diff --git a/.gitignore b/.gitignore index ae4f746e..d98e2288 100644 --- a/.gitignore +++ b/.gitignore @@ -20,6 +20,9 @@ docs/source/**/.ipynb_checkpoints # dask worker space docs/source/**/dask-worker-space +# cached simulation results +docs/source/**/cache + # vscode .vscode diff --git a/docs/source/examples.rst b/docs/source/examples.rst index 9e80c70d..a1de2428 100644 --- a/docs/source/examples.rst +++ b/docs/source/examples.rst @@ -6,6 +6,7 @@ Examples Structure Heat Microscopic 3-Temperature-Model + Landau-Lifshitz-Bloch Phonons Dynamical Xray Scattering Dynamical Magnetic Xray Scattering \ No newline at end of file diff --git a/docs/source/examples/LLB.ipynb b/docs/source/examples/LLB.ipynb new file mode 100644 index 00000000..efd7fe47 --- /dev/null +++ b/docs/source/examples/LLB.ipynb @@ -0,0 +1,1011 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b8b93729-7ae5-4edb-8aaf-d4d32bd24caf", + "metadata": {}, + "source": [ + "# Landau-Lifshitz-Bloch simulations" + ] + }, + { + "cell_type": "markdown", + "id": "cf660cae-16c0-4450-8f27-8977ad536895", + "metadata": { + "tags": [] + }, + "source": [ + "Here we calculate the vectorial magnetization dynamic in a magnetic heterostructure employing the mean-field quantum Landau-Lifshitz-Bloch (LLB) apporach. Please read the following review to get an overview of the LLB equation in ultrafast magnetism\n", + "\n", + "U. Atxitia, D. Hinzke, and U. Nowak, \n", + "*Fundamentals and Applications of the Landau-Lifshitz-Bloch Equation*,\n", + "[J. Phys. D. Appl. Phys. 50, (2017).](https://doi.org/10.1088/1361-6463/50/3/033003)\n", + "\n", + "Here we need to solve the following differential equation:\n", + "\n", + "\\begin{align*}\n", + "\\frac{d\\mathbf{m}}{dt}=\\gamma_e \\left(\\mathbf{m} \\times\n", + " \\mathbf{H}_\\mathrm{eff} + \\frac{\\alpha_{\\perp}}{m^2}\\mathbf{m}\n", + " \\times (\\mathbf{m} \\times \\mathbf{H}_\\mathrm{eff}) -\n", + " \\frac{\\alpha_{\\parallel}}{m^2}(\\mathbf{m} \\cdot\n", + " \\mathbf{H}_\\mathrm{eff}) \\cdot \\mathbf{m}\\right)\n", + "\\end{align*}\n", + "\n", + "The three terms describe\n", + "\n", + "1. **precession** at Larmor frequency,\n", + "2. **transversal damping** (conserving the macrospin length), and\n", + "3. **longitudinal damping** (changing macrospin length due to incoherent\n", + " atomistic spin excitations within the layer the macrospin is\n", + " defined on).\n", + "\n", + "$\\alpha_{\\parallel}$ and $\\alpha_{\\perp}$ are the longitudinal damping and transverse damping parameters, respectively.\n", + "$\\gamma_e = -1.761\\times10^{11}\\,\\mathrm{rad\\,s^{-1}\\,T^{-1}}$ is\n", + "the gyromagnetic ratio of an electron.\n", + "\n", + "The effective magnetic field is the sum of all relevant magnetic\n", + "interactions:\n", + "\n", + "\\begin{align*}\n", + " \\mathbf{H}_\\mathrm{eff} = \\mathbf{H}_\\mathrm{ext}\n", + " + \\mathbf{H}_\\mathrm{A}\n", + " + \\mathbf{H}_\\mathrm{ex}\n", + " + \\mathbf{H}_\\mathrm{th}\n", + "\\end{align*}\n", + "\n", + "where\n", + "\n", + "* $\\mathbf{H}_\\mathrm{ext}$ is the external magnetic field\n", + "* $\\mathbf{H}_\\mathrm{A}$ is the uniaxial anisotropy field\n", + "* $\\mathbf{H}_\\mathrm{ex}$ is the exchange field\n", + "* $\\mathbf{H}_\\mathrm{th}$ is the thermal field\n", + "\n", + "The definitions of these subterms are described in their respective [API documentation](../magnetization.html#udkm1Dsim.simulations.magnetization.LLB).\n", + "\n", + "**The material parameters of the current example arbritarily chosen.**" + ] + }, + { + "cell_type": "markdown", + "id": "cd4c34ca-9054-4dc2-9f36-66065e7f9f65", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Do all necessary imports and settings." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "92d3431e-2b84-4f20-93a6-1709d275af9f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import udkm1Dsim as ud\n", + "u = ud.u # import the pint unit registry from udkm1Dsim\n", + "import scipy.constants as constants\n", + "import numpy as np\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "u.setup_matplotlib() # use matplotlib with pint units" + ] + }, + { + "cell_type": "markdown", + "id": "3767f02e-ae8e-4cb6-b12f-a13e76b710bc", + "metadata": {}, + "source": [ + "## Structure\n", + "\n", + "Refer to the [structure-example](structure.ipynb) for more details. \n", + "We are providing a magnetization of the atoms which are used as initial magnetization in the LLB simulations, in case no specific initial condition is provided by the user." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bf76219d-f422-456e-b5cc-33e5ce7f1c15", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "Co = ud.Atom('Co', mag_amplitude=1, mag_gamma=0*u.deg, mag_phi=0*u.deg)\n", + "Ni = ud.Atom('Ni', mag_amplitude=1, mag_gamma=90*u.deg, mag_phi=0*u.deg)\n", + "Fe = ud.Atom('Fe', mag_amplitude=1, mag_gamma=0*u.deg, mag_phi=90*u.deg)\n", + "Si = ud.Atom('Si')" + ] + }, + { + "cell_type": "markdown", + "id": "b45a1cc6-5a6e-450d-9205-8a250163d6a7", + "metadata": {}, + "source": [ + "Solving the LLB requries several additional parameters of the accoriding `Layer` objects:\n", + "\n", + "* `eff_spin` - effective spin\n", + "* `curie_temp` - Curie temperature\n", + "* `lamda` - damping parameter (mispelled because of python `lambda`-functions)\n", + "* `mag_moment` - atomic magnetic moment\n", + "* `aniso_exponent` - exponent of the uniaxial anisotropy\n", + "* `anisotropy` - vector of the anisotropy $[K_x, K_y, K_z]$\n", + "* `exch_stiffness` - vector of the exchange stiffness $[A_{i\\rightarrow (i-1)}, A_{i\\rightarrow i}, A_{i\\rightarrow (i+1)}]$\n", + "* `mag_saturation` - zero temperature saturation magnetization\n", + "\n", + "The correct physical units and more details are documented in the [Layer API](../layers.html#udkm1Dsim.structures.layers.Layer)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4ca2fc14-5504-4fee-9fe4-040abfc886a1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of subsystems changed from 1 to 2.\n" + ] + } + ], + "source": [ + "prop_Ni = {}\n", + "# two-temperture model\n", + "prop_Ni['heat_capacity'] = ['0.1*T',\n", + " 532*u.J/u.kg/u.K,\n", + " ]\n", + "prop_Ni['therm_cond'] = [20*u.W/(u.m*u.K),\n", + " 80*u.W/(u.m*u.K),]\n", + "g = 4.0e18 # electron-phonon coupling\n", + "prop_Ni['sub_system_coupling'] = \\\n", + " ['-{:f}*(T_0-T_1)'.format(g),\n", + " '{:f}*(T_0-T_1)'.format(g)\n", + " ]\n", + "prop_Ni['lin_therm_exp'] = [0, 11.8e-6]\n", + "prop_Ni['opt_ref_index'] = 2.9174+3.3545j\n", + "\n", + "# LLB parameters\n", + "prop_Ni['eff_spin'] = 0.5\n", + "prop_Ni['curie_temp'] = 630*u.K\n", + "prop_Ni['lamda'] = 0.005\n", + "prop_Ni['mag_moment'] = 0.393*u.bohr_magneton\n", + "prop_Ni['aniso_exponent'] = 3\n", + "prop_Ni['anisotropy'] = [0.45e6, 0.45e6, 0.45e6]*u.J/u.m**3\n", + "prop_Ni['exch_stiffness'] = [0.1e-15, 1e-15, 0.01e-15]*u.J/u.m\n", + "prop_Ni['mag_saturation'] = 500e3*u.J/u.T/u.m**3\n", + "\n", + "# build the layer\n", + "layer_Ni = ud.AmorphousLayer('Ni', 'Ni amorphous', thickness=1*u.nm,\n", + " density=7000*u.kg/u.m**3, atom=Ni, **prop_Ni)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "959d687a-cc4b-45a0-9f1b-166ac82fc503", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of subsystems changed from 1 to 2.\n" + ] + } + ], + "source": [ + "# similar to Ni layer\n", + "prop_Co = {}\n", + "prop_Co['heat_capacity'] = ['0.1*T',\n", + " 332*u.J/u.kg/u.K,\n", + " ]\n", + "prop_Co['therm_cond'] = [20*u.W/(u.m*u.K),\n", + " 80*u.W/(u.m*u.K),]\n", + "g = 5.0e18\n", + "prop_Co['sub_system_coupling'] = \\\n", + " ['-{:f}*(T_0-T_1)'.format(g),\n", + " '{:f}*(T_0-T_1)'.format(g)\n", + " ]\n", + "prop_Co['lin_therm_exp'] = [0, 11.8e-6]\n", + "prop_Co['opt_ref_index'] = 2.9174+3.3545j\n", + "\n", + "prop_Co['eff_spin'] = 3\n", + "prop_Co['curie_temp'] = 1480*u.K\n", + "prop_Co['lamda'] = 0.005\n", + "prop_Co['mag_moment'] = 0.393*u.bohr_magneton\n", + "prop_Co['aniso_exponent'] = 3\n", + "prop_Co['anisotropy'] = [0.45e6, 0.45e6, 0.45e6]*u.J/u.m**3\n", + "prop_Co['exch_stiffness'] = [0.2e-15, 2e-15, 0.02e-15]*u.J/u.m\n", + "prop_Co['mag_saturation'] = 1400e3*u.J/u.T/u.m**3\n", + "\n", + "layer_Co = ud.AmorphousLayer('Co', 'Co amorphous', thickness=1*u.nm,\n", + " density=7000*u.kg/u.m**3, atom=Co, **prop_Co)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fb894e96-91e6-4553-95f2-ae208d3089e4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of subsystems changed from 1 to 2.\n" + ] + } + ], + "source": [ + "# similar to Ni layer\n", + "prop_Fe = {}\n", + "prop_Fe['heat_capacity'] = ['0.1*T',\n", + " 732*u.J/u.kg/u.K,\n", + " ]\n", + "prop_Fe['therm_cond'] = [20*u.W/(u.m*u.K),\n", + " 80*u.W/(u.m*u.K),]\n", + "g = 6.0e18\n", + "prop_Fe['sub_system_coupling'] = \\\n", + " ['-{:f}*(T_0-T_1)'.format(g),\n", + " '{:f}*(T_0-T_1)'.format(g)\n", + " ]\n", + "prop_Fe['lin_therm_exp'] = [0, 11.8e-6]\n", + "prop_Fe['opt_ref_index'] = 2.9174+3.3545j\n", + "\n", + "prop_Fe['eff_spin'] = 2\n", + "prop_Fe['curie_temp'] = 1024*u.K\n", + "prop_Fe['lamda'] = 0.005\n", + "prop_Fe['mag_moment'] = 2.2*u.bohr_magneton\n", + "prop_Fe['aniso_exponent'] = 3\n", + "prop_Fe['anisotropy'] = [0.45e6, 0.45e6, 0.45e6]*u.J/u.m**3\n", + "prop_Fe['exch_stiffness'] = [0.3e-15, 3e-17, 0.03e-15]*u.J/u.m\n", + "prop_Fe['mag_saturation'] = 200e3*u.J/u.T/u.m**3\n", + "\n", + "layer_Fe = ud.AmorphousLayer('Fe', 'Fe amorphous', thickness=1*u.nm,\n", + " density=7000*u.kg/u.m**3, atom=Fe, **prop_Fe)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "645ee3c5-01aa-458a-b8f4-93c99ecf7a2b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of subsystems changed from 1 to 2.\n" + ] + } + ], + "source": [ + "# this is the non-magnetic substrate\n", + "prop_Si = {}\n", + "prop_Si['heat_capacity'] = [100*u.J/u.kg/u.K, 603*u.J/u.kg/u.K]\n", + "prop_Si['therm_cond'] = [0, 100*u.W/(u.m*u.K)]\n", + "\n", + "prop_Si['sub_system_coupling'] = [0, 0]\n", + "\n", + "prop_Si['lin_therm_exp'] = [0, 2.6e-6]\n", + "prop_Si['sound_vel'] = 8.433*u.nm/u.ps\n", + "prop_Si['opt_ref_index'] = 3.6941+0.0065435j\n", + "\n", + "layer_Si = ud.AmorphousLayer('Si', \"Si amorphous\", thickness=1*u.nm, density=2336*u.kg/u.m**3,\n", + " atom=Si, **prop_Si)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d93b60d2-c329-4c2a-aed0-3466ff0cefdb", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "S = ud.Structure('NiCoFeNi')\n", + "\n", + "S.add_sub_structure(layer_Ni, 10)\n", + "S.add_sub_structure(layer_Co, 15)\n", + "S.add_sub_structure(layer_Fe, 10)\n", + "S.add_sub_structure(layer_Ni, 25)\n", + "S.add_sub_structure(layer_Si, 200)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "256ee59a-a00a-42bf-8035-05417317b644", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "S.visualize()" + ] + }, + { + "cell_type": "markdown", + "id": "2ebb7482-edd9-4287-9d16-39bfc9003ffa", + "metadata": {}, + "source": [ + "## Initialize Heat and the Excitation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ff2c8311-3140-4028-8eb3-eca39514d3fd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "h = ud.Heat(S, True)\n", + "\n", + "h.save_data = False\n", + "h.disp_messages = True" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e46146bb-ac15-4cc5-8372-d3448f1988d0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "h.excitation = {'fluence': [25]*u.mJ/u.cm**2,\n", + " 'delay_pump': [0]*u.ps,\n", + " 'pulse_width': [0.15]*u.ps,\n", + " 'multilayer_absorption': True,\n", + " 'wavelength': 800*u.nm,\n", + " 'theta': 45*u.deg}\n", + "# temporal and spatial grid\n", + "delays = np.r_[-10:10:0.05, 10:200:0.5]*u.ps\n", + "_, _, distances = S.get_distances_of_layers()" + ] + }, + { + "cell_type": "markdown", + "id": "77e5ba0a-3b94-4539-9659-f13112805e3c", + "metadata": {}, + "source": [ + "## Calculate Heat Diffusion for 2-Temperature Model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "daf4037c-bb4d-470c-b18e-2ccb68860b7f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Surface incidence fluence scaled by factor 0.7071 due to incidence angle theta=45.00 deg\n", + "Calculating _heat_diffusion_ for excitation 1:1 ...\n", + "Absorption profile is calculated by multilayer formalism.\n", + "Total reflectivity of 46.5 % and transmission of 4.0 %.\n" + ] + }, + { + "data": { + "application/json": { + "ascii": false, + "bar_format": null, + "colour": null, + "elapsed": 0.022295713424682617, + "initial": 0, + "n": 0, + "ncols": null, + "nrows": 59, + "postfix": null, + "prefix": "", + "rate": null, + "total": null, + "unit": "it", + "unit_divisor": 1000, + "unit_scale": false + }, + "application/vnd.jupyter.widget-view+json": { + "model_id": "20f0b3df949447909f7183079b9a427f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Elapsed time for _heat_diffusion_ with 1 excitation(s): 20.021503 s\n", + "Calculating _heat_diffusion_ without excitation...\n" + ] + }, + { + "data": { + "application/json": { + "ascii": false, + "bar_format": null, + "colour": null, + "elapsed": 0.022442102432250977, + "initial": 0, + "n": 0, + "ncols": null, + "nrows": 59, + "postfix": null, + "prefix": "", + "rate": null, + "total": null, + "unit": "it", + "unit_divisor": 1000, + "unit_scale": false + }, + "application/vnd.jupyter.widget-view+json": { + "model_id": "6604962ec957436cb2c4824f58549bd4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Elapsed time for _heat_diffusion_: 34.726814 s\n", + "Elapsed time for _temp_map_: 54.925221 s\n" + ] + } + ], + "source": [ + "# enable heat diffusion\n", + "h.heat_diffusion = True\n", + "# set the boundary conditions\n", + "h.boundary_conditions = {'top_type': 'isolator', 'bottom_type': 'isolator'}\n", + "# The resulting temperature profile is calculated in one line:\n", + "\n", + "temp_map, delta_temp = h.get_temp_map(delays, 300)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2b5e183e-fb49-48ef-84a7-11e68411d953", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[6, 8])\n", + "plt.subplot(2, 1, 1)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, temp_map[:, :, 0],\n", + " shading='auto')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('Temperature Map Electrons')\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, temp_map[:, :, 1],\n", + " shading='auto')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('Temperature Map Phonons')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5dda2842-980f-4bcc-82b2-08de983a504a", + "metadata": {}, + "source": [ + "## Landau-Lifshitz-Bloch Simulations\n", + "\n", + "The `LLB` class requires a `Structure` object and a boolean `force_recalc` in order to overwrite previous simulation results.\n", + "\n", + "These results are saved in the `cache_dir` when `save_data` is enabled.\n", + "Printing simulation messages can be en-/disabled using `disp_messages` and progress bars can using the boolean switch `progress_bar`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fb4748eb-757a-456b-a56c-de670aa9ab97", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Landau-Lifshitz-Bloch Magnetization Dynamics simulation properties:\n", + "\n", + "Magnetization simulation properties:\n", + "\n", + "This is the current structure for the simulations:\n", + "\n", + "Structure properties:\n", + "\n", + "Name : NiCoFeNi\n", + "Thickness : 260.00 nanometer\n", + "Roughness : 0.00 nanometer\n", + "----\n", + "10 times Ni amorphous: 10.00 nanometer\n", + "15 times Co amorphous: 15.00 nanometer\n", + "10 times Fe amorphous: 10.00 nanometer\n", + "25 times Ni amorphous: 25.00 nanometer\n", + "200 times Si amorphous: 200.00 nanometer\n", + "----\n", + "no substrate\n", + "\n", + "\n", + "Display properties:\n", + "\n", + "================ =======\n", + " parameter value\n", + "================ =======\n", + " force recalc True\n", + " cache directory ./\n", + "display messages True\n", + " save data False\n", + " progress bar True\n", + "================ =======\n" + ] + } + ], + "source": [ + "llb = ud.LLB(S, True)\n", + "\n", + "llb.save_data = False\n", + "llb.disp_messages = True\n", + "\n", + "print(llb)" + ] + }, + { + "cell_type": "markdown", + "id": "78494782-c203-4fb4-b0b2-82c681e668c0", + "metadata": { + "tags": [] + }, + "source": [ + "### Brillouin Function\n", + "\n", + "Internally, the LLB calculates a mean-field magnetization map for the according electron temperatures\n", + "$T_e$ at for every layer and for every time step. This done by solving the *Brillouin* function of each\n", + "layer and then mapping the result onto the according spatio-temporal grid, as given by the `temp_map`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "fd301e0c-bb45-4aca-902c-51a816c4b2b5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating _mean_field_magnetization_map_ ...\n", + "Elapsed time for _mean_field_magnetization_map_: 1.763555 s\n" + ] + } + ], + "source": [ + "mean_field_mag_map = llb.get_mean_field_mag_map(temp_map[:, :, 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "577a30ba-aae9-41d0-97c8-267139919763", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[6, 8])\n", + "\n", + "plt.subplot(2, 1, 1)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, temp_map[:, :, 0],\n", + " shading='auto')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('Temperature Map Electrons')\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, mean_field_mag_map, shading='auto')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('Mean-Field magnetization')\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "16217c36-6b3c-4ea9-9473-b6c7f810294b", + "metadata": {}, + "source": [ + "In order to run the actual LLB simulation, an optional initial magnetization `init_mag` as well as an external magnetic field `H_ext` can be provided.\n", + "While `H_ext` is provided in cartesian coordinates $[H_x, H_y, H_z]$ in Tesla, the initial magnetization is given in plolar coordinates $[A, \\phi, \\gamma]$ in units of [none, rad, rad], following the definitions shown in the [user guide](../user_guide.html#).\n", + "\n", + "Running the simulation is done by calling the `get_magnetization_map` method which requires a `delay` vector as well as the `temp_map`.\n", + "The resulting `magnetization_map` is returned in **polar coordinates**." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4471c839-e43d-4b67-a27b-3290f5bb6ce6", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating _magnetization_map_ ...\n", + "Calculating _mean_field_magnetization_map_ ...\n", + "Elapsed time for _mean_field_magnetization_map_: 1.800176 s\n" + ] + }, + { + "data": { + "application/json": { + "ascii": false, + "bar_format": null, + "colour": null, + "elapsed": 0.025523900985717773, + "initial": 0, + "n": 0, + "ncols": null, + "nrows": 59, + "postfix": null, + "prefix": "", + "rate": null, + "total": null, + "unit": "it", + "unit_divisor": 1000, + "unit_scale": false + }, + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d7aec774fcb44e3be6d3b8aaba4f2b4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Elapsed time for _LLB_: 2.235245 s\n", + "Elapsed time for _magnetization_map_: 2.237341 s\n" + ] + } + ], + "source": [ + "init_mag = np.array([1.0, (0.*u.deg).to('rad').magnitude, (0*u.deg).to('rad').magnitude])\n", + "\n", + "magnetization_map = llb.get_magnetization_map(delays, temp_map=temp_map, init_mag=init_mag,\n", + " H_ext=np.array([0, 0.05, 1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ef800a4b-0f79-4cbf-8c92-807088304741", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[6, 12])\n", + "plt.subplot(3, 1, 1)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, magnetization_map[:, :, 0],\n", + " shading='auto', cmap='plasma')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('$A$')\n", + "\n", + "plt.subplot(3, 1, 2)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, magnetization_map[:, :, 1],\n", + " shading='auto', cmap='plasma')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('$\\phi$')\n", + "\n", + "plt.subplot(3, 1, 3)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, magnetization_map[:, :, 2],\n", + " shading='auto', cmap='plasma')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('$\\gamma$')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "91770761-06f9-41aa-a784-fd10bf0e38e9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[6,8])\n", + "plt.subplot(2,1,1)\n", + "plt.plot(delays, np.mean(magnetization_map[:, 0:10, 0], axis=1), label=r'$A$')\n", + "plt.legend()\n", + "plt.xlabel('Delay (ps)')\n", + "plt.ylabel('Magnetization')\n", + "plt.subplot(2,1,2)\n", + "plt.plot(delays, (np.mean(magnetization_map[:, 0:10, 1], axis=1)*u.rad).to('deg'), label=r'$\\phi$')\n", + "plt.plot(delays, (np.mean(magnetization_map[:, 0:10, 2], axis=1)*u.rad).to('deg'), label=r'$\\gamma$')\n", + "plt.legend()\n", + "plt.xlabel('Delay (ps)')\n", + "plt.ylabel('Magnetization')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "492690bd-2122-45f3-b6ba-2281080911b6", + "metadata": {}, + "source": [ + "The `magnetization` class provides helper methods to convert the result also into cartesian coordinates:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d499a874-55d6-40d5-acf0-4a1a81fad066", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "magnetization_map_xyz = ud.LLB.convert_polar_to_cartesian(magnetization_map)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "a69aec0c-bfc8-4416-b8ba-b7c19d73ca6e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[6, 12])\n", + "plt.subplot(3, 1, 1)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, magnetization_map_xyz[:, :, 0],\n", + " shading='auto', cmap='plasma')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('$M_x$')\n", + "\n", + "plt.subplot(3, 1, 2)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, magnetization_map_xyz[:, :, 1],\n", + " shading='auto', cmap='plasma')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('$M_y$')\n", + "\n", + "plt.subplot(3, 1, 3)\n", + "plt.pcolormesh(distances.to('nm').magnitude, delays.to('ps').magnitude, magnetization_map_xyz[:, :, 2],\n", + " shading='auto', cmap='plasma')\n", + "plt.colorbar()\n", + "plt.xlabel('Distance [nm]')\n", + "plt.ylabel('Delay [ps]')\n", + "plt.title('$M_z$')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "9a26a4fc-ec9a-4658-8601-52b55a5a29c5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[6,8])\n", + "plt.subplot(2,1,1)\n", + "plt.plot(delays, np.mean(magnetization_map_xyz[:, 0:10, 2], axis=1), label=r'$M_z$')\n", + "plt.legend()\n", + "plt.xlabel('Delay (ps)')\n", + "plt.ylabel('Magnetization')\n", + "plt.subplot(2,1,2)\n", + "plt.plot(delays, np.mean(magnetization_map_xyz[:, 0:10, 0], axis=1), label=r'$M_x$')\n", + "plt.plot(delays, np.mean(magnetization_map_xyz[:, 0:10, 1], axis=1), label=r'$M_y$')\n", + "plt.legend()\n", + "plt.xlabel('Delay (ps)')\n", + "plt.ylabel('Magnetization')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "16656a39-4c46-4d07-ba93-0aaf784c82f8", + "metadata": {}, + "source": [ + "In both plot it is obvious, that the magnetization already starts to change before the actual laser excitation raises the electronic temperatures.\n", + "This is because of the misalignment of the initial magnetization and the external magnetic field.\n", + "To avoid this, the steady-state solution of the layer magnetization must be found first and used as `init_mag` for the actual transient simulations." + ] + } + ], + "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.8.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/udkm1Dsim/__init__.py b/udkm1Dsim/__init__.py index a8dd95ae..bf3f9969 100644 --- a/udkm1Dsim/__init__.py +++ b/udkm1Dsim/__init__.py @@ -8,11 +8,11 @@ from .simulations.simulation import Simulation from .simulations.heat import Heat from .simulations.phonons import Phonon, PhononNum, PhononAna -from .simulations.magnetization import Magnetization +from .simulations.magnetization import Magnetization, LLB from .simulations.xrays import Xray, XrayKin, XrayDyn, XrayDynMag __all__ = ['Atom', 'AtomMixed', 'Layer', 'AmorphousLayer', 'UnitCell', 'Structure', - 'Simulation', 'Heat', 'Phonon', 'PhononNum', 'PhononAna', 'Magnetization', + 'Simulation', 'Heat', 'Phonon', 'PhononNum', 'PhononAna', 'Magnetization', 'LLB', 'Xray', 'XrayKin', 'XrayDyn', 'XrayDynMag', 'u', 'Q_'] __version__ = '1.5.6' diff --git a/udkm1Dsim/simulations/magnetization.py b/udkm1Dsim/simulations/magnetization.py index 5b961490..e99c4063 100644 --- a/udkm1Dsim/simulations/magnetization.py +++ b/udkm1Dsim/simulations/magnetization.py @@ -22,15 +22,20 @@ # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE # OR OTHER DEALINGS IN THE SOFTWARE. -__all__ = ['Magnetization'] +__all__ = ['Magnetization', 'LLB'] __docformat__ = 'restructuredtext' from .simulation import Simulation -from ..helpers import make_hash_md5 +from .. import u, Q_ +from ..helpers import make_hash_md5, finderb import numpy as np +from scipy.integrate import solve_ivp +from scipy.optimize import fsolve +import scipy.constants as constants from time import time from os import path +from tqdm.notebook import tqdm class Magnetization(Simulation): @@ -57,19 +62,28 @@ class Magnetization(Simulation): disp_messages (boolean): true to display messages from within the simulations. progress_bar (boolean): enable tqdm progress bar. + ode_options (dict): options for scipy solve_ivp ode solver """ def __init__(self, S, force_recalc, **kwargs): super().__init__(S, force_recalc, **kwargs) + self.ode_options = { + 'method': 'RK45', + 'first_step': None, + 'max_step': np.inf, + 'rtol': 1e-3, + 'atol': 1e-6, + } def __str__(self, output=[]): """String representation of this class""" + class_str = 'Magnetization simulation properties:\n\n' class_str += super().__str__(output) return class_str - def get_hash(self, delays, **kwargs): + def get_hash(self, **kwargs): """get_hash Calculates an unique hash given by the delays as well as the sample @@ -78,14 +92,15 @@ def get_hash(self, delays, **kwargs): Args: delays (ndarray[float]): delay grid for the simulation. - **kwargs (ndarray[float], optional): optional strain and - temperature profile. + **kwargs (ndarray[float], optional): optional delays, strain and + temperature profile as well as external magnetic field and + initial magnetization. Returns: hash (str): unique hash. """ - param = [delays] + param = [] if 'strain_map' in kwargs: strain_map = kwargs.get('strain_map') @@ -106,28 +121,104 @@ def get_hash(self, delays, **kwargs): return self.S.get_hash(types='magnetic') + '_' + make_hash_md5(param) + def check_initial_magnetization(self, init_mag, distances=[]): + """check_initial_magnetization + + Check if a given initial magnetization profile is valid. The profile + must be either a vector `[amplitude, phi, gamma]` describing a global + initial magnetization or an array of shape `[Nx3]` with N being the + number of layers or the length of the specific spatial grid. If no + initial magnetization is given, the initial profile is determined from + the magnetization of the layers on creation. In addition, a spatial + grid can be provided. + + Args: + init_mag (ndarray[float]): initial global or local magnetization + profile. + distances (ndarray[float, Quantity], optional): spatial grid of the + initial magnetization. + + Returns: + init_mag (ndarray[float]): checked initial magnetization as array on + the according spatial grid. + + """ + try: + distances = distances.to('m').magnitude + except AttributeError: + pass + + if distances == []: + # no spatial grid is provided + N = self.S.get_number_of_layers() + [distances, _, _] = self.S.get_distances_of_layers(False) + else: + N = len(distances) + + if len(init_mag) == 0: + self.disp_message('No explicit initial magnetization given ' + '- use magnetization of layers instead.') + init_mag = np.zeros([N, 3]) + # use finderb search to find the corresponding indices between the + # internal and external spatial grids + [d_start, _, _] = self.S.get_distances_of_layers(False) + idx = finderb(distances, d_start) + + magnetizations = self.S.get_layer_property_vector('_magnetization') + init_mag[:, 0] = np.array([mag['amplitude'] for mag in magnetizations])[idx] + init_mag[:, 1] = np.array([mag['phi'] for mag in magnetizations])[idx] + init_mag[:, 2] = np.array([mag['gamma'] for mag in magnetizations])[idx] + else: + if np.size(init_mag) == 3: + # it is the same initial magnetization for all layers + init_mag = np.tile(init_mag, (N, 1)) + elif np.shape(init_mag) != (N, 3): + # init_temp is a vector but has not as many elements as layers + raise ValueError('The initial magnetization array must have 3 or ' + 'Nx3 elements, where N is the number of layers ' + 'in the structure or the length of the spatial ' + 'grid provided as distances vector!') + + # convert phi and gamma to rad and store only magnitudes + try: + init_mag[:, 1] = init_mag[:, 1].to('rad').magnitude + except AttributeError: + pass + try: + init_mag[:, 2] = init_mag[:, 2].to('rad').magnitude + except AttributeError: + pass + return init_mag + def get_magnetization_map(self, delays, **kwargs): - """get_magnetization_map + r"""get_magnetization_map - Returns an absolute `magnetization_map` for the sample structure. - The angles for `gamma` and `phi` must be in radians as pure numpy - arrays. - The `magnetization_map` can depend on the ``temp_map`` and + Returns an absolute ``magnetization_map`` for the sample structure with + the dimension :math:`M \times N \times 3` with :math:`M` being the + number of delays and :math:`N` the number of layers in the structure or + the length of the given spatial grid. Each element of the map contains + the three magnetization components ``[amplitude, phi, gamma]``. + The angles ``phi`` and ``gamma`` must be returned in radians as pure + numpy arrays. + The ``magnetization_map`` can depend on the ``temp_map`` and ``strain_map`` that can be also calculated for the sample structure. + More over an external magnetic field ``H_ext`` and initial magnetization + profile ``init_mag`` can be provided. Args: delays (ndarray[Quantity]): delays range of simulation [s]. **kwargs (ndarray[float], optional): optional strain and - temperature profile. + temperature profile as well external magnetic field in [T] and + initial magnetization. Returns: magnetization_map (ndarray[float]): spatio-temporal absolute - magnetization profile. + magnetization profile. """ # create a hash of all simulation parameters filename = 'magnetization_map_' \ - + self.get_hash(delays, **kwargs) \ + + self.get_hash(delays=delays, **kwargs) \ + '.npz' full_filename = path.abspath(path.join(self.cache_dir, filename)) # check if we find some corresponding data in the cache dir @@ -147,6 +238,19 @@ def get_magnetization_map(self, delays, **kwargs): if ('temp_map' in kwargs): if not isinstance(kwargs['temp_map'], np.ndarray): raise TypeError('temp_map must be a numpy ndarray!') + if ('H_ext' in kwargs): + if not isinstance(kwargs['H_ext'], np.ndarray): + raise TypeError('H_ext must be a numpy ndarray!') + elif kwargs['H_ext'].shape != (3,): + raise ValueError('H_ext must be a vector with 3 components ' + '(H_x, H_y, H_z)!') + if ('init_mag' in kwargs): + if not isinstance(kwargs['init_mag'], np.ndarray): + raise TypeError('init_mag must be a numpy ndarray with ' + 'all in radians without units!') + elif kwargs['init_mag'].shape != (3,): + raise ValueError('init_mag must be a vector with Nx3 ' + 'with N being the number of layers.') magnetization_map = self.calc_magnetization_map(delays, **kwargs) @@ -159,11 +263,8 @@ def get_magnetization_map(self, delays, **kwargs): def calc_magnetization_map(self, delays, **kwargs): """calc_magnetization_map - Calculates an absolute ``magnetization_map`` for the sample structure. - The angles for `gamma` and `phi` must be in radians as pure numpy - arrays. - The ``magnetization_map`` can depend on the ``temp_map`` and - ``strain_map`` that can be also calculated for the sample structure. + Calculates an absolute ``magnetization_map`` - see + :meth:`get_magnetization_map` for details. This method is just an interface and should be overwritten for the actual simulations. @@ -171,11 +272,945 @@ def calc_magnetization_map(self, delays, **kwargs): Args: delays (ndarray[Quantity]): delays range of simulation [s]. **kwargs (ndarray[float], optional): optional strain and - temperature profile. + temperature profile as well external magnetic field and initial + magnetization. Returns: magnetization_map (ndarray[float]): spatio-temporal absolute - magnetization profile. + magnetization profile. """ raise NotImplementedError + + @staticmethod + def convert_polar_to_cartesian(polar): + r"""convert_polar_to_cartesian + + Convert a vector or field from polar coordinates + :math:`(r, \phi, \gamma)` to cartesian coordinates :math:`(x, y, z)`: + + .. math:: + + F_x & = r \sin(\phi)\cos(\gamma) \\ + F_y & = r \sin(\phi)\sin(\gamma) \\ + F_z & = r \cos(\phi) + + where :math:`r`, :math:`\phi`, :math:`\gamma` are the radius + (amplitude), azimuthal, and polar angles of vector field + :math:`\mathbf{F}`, respectively. + + Args: + polar (ndarray[float]): vector of field to convert. + + Returns: + cartesian (ndarray[float]): converted vector or field. + + """ + cartesian = np.zeros_like(polar) + + amplitudes = polar[..., 0] + phis = polar[..., 1] + gammas = polar[..., 2] + cartesian[..., 0] = amplitudes*np.sin(phis)*np.cos(gammas) + cartesian[..., 1] = amplitudes*np.sin(phis)*np.sin(gammas) + cartesian[..., 2] = amplitudes*np.cos(phis) + + return cartesian + + @staticmethod + def convert_cartesian_to_polar(cartesian): + r"""convert_cartesian_to_polar + + Convert a vector or field from cartesian coordinates :math:`(x, y, z)` + to polar coordinates :math:`(r, \phi, \gamma)`: + + .. math:: + + F_r & = \sqrt{F_x^2 + F_y^2+F_z^2}\\ + F_{\phi} & = \begin{cases}\\ + \arctan\left(\frac{F_y}{F_x} \right) & \mathrm{for}\ F_x > 0 \\ + \pi + \arctan\left(\frac{F_y}{F_x}\right) + & \mathrm{for}\ F_x < 0 \ \mathrm{and}\ F_y \geq 0 \\ + \arctan\left(\frac{F_y}{F_x}\right) - \pi + & \mathrm{for}\ F_x < 0 \ \mathrm{and}\ F_y < 0 \\ + 0 & \mathrm{for}\ F_x = F_y = 0 + \end{cases} \\ + F_{\gamma} & = \arccos\left(\frac{F_z}{F_r} \right) + + where :math:`F_r`, :math:`F_{\phi}`, :math:`F_{\gamma}` are the radial + (amplitude), azimuthal, and polar component of vector field + :math:`\mathbf{F}`, respectively. + + Args: + cartesian (ndarray[float]): vector of field to convert. + + Returns: + polar (ndarray[float]): converted vector or field. + + """ + polar = np.zeros_like(cartesian) + xs = cartesian[..., 0] + ys = cartesian[..., 1] + zs = cartesian[..., 2] + amplitudes = np.sqrt(xs**2 + ys**2 + zs**2) + mask = amplitudes != 0. # mask for non-zero amplitudes + polar[..., 0] = amplitudes + polar[mask, 1] = np.arccos(np.divide(zs[mask], amplitudes[mask])) + polar[..., 2] = np.arctan2(ys, xs) + + return polar + + +class LLB(Magnetization): + """LLB + + Mean-field quantum Landau-Lifshitz-Bloch simulations. + + Please find a detailed review on the Landau-Lifshitz-Bloch equation by + Unai Atxitia et al. [11]_. + + In collaboration with Theodor Griepe + (`@Nilodirf `_) from the group of + Unai Atxitia at Instituto de Ciencia de Materiales de Madrid (ICMM-CSIC). + + Args: + S (Structure): sample to do simulations with. + force_recalc (boolean): force recalculation of results. + + Keyword Args: + save_data (boolean): true to save simulation results. + cache_dir (str): path to cached data. + disp_messages (boolean): true to display messages from within the + simulations. + progress_bar (boolean): enable tqdm progress bar. + + Attributes: + S (Structure): sample structure to calculate simulations on. + force_recalc (boolean): force recalculation of results. + save_data (boolean): true to save simulation results. + cache_dir (str): path to cached data. + disp_messages (boolean): true to display messages from within the + simulations. + progress_bar (boolean): enable tqdm progress bar. + + References: + + .. [11] [1] U. Atxitia, D. Hinzke, and U. Nowak, + *Fundamentals and Applications of the Landau-Lifshitz-Bloch Equation*, + `J. Phys. D. Appl. Phys. 50, (2017). + `_ + + """ + + def __init__(self, S, force_recalc, **kwargs): + super().__init__(S, force_recalc, **kwargs) + + def __str__(self): + """String representation of this class""" + class_str = 'Landau-Lifshitz-Bloch Magnetization Dynamics simulation ' \ + 'properties:\n\n' + class_str += super().__str__() + return class_str + + def calc_magnetization_map(self, delays, temp_map, H_ext=np.array([0, 0, 0]), init_mag=[]): + r"""calc_magnetization_map + + Calculates the magnetization map using the mean-field quantum + Landau-Lifshitz-Bloch equation (LLB) for a given delay range and + according temperature map: + + .. math:: + + \frac{d\mathbf{m}}{dt}=\gamma_e \left(\mathbf{m} \times + \mathbf{H}_\mathrm{eff} + \frac{\alpha_{\perp}}{m^2}\mathbf{m} + \times (\mathbf{m} \times \mathbf{H}_\mathrm{eff}) - + \frac{\alpha_{\parallel}}{m^2}(\mathbf{m} \cdot + \mathbf{H}_\mathrm{eff}) \cdot \mathbf{m}\right) + + The three terms describe + + #. **precession** at Larmor frequency, + #. **transversal damping** (conserving the macrospin length), and + #. **longitudinal damping** (changing macrospin length due to incoherent + atomistic spin excitations within the layer the macrospin is + defined on). + + :math:`\alpha_{\parallel}` and :math:`\alpha_{\perp}` are the + :meth:`longitudinal damping` and + :meth:`transverse damping` parameters, + respectively. + :math:`\gamma_e = -1.761\times10^{11}\,\mathrm{rad\,s^{-1}\,T^{-1}}` is + the gyromagnetic ratio of an electron. + + The effective magnetic field is the sum of all relevant magnetic + interactions: + + .. math:: + + \mathbf{H}_\mathrm{eff} = \mathbf{H}_\mathrm{ext} + + \mathbf{H}_\mathrm{A} + + \mathbf{H}_\mathrm{ex} + + \mathbf{H}_\mathrm{th} + + where + + * :math:`\mathbf{H}_\mathrm{ext}` is the external magnetic field + * :math:`\mathbf{H}_\mathrm{A}` is the :meth:`uniaxial anisotropy field + ` + * :math:`\mathbf{H}_\mathrm{ex}` is the :meth:`exchange field + ` + * :math:`\mathbf{H}_\mathrm{th}` is the :meth:`thermal field + ` + + Args: + delays (ndarray[Quantity]): delays range of simulation [s]. + temp_map (ndarray[float]): spatio-temporal temperature map. + H_ext (ndarray[float], optional): external magnetic field + (H_x, H_y, H_z) [T]. + + Returns: + magnetization_map (ndarray[float]): spatio-temporal absolute + magnetization profile. + + """ + t1 = time() + try: + delays = delays.to('s').magnitude + except AttributeError: + pass + M = len(delays) + + distances, _, _ = self.S.get_distances_of_layers(False) + + init_mag = self.check_initial_magnetization(init_mag, distances) + # convert initial magnetization from polar to cartesian coordinates + init_mag = LLB.convert_polar_to_cartesian(init_mag) + # get layer properties + curie_temps = self.S.get_layer_property_vector('_curie_temp') + eff_spins = self.S.get_layer_property_vector('eff_spin') + lambdas = self.S.get_layer_property_vector('lamda') + mf_exch_couplings = self.S.get_layer_property_vector('mf_exch_coupling') + mag_moments = self.S.get_layer_property_vector('_mag_moment') + aniso_exponents = self.S.get_layer_property_vector('aniso_exponent') + anisotropies = self.S.get_layer_property_vector('_anisotropy') + mag_saturations = self.S.get_layer_property_vector('_mag_saturation') + exch_stiffnesses = self.get_directional_exchange_stiffnesses() + thicknesses = self.S.get_layer_property_vector('_thickness') + # calculate the mean magnetization maps for each unique layer + # and all relevant parameters + mean_mag_map = self.get_mean_field_mag_map(temp_map[:, :, 0]) + # mask for magnetic layers only + is_magnetic = curie_temps > 0 + N = np.count_nonzero(is_magnetic) + + if self.progress_bar: # with tqdm progressbar + pbar = tqdm() + pbar.set_description('Delay = {:.3f} ps'.format(delays[0]*1e12)) + state = [delays[0], abs(delays[-1]-delays[0])/100] + else: # without progressbar + pbar = None + state = None + # solve pdepe with method-of-lines + sol = solve_ivp( + LLB.odefunc, + [delays[0], delays[-1]], + np.reshape(init_mag[is_magnetic, :], N*3, order='F'), + args=(delays, + N, + H_ext, + temp_map[:, is_magnetic, 0], # provide only the electron temperature + mean_mag_map[:, is_magnetic], + curie_temps[is_magnetic], + eff_spins[is_magnetic], + lambdas[is_magnetic], + mf_exch_couplings[is_magnetic], + mag_moments[is_magnetic], + aniso_exponents[is_magnetic], + anisotropies[is_magnetic], + mag_saturations[is_magnetic], + exch_stiffnesses[is_magnetic], + thicknesses[is_magnetic], + pbar, state), + t_eval=delays, + **self.ode_options) + + if pbar is not None: # close tqdm progressbar if used + pbar.close() + temp = sol.y.T + # final magnetization map is zero for all non-magnetic layers + magnetization_map = np.zeros([M, len(distances), 3]) + # reshape results and set only for magnetic layers + magnetization_map[:, is_magnetic, :] = np.array(temp).reshape([M, N, 3], order='F') + # convert to polar coordinates + magnetization_map = LLB.convert_cartesian_to_polar(magnetization_map) + self.disp_message('Elapsed time for _LLB_: {:f} s'.format(time()-t1)) + + return magnetization_map + + def get_mean_field_mag_map(self, temp_map): + r"""get_mean_field_mag_map + + Returns the mean-field magnetization map see + :meth:`calc_mean_field_mag_map` for details. The dimension of the map + are :math:`M \times N` with :math:`M` being the number of delays and + :math:`N` the number of layers in the structure. + + Args: + temp_map (ndarray[float]): spatio-temporal electron temperature map. + + Returns: + mf_mag_map (ndarray[float]): spatio-temporal mean_field + magnetization map. + + """ + # create a hash of all simulation parameters + filename = 'mf_magnetization_map_' \ + + self.get_hash(temp_map=temp_map) \ + + '.npz' + full_filename = path.abspath(path.join(self.cache_dir, filename)) + # check if we find some corresponding data in the cache dir + if path.exists(full_filename) and not self.force_recalc: + # found something so load it + tmp = np.load(full_filename) + mf_mag_map = tmp['mf_mag_map'] + self.disp_message('_mean_field_magnetization_map_ loaded from file:\n\t' + filename) + else: + t1 = time() + self.disp_message('Calculating _mean_field_magnetization_map_ ...') + # parse the input arguments + if not isinstance(temp_map, np.ndarray): + raise TypeError('temp_map must be a numpy ndarray!') + + mf_mag_map = self.calc_mean_field_mag_map(temp_map) + + self.disp_message('Elapsed time for _mean_field_magnetization_map_:' + ' {:f} s'.format(time()-t1)) + self.save(full_filename, {'mf_mag_map': mf_mag_map}, + '_mean_field_magnetization_map_') + return mf_mag_map + + def calc_mean_field_mag_map(self, temp_map): + r"""calc_mean_field_mag_map + + Calculate the mean-field magnetization map :math:`m_\mathrm{eq}` by + solving the self consistent equation + + .. math:: + + m_\mathrm{eq}(T) & = B_S(m_\mathrm{eq}, T) \\ + + where :math:`B_S` is the Brillouin function. + + Args: + temp_map (ndarray[float]): spatio-temporal electron temperature map. + + Returns: + mf_mag_map (ndarray[float]): spatio-temporal mean_field + magnetization map. + + """ + (M, N) = temp_map.shape # M - number of delays, N - number of layers + + mf_mag_map = np.zeros_like(temp_map) + + unique_layers = self.S.get_unique_layers() + relevant_temps = {} + # iterate over all positions per unique layers + for i, (k, v) in enumerate(self.S.get_all_positions_per_unique_layer().items()): + relevant_temps[k] = [] + # unique layer properties + curie_temp = unique_layers[1][i]._curie_temp + # mean-field magnetization is only calculated for a non-zero Curie + # temperature of magnetic layers + if curie_temp > 0: + eff_spin = unique_layers[1][i].eff_spin + mf_exch_coupling = unique_layers[1][i].mf_exch_coupling + + # simple round for down-sampling + unique_temps = np.unique(np.round(temp_map[:, v].flatten(), decimals=1)) + # only temperatures below T_C are relevant + unique_temps = unique_temps[unique_temps <= curie_temp] + # are normalized by T_C + reduced_temps = unique_temps/curie_temp + mf_mags = np.zeros_like(reduced_temps) + + for j, T in enumerate(reduced_temps): + if T == 1: + mf_mags[j] = 0 + else: + mf_mags[j] = fsolve( + lambda x: x - LLB.calc_Brillouin(x, T, eff_spin, mf_exch_coupling, + curie_temp), np.sqrt(1-T)) + + relevant_temps[k] = np.stack((unique_temps, mf_mags)) + + # for every temperature in temp_map search for best match in + # relevant_temps and assign according mf_mag into mf_mag_map + idx = finderb(np.round(temp_map[:, v].flatten(), decimals=1), + relevant_temps[k][0, :]) + mf_mag_map[:, v] = np.reshape(relevant_temps[k][1, idx], (M, len(v))) + else: + # non-magnetic layers with Curie temperature = 0 + mf_mag_map[:, v] = 0 + + return mf_mag_map + + def get_directional_exchange_stiffnesses(self): + r"""get_directional_exchange_stiffnesses + + Returns the directional exchange stiffnesses with size + :math:`N \times 2`, with :math:`N` being the number of layers, between + the :math:`(i-1)^\mathrm{th}` and :math:`i^\mathrm{th}` layers as well + as between the :math:`i^\mathrm{th}` and :math:`(i+1)^\mathrm{th}` + layers in the structure. + In case two neighboring layers are identical the center entry + of the 3-component `exchange_stiffness` is used. In case of an interface + to the top :math:`(i-1)\rightarrow i` it will be the first entry and + for an interface to the bottom :math:`i\rightarrow (i+1)` it will be + the third entry. + + Returns: + A (ndarray[float]): directional exchange stiffnesses. + + """ + exch_stiffnesses = self.S.get_layer_property_vector('_exch_stiffness') + + indices, _, _ = self.S.get_layer_vectors() + + A = np.zeros([len(indices), 2]) + interfaces = (np.r_[1, np.diff(indices), 1]) + interfaces[interfaces != 0] = -1 + select = (interfaces+1).astype(np.int16) + + A[:, 0] = exch_stiffnesses[np.arange(len(select[0:-1])), select[0:-1]] + + interfaces[interfaces != 0] = 1 + select = (interfaces+1).astype(np.int16) + A[:, 1] = exch_stiffnesses[np.arange(len(select[1:])), select[1:]] + + return A + + @staticmethod + def odefunc(t, m, + delays, N, H_ext, temp_map, mean_mag_map, curie_temps, eff_spins, lambdas, + mf_exch_couplings, mag_moments, aniso_exponents, anisotropies, mag_saturations, + exch_stiffnesses, thicknesses, pbar, state): + """odefunc + + Ordinary differential equation that is solved for 1D LLB. + + Args: + t (ndarray[float]): internal time steps of the ode solver. + m (ndarray[float]): internal variable of the ode solver. + delays (ndarray[float]): delays range of simulation [s]. + N (int): number of spatial grid points. + H_ext (ndarray[float]): external magnetic field + (H_x, H_y, H_z) [T]. + temp_map (ndarray[float]): spatio-temporal electron temperature map. + mean_mag_map (ndarray[float]): spatio-temporal + mean-field magnetization map. + curie_temps (ndarray[float]): Curie temperatures of layers. + eff_spins (ndarray[float]): effective spins of layers. + lambdas (ndarray[float]): coupling-to-bath parameter of layers. + mf_exch_couplings (ndarray[float]): mean-field exchange couplings of + layers. + mag_moments (ndarray[float]): atomic magnetic moments of layers. + aniso_exponents (ndarray[float]): exponent of uniaxial anisotropy of + layers. + anisotropies (ndarray[float]): anisotropy vectors of layers. + mag_saturations (ndarray[float]): saturation magnetization of + layers. + exch_stiffnesses (ndarray[float]): exchange stiffness of layers + towards the upper and lower layer. + thicknesses (ndarray[float]): thicknesses of layers. + pbar (tqdm): tqdm progressbar. + state (list[float]): state variables for progress bar. + + Returns: + dmdt (ndarray[float]): temporal derivative of internal variable. + + """ + # state is a list containing last updated time t: + # state = [last_t, dt] + # I used a list because its values can be carried between function + # calls throughout the ODE integration + last_t, dt = state + try: + n = int((t - last_t)/dt) + except ValueError: + n = 0 + + if n >= 1: + pbar.update(n) + pbar.set_description('Delay = {:.3f} ps'.format(t*1e12)) + state[0] = t + elif n < 0: + state[0] = t + + # initialize arrays + # reshape input temperature + m = np.array(m).reshape([N, 3], order='F') + + # nearest delay index for current time t + idt = finderb(t, delays)[0] + temps = temp_map[idt, :].flatten() + # binary masks for layers being under or over its Curie temperature + under_tc = (temps < curie_temps) + over_tc = ~under_tc + # get the current mean-field magnetization + mf_magnetizations = mean_mag_map[idt, :] + + # actual calculations + m_squared = np.sum(np.power(m, 2), axis=1) + gamma_e = -1.761e11 + + # external field H_ext is given as input + # calculate uniaxial anisotropy field + H_A = LLB.calc_uniaxial_anisotropy_field(m, mf_magnetizations, aniso_exponents, + anisotropies, mag_saturations) + # calculate exchange field + H_ex = LLB.calc_exchange_field(m, exch_stiffnesses, mag_saturations, thicknesses) + # calculate thermal field + H_th = LLB.calc_thermal_field(m, m_squared, temps, mf_magnetizations, eff_spins, + curie_temps, mf_exch_couplings, mag_moments, under_tc, + over_tc) + + # calculate the effective field + H_eff = H_ext + H_A + H_ex + H_th + + # calculate components of LLB + # precessional term: + m_rot = np.cross(m, H_eff) + + # damping + qs = LLB.calc_qs(temps, curie_temps, eff_spins, mf_magnetizations, + under_tc) + # transversal damping + alpha_trans = LLB.calc_transverse_damping(temps, curie_temps, lambdas, + qs, mf_magnetizations, + under_tc, over_tc) + trans_damping = np.multiply( + np.divide(alpha_trans, m_squared)[:, np.newaxis], + np.cross(m, m_rot) + ) + # longitudinal damping + alpha_long = LLB.calc_longitudinal_damping(temps, curie_temps, + eff_spins, lambdas, qs, + under_tc, over_tc) + long_damping = np.multiply( + np.divide(alpha_long, m_squared)[:, np.newaxis], + np.multiply(np.einsum('ij,ij->i', m, H_eff)[:, np.newaxis], m) + ) + + dmdt = gamma_e * (m_rot + trans_damping - long_damping) + + return np.reshape(dmdt, N*3, order='F') + + @staticmethod + def calc_uniaxial_anisotropy_field(mag_map, mf_magnetizations, aniso_exponents, anisotropies, + mag_saturations): + r"""calc_uniaxial_anisotropy_field + + Calculate the uniaxial anisotropy component of the effective field. + + .. math:: + + \mathbf{H}_\mathrm{A} = - + \frac{2}{M_s} + \left( + K_x\,m_\mathrm{eq}(T)^{\kappa-2} + \begin{bmatrix}0\\m_y\\m_z\end{bmatrix} + + K_y\,m_\mathrm{eq}(T)^{\kappa-2} + \begin{bmatrix}m_x\\0\\m_z\end{bmatrix} + + K_z\,m_\mathrm{eq}(T)^{\kappa-2} + \begin{bmatrix}m_x\\m_y\\0\end{bmatrix} + \right) + + with :math:`K = (K_x, K_y, K_z)` as the anisotropy and :math:`\kappa` as + the uniaxial anisotropy exponent. + + Args: + mag_map (ndarray[float]): spatio-temporal magnetization map + - possibly for a single delay. + mf_magnetizations (ndarray[float]): mean-field magnetization of + layers. + aniso_exponents (ndarray[float]): exponent of uniaxial + anisotropy of layers. + anisotropies (ndarray[float]): anisotropy vectors of layers. + mag_saturations (ndarray[float]): saturation magnetization of + layers. + + Returns: + H_A (ndarray[float]): uniaxial anisotropy field. + + """ + H_A = np.zeros_like(mag_map) + + factor = -2/mag_saturations + unit_vector = np.array([0, 1, 1])[np.newaxis, :] + for i in range(3): + H_A += factor[:, np.newaxis] * anisotropies[:, i, np.newaxis]\ + * np.power(mf_magnetizations, + aniso_exponents-2)[:, np.newaxis] \ + * mag_map*np.roll(unit_vector, i, axis=1) + + return H_A + + @staticmethod + def calc_exchange_field(mag_map, exch_stiffnesses, mag_saturations, thicknesses): + r"""calc_exchange_field + + Calculate the exchange component of the effective field, which is + defined as for each :math:`i^\mathrm{th}` layer in the structure as + + .. math:: + + H_{\mathrm{ex}, i}=\frac{2}{M_{s,i} \Delta z_i^2} + \left(A_{i}^{i-1}\left(\mathbf{m}_{i-1}-\mathbf{m}_{i}\right) + + A_i^{i+1}\left(\mathbf{m}_{i+1}-\mathbf{m}_{i}\right) \right), + + where :math:`\Delta z` is the thickness of the layers or magnetic grains + and :math:`M_s` is the saturation magnetization. :math:`A_{i}^{i-1}` and + :math:`A_i^{i+1}` describe the exchange stiffness between the nearest + neighboring layers provided by + :meth:`get_directional_exchange_stiffnesses`. + + Args: + mag_map (ndarray[float]): spatio-temporal magnetization map + - possibly for a single delay. + exch_stiffnesses (ndarray[float]): exchange stiffness of layers + towards the upper and lower layer. + mag_saturations (ndarray[float]): saturation magnetization of + layers. + + Returns: + H_ex (ndarray[float]): exchange field. + + """ + H_ex = np.zeros_like(mag_map) + + m_diff_down = np.concatenate((np.diff(mag_map, axis=0), np.zeros((1, 3))), axis=0) + m_diff_up = -np.roll(m_diff_down, 1) + + es = np.divide(2, np.multiply(mag_saturations, thicknesses**2)) + + H_ex = es[:, np.newaxis]*exch_stiffnesses[:, 0, np.newaxis]*m_diff_up \ + + es[:, np.newaxis]*exch_stiffnesses[:, 1, np.newaxis]*m_diff_down + + return -H_ex + + @staticmethod + def calc_thermal_field(mag_map, mag_map_squared, temp_map, mf_magnetizations, eff_spins, + curie_temps, mf_exch_couplings, mag_moments, under_tc, over_tc): + r"""calc_thermal_field + + Calculate the thermal component of the effective field. + + .. math:: + + \mathbf{H}_\mathrm{th} = \begin{cases} + \frac{1}{2\chi_{\parallel}}\left(1-\frac{m^2}{m_\mathrm{eq}^2} + \right)\mathbf{m} & \mathrm{for}\ T < T_\mathrm{C} \\ + -\frac{1}{\chi_{\parallel}}\left(1+\frac{3}{5} + \frac{T_\mathrm{C}}{T-T_\mathrm{C}}m^2\right)\mathbf{m} + & \mathrm{for}\ T \geq T_\mathrm{C} + \end{cases} + + with :math:`\chi_{\parallel}` being the + :meth:`longitudinal susceptibility`. + + Args: + mag_map (ndarray[float]): spatio-temporal magnetization map + - possibly for a single delay. + mag_map_squared (ndarray[float]): spatio-temporal magnetization map + squared- possibly for a single delay. + temp_map (ndarray[float]): spatio-temporal temperature map + - possibly for a single delay. + mf_magnetizations (ndarray[float]): mean-field magnetization of + layers. + eff_spins (ndarray[float]): effective spin of layers. + curie_temps (ndarray[float]): Curie temperature of layers. + mf_exch_couplings (ndarray[float]): mean-field exch. coupling of + layers. + mag_moments (ndarray[float]): atomic magnetic moments of layers. + under_tc (ndarray[boolean]): mask temperatures under the Curie + temperature. + over_tc (ndarray[boolean]): mask temperatures over the Curie + temperature. + + Returns: + H_th (ndarray[float]): thermal field. + + """ + chi_long = LLB.calc_long_susceptibility(temp_map, mf_magnetizations, curie_temps, + eff_spins, mf_exch_couplings, mag_moments, + under_tc, over_tc) + + H_th = np.zeros_like(temp_map) + H_th[under_tc] = 1/(2 * chi_long[under_tc]) * ( + 1 - mag_map_squared[under_tc]/mf_magnetizations[under_tc]**2 + ) + H_th[over_tc] = -1/chi_long[over_tc] * ( + 1 + 3/5 * curie_temps[over_tc]/(temp_map[over_tc]-curie_temps[over_tc]) + ) * mag_map_squared[over_tc] + + return np.multiply(H_th[:, np.newaxis], mag_map) + + @staticmethod + def calc_Brillouin(mag, temp, eff_spin, mf_exch_coupling, curie_temp): + r"""calc_Brillouin + + .. math:: + + B_S(m, T) = \frac{2 S+1}{2S} \coth{\left(\frac{2S+1}{2S} + \frac{J \, m}{k_\mathrm{B}\, T}\right)} + - \frac{1}{2S}\coth{\left(\frac{1}{2S} + \frac{J \, m}{k_\mathrm{B}\,T}\right)} + + where + + .. math:: + + J = 3\frac{S}{S+1}k_\mathrm{B} \, T_\mathrm{C} + + is the mean field exchange coupling constant for effective spin + :math:`S` and Curie temperature :math:`T_\mathrm{C}`. + + Args: + mag (ndarray[float]): magnetization of layer. + temp (ndarray[float]): electron temperature of layer. + eff_spin (ndarray[float]): effective spin of layer. + mf_exch_coupling (ndarray[float]): mean-field exch. coupling of + layers. + curie_temp (ndarray[float]): Curie temperature of layer. + + Returns: + brillouin (ndarray[float]): brillouin function. + + """ + + eta = mf_exch_coupling * mag / constants.k / temp / curie_temp + c1 = (2 * eff_spin + 1) / (2 * eff_spin) + c2 = 1 / (2 * eff_spin) + brillouin = c1 / np.tanh(c1 * eta) - c2 / np.tanh(c2 * eta) + return brillouin + + @staticmethod + def calc_dBrillouin_dx(temp_map, mf_magnetizations, eff_spins, mf_exch_couplings): + r"""calc_dBrillouin_dx + + Calculate the derivative of the Brillouin function :math:`B_x` at + :math:`m = m_\mathrm{eq}`: + + .. math:: + + B_x = \frac{dB}{dx} = \frac{1}{4S^2\sinh^2(x/2S)} + -\frac{(2S+1)^2}{4S^2\sinh^2\left(\frac{(2S+1)x}{2S}\right)} + + with :math:`x=\frac{J\,m}{k_\mathrm{B}\,T}`. + + Args: + temp_map (ndarray[float]): spatio-temporal temperature map + - possibly for a single delay. + mf_magnetizations (ndarray[float]): mean-field magnetization of + layers. + eff_spins (ndarray[float]): effective spin of layers. + mf_exch_couplings (ndarray[float]): mean-field exchange couplings of + layers. + + Returns: + dBdx (ndarray[float]): derivative of Brillouin function. + + """ + x = np.divide(mf_exch_couplings*mf_magnetizations, + constants.k*temp_map) + + two_eff_spins = 2*eff_spins + dBdx = 1 / (two_eff_spins**2 * np.sinh(x / (two_eff_spins))**2) \ + - (two_eff_spins + 1)**2 / \ + (two_eff_spins**2 * np.sinh(((two_eff_spins + 1) * x) / (two_eff_spins))**2) + + return dBdx + + @staticmethod + def calc_transverse_damping(temp_map, curie_temps, lambdas, qs, + mf_magnetizations, under_tc, over_tc): + r"""calc_transverse_damping + + Calculate the transverse damping parameter: + + .. math:: + + \alpha_{\perp} = \begin{cases} + \frac{\lambda}{m_\mathrm{eq}(T)}\left(\frac{\tanh(q_s)}{q_s}- + \frac{T}{3T_\mathrm{C}}\right) + & \mathrm{for}\ T < T_\mathrm{C} \\ + \frac{2 \lambda}{3}\frac{T}{T_\mathrm{C}} + & \mathrm{for}\ T \geq T_\mathrm{C} + \end{cases} + + Args: + temp_map (ndarray[float]): spatio-temporal temperature map + - possibly for a single delay. + curie_temps (ndarray[float]): Curie temperatures of layers. + lambdas (ndarray[float]): coupling-to-bath parameter of layers. + qs (ndarray[float]): qs parameter. + mf_magnetizations (ndarray[float]): mean-field magnetization of + layers. + under_tc (ndarray[boolean]): mask temperatures under the Curie + temperature. + over_tc (ndarray[boolean]): mask temperatures over the Curie + temperature. + + Returns: + alpha_trans (ndarray[float]): transverse damping parameter. + + """ + alpha_trans = np.zeros_like(temp_map) + alpha_trans[under_tc] = np.multiply( + np.divide(lambdas[under_tc], mf_magnetizations[under_tc]), ( + np.divide(np.tanh(qs), qs) + - np.divide(temp_map[under_tc], 3*curie_temps[under_tc]) + ) + ) + alpha_trans[over_tc] = lambdas[over_tc]*2/3*np.divide( + temp_map[over_tc], curie_temps[over_tc] + ) + return alpha_trans + + @staticmethod + def calc_longitudinal_damping(temp_map, curie_temps, eff_spins, lambdas, qs, + under_tc, over_tc): + r"""calc_transverse_damping + + Calculate the transverse damping parameter: + + .. math:: + + \alpha_{\parallel} = \begin{cases} + \frac{2\lambda}{S+1} + \frac{1}{\sinh(2q_s)} & \mathrm{for}\ T < T_\mathrm{C} \\ + \frac{2 \lambda}{3}\frac{T}{T_\mathrm{C}} + & \mathrm{for}\ T \geq T_\mathrm{C} + \end{cases} + + Args: + temp_map (ndarray[float]): spatio-temporal temperature map + - possibly for a single delay. + curie_temps (ndarray[float]): Curie temperatures of layers. + eff_spins (ndarray[float]): effective spins of layers. + lambdas (ndarray[float]): coupling-to-bath parameter of layers. + qs (ndarray[float]): qs parameter. + under_tc (ndarray[boolean]): mask temperatures under the Curie + temperature. + over_tc (ndarray[boolean]): mask temperatures over the Curie + temperature. + + Returns: + alpha_long (ndarray[float]): transverse damping parameter. + + """ + alpha_long = np.zeros_like(temp_map) + alpha_long[under_tc] = np.divide(2*np.divide(lambdas[under_tc], + (eff_spins[under_tc]+1)), + np.sinh(2*qs) + ) + alpha_long[over_tc] = lambdas[over_tc]*2/3*np.divide( + temp_map[over_tc], curie_temps[over_tc] + ) + + return alpha_long + + @staticmethod + def calc_qs(temp_map, mf_magnetizations, curie_temps, eff_spins, under_tc): + r"""calc_qs + + Calculate the :math:`q_s` parameter: + + .. math:: + + q_s=\frac{3 T_\mathrm{C} m_\mathrm{eq}(T)}{(2S+1)T} + + Args: + temp_map (ndarray[float]): spatio-temporal temperature map + - possibly for a single delay. + mf_magnetizations (ndarray[float]): mean-field magnetization of + layers. + curie_temps (ndarray[float]): Curie temperatures of layers. + eff_spins (ndarray[float]): effective spins of layers. + under_tc (ndarray[boolean]): mask temperatures below the Curie + temperature. + + Returns: + qs (ndarray[float]): qs parameter. + + """ + return np.divide( + 3*curie_temps[under_tc] * mf_magnetizations[under_tc], + (2*eff_spins[under_tc] + 1)*temp_map[under_tc] + ) + + @staticmethod + def calc_long_susceptibility(temp_map, mf_magnetizations, curie_temps, eff_spins, + mf_exch_couplings, mag_moments, under_tc, over_tc): + r"""calc_long_susceptibility + + Calculate the the longitudinal susceptibility + + .. math:: + + \chi_{\parallel} = \begin{cases} + \frac{\mu_{\rm{B}}\,B_x(m_{eq}, T)}{ + T\,k_\mathrm{B}-J\,B_x(m_{eq}, T)} + & \mathrm{for}\ T < T_\mathrm{C} \\ + \frac{\mu_{\rm{B}}T_\mathrm{C}}{J(T-T_\mathrm{C})} + & \mathrm{for}\ T \geq T_\mathrm{C} + \end{cases} + + with :math:`B_x(m_{eq},T)` being the :meth:`derivative of the Brillouin + function`. + + Args: + temp_map (ndarray[float]): spatio-temporal temperature map + - possibly for a single delay. + mf_magnetizations (ndarray[float]): mean-field magnetization of + layers. + curie_temps (ndarray[float]): Curie temperatures of layers. + eff_spins (ndarray[float]): effective spins of layers. + mf_exch_couplings (ndarray[float]): mean-field exchange couplings of + layers. + mag_moments (ndarray[float]): atomic magnetic moments of layers. + under_tc (ndarray[boolean]): mask temperatures below the Curie + temperature. + over_tc (ndarray[boolean]): mask temperatures over the Curie + temperature. + + Returns: + chi_long (ndarray[float]): longitudinal susceptibility. + + """ + + dBdx = LLB.calc_dBrillouin_dx(temp_map[under_tc], + mf_magnetizations[under_tc], + eff_spins[under_tc], + mf_exch_couplings[under_tc]) + + chi_long = np.zeros_like(temp_map) + chi_long[under_tc] = np.divide( + mag_moments[under_tc]*dBdx, + temp_map[under_tc]*constants.k - mf_exch_couplings[under_tc]*dBdx + ) + chi_long[over_tc] = np.divide( + mag_moments[over_tc]*curie_temps[over_tc], + mf_exch_couplings[over_tc]*(temp_map[over_tc]-curie_temps[over_tc]) + ) + + return chi_long + + @property + def distances(self): + return Q_(self._distances, u.meter).to('nm') + + @distances.setter + def distances(self, distances): + self._distances = distances.to_base_units().magnitude diff --git a/udkm1Dsim/structures/layers.py b/udkm1Dsim/structures/layers.py index 26592575..4d2bdeef 100644 --- a/udkm1Dsim/structures/layers.py +++ b/udkm1Dsim/structures/layers.py @@ -32,6 +32,8 @@ from inspect import isfunction from sympy import integrate, lambdify, symbols, symarray from tabulate import tabulate +import scipy.constants as constants +import warnings class Layer: @@ -80,8 +82,8 @@ class Layer: opt_ref_index_per_strain (ndarray[float]): optical refractive index change per strain - real and imagenary part :math:`\frac{d n}{d \eta} + i\frac{d \kappa}{d \eta}`. - therm_cond (list[@lambda]): list of HANDLES T-dependent thermal - conductivity [W/(m K)]. + therm_cond (list[@lambda]): list of T-dependent thermal conductivity + [W/(m K)]. lin_therm_exp (list[@lambda]): list of T-dependent linear thermal expansion coefficient (relative). int_lin_therm_exp (list[@lambda]): list of T-dependent integrated @@ -90,10 +92,20 @@ class Layer: function [J/(kg K)]. int_heat_capacity (list[@lambda]): list of T-dependent integrated heat capacity function. - sub_system_coupling (list[@lambda]): list of of coupling functions of + sub_system_coupling (list[@lambda]): list of coupling functions of different subsystems [W/m³]. num_sub_systems (int): number of subsystems for heat and phonons (electrons, lattice, spins, ...). + eff_spin (float): effective spin. + curie_temp (float): Curie temperature [K]. + mf_exch_coupling (float): mean field exchange coupling constant [m²kg/s²]. + lamda (float): intrinsic coupling to bath parameter. + mag_moment (float): atomic magnetic moment [mu_Bohr]. + aniso_exponent(ndarray[float]): exponent of T-dependence uniaxial + anisotropy. + anisotropy (float): anisotropy at T=0 K [J/m³] as x,y,z component vector. + exch_stiffness (float): exchange stiffness at T=0 K [J/m]. + mag_saturation (float): saturation magnetization at 0 K [J/T/m³]. """ @@ -122,6 +134,15 @@ def __init__(self, id, name, **kwargs): 'thermal expansion and subsystem coupling have not ' 'the same number of elements!') + self.eff_spin = kwargs.get('eff_spin', 0) + self.curie_temp = kwargs.get('curie_temp', 0.0*u.K) + self.lamda = kwargs.get('lamda', 0) + self.mag_moment = kwargs.get('mag_moment', 0*u.bohr_magneton) + self.aniso_exponent = kwargs.get('aniso_exponent', 0) + self.anisotropy = kwargs.get('anisotropy', [0, 0, 0]*u.J/u.m**3) + self.exch_stiffness = kwargs.get('exch_stiffness', 0*u.J/u.m) + self.mag_saturation = kwargs.get('mag_saturation', 0*u.J/u.T/u.m**3) + def __str__(self): """String representation of this class""" output = [ @@ -141,7 +162,18 @@ def __str__(self): ['thermal conduct.', ' W/(m K)\n'.join(self.therm_cond_str) + ' W/(m K)'], ['linear thermal expansion', '\n'.join(self.lin_therm_exp_str)], ['heat capacity', ' J/(kg K)\n'.join(self.heat_capacity_str) + ' J/(kg K)'], - ['subsystem coupling', ' W/m³\n'.join(self.sub_system_coupling_str) + ' W/m³']] + ['subsystem coupling', ' W/m³\n'.join(self.sub_system_coupling_str) + ' W/m³'], + ['effective spin', self.eff_spin], + ['Curie temperature', '{:.4~P}'.format(self.curie_temp.to('K'))], + ['mean-field exch. coupling', self.mf_exch_coupling*u.m**2*u.kg/u.s**2], + ['coupling to bath parameter', self.lamda], + ['atomic magnetic moment', '{:.4~P}'.format(self.mag_moment.to( + 'bohr_magneton'))], + ['uniaxial anisotropy exponent', self.aniso_exponent], + ['anisotropy', self.anisotropy], + ['exchange stiffness', self.exch_stiffness], + ['saturation magnetization', self.mag_saturation], + ] return output @@ -236,7 +268,9 @@ def get_property_dict(self, **kwargs): '_thickness'], 'optical': ['_c_axis', '_opt_pen_depth', 'opt_ref_index', 'opt_ref_index_per_strain'], - 'magnetic': ['_thickness', 'magnetization'], + 'magnetic': ['_thickness', 'magnetization', 'eff_spin', + '_curie_temp', '_aniso_exponents', '_anisotropy', + '_exch_stiffness', '_mag_saturation', 'lamda'], } types = (kwargs.get('types', 'all')) @@ -307,6 +341,20 @@ def calc_spring_const(self): """ self.spring_const[0] = (self._mass_unit_area * (self._sound_vel/self._thickness)**2) + def calc_mf_exchange_coupling(self): + r"""calc_mf_exchange_coupling + + Calculate the mean-field exchange coupling constant + + .. math:: J = \frac{3}{S_{eff}+1} k_B T_C + + """ + try: + self.mf_exch_coupling = 3*self.eff_spin/(self.eff_spin+1)*constants.k*self._curie_temp + except AttributeError: + # on initialization self._curie_temp + self.mf_exch_coupling = 0 + @property def thickness(self): return Q_(self._thickness, u.meter).to('nm') @@ -496,6 +544,70 @@ def sub_system_coupling(self, sub_system_coupling): self._sub_system_coupling, self.sub_system_coupling_str = \ self.check_input(sub_system_coupling) + @property + def eff_spin(self): + return self._eff_spin + + @eff_spin.setter + def eff_spin(self, eff_spin): + self._eff_spin = float(eff_spin) + self.calc_mf_exchange_coupling() + + @property + def curie_temp(self): + return Q_(self._curie_temp, u.K) + + @curie_temp.setter + def curie_temp(self, curie_temp): + self._curie_temp = float(curie_temp.to_base_units().magnitude) + self.calc_mf_exchange_coupling() + + @property + def mag_moment(self): + return Q_(self._mag_moment, u.A*u.m**2).to('bohr_magneton') + + @mag_moment.setter + def mag_moment(self, mag_moment): + self._mag_moment = float(mag_moment.to_base_units().magnitude) + + @property + def anisotropy(self): + return Q_(self._anisotropy, u.J/u.m**3) + + @anisotropy.setter + def anisotropy(self, anisotropy): + self._anisotropy = np.zeros(3) + try: + if len(anisotropy) == 3: + self._anisotropy = anisotropy.to_base_units().magnitude + else: + warnings.warn('Anisotropy must be a scalar or vector of length 3!') + except TypeError: + self._anisotropy[0] = anisotropy.to_base_units().magnitude + + @property + def exch_stiffness(self): + return Q_(self._exch_stiffness, u.J/u.m) + + @exch_stiffness.setter + def exch_stiffness(self, exch_stiffness): + self._exch_stiffness = np.zeros(3) + try: + if len(exch_stiffness) == 3: + self._exch_stiffness = exch_stiffness.to_base_units().magnitude + else: + warnings.warn('Exchange stiffness must be a scalar or vector of length 3!') + except TypeError: + self._exch_stiffness[:] = exch_stiffness.to_base_units().magnitude + + @property + def mag_saturation(self): + return Q_(self._mag_saturation, u.J/u.T/u.m**3) + + @mag_saturation.setter + def mag_saturation(self, mag_saturation): + self._mag_saturation = float(mag_saturation.to_base_units().magnitude) + class AmorphousLayer(Layer): r"""AmorphousLayer @@ -559,6 +671,16 @@ class AmorphousLayer(Layer): different subsystems [W/m³]. num_sub_systems (int): number of subsystems for heat and phonons (electrons, lattice, spins, ...). + eff_spin (float): effective spin. + curie_temp (float): Curie temperature [K]. + mf_exch_coupling (float): mean field exchange coupling constant [m²kg/s²]. + lamda (float): intrinsic coupling to bath parameter. + mag_moment (float): atomic magnetic moment [mu_Bohr]. + aniso_exponent(ndarray[float]): exponent of T-dependence uniaxial + anisotropy. + anisotropy (float): anisotropy at T=0 K [J/m³] as x,y,z component vector. + exch_stiffness (float): exchange stiffness at T=0 K [J/m]. + mag_saturation (float): saturation magnetization at 0 K [J/T/m³]. magnetization (dict[float]): magnetization amplitude, phi and gamma angle inherited from the atom. atom (object): Atom or AtomMixed in the layer. @@ -621,6 +743,20 @@ def atom(self, atom): 'gamma': atom.mag_gamma, } + @property + def magnetization(self): + return {'amplitude': self._magnetization['amplitude'], + 'phi': Q_(self._magnetization['phi'], u.rad).to('deg'), + 'gamma': Q_(self._magnetization['gamma'], u.rad).to('deg') + } + + @magnetization.setter + def magnetization(self, magnetization): + self._magnetization = {'amplitude': magnetization['amplitude'], + 'phi': magnetization['phi'].to_base_units().magnitude, + 'gamma': magnetization['gamma'].to_base_units().magnitude + } + class UnitCell(Layer): r"""UnitCell @@ -690,7 +826,17 @@ class UnitCell(Layer): atoms (list[atom, @lambda]): list of atoms and function handle for strain dependent displacement. num_atoms (int): number of atoms in unit cell. - magnetization (list[float]): magnetization amplitutes, phi, and + eff_spin (float): effective spin. + curie_temp (float): Curie temperature [K]. + mf_exch_coupling (float): mean field exchange coupling constant [m²kg/s²]. + lamda (float): intrinsic coupling to bath parameter. + mag_moment (float): atomic magnetic moment [mu_Bohr]. + aniso_exponent(ndarray[float]): exponent of T-dependence uniaxial + anisotropy. + anisotropy (float): anisotropy at T=0 K [J/m³] as x,y,z component vector. + exch_stiffness (float): exchange stiffness at T=0 K [J/m]. + mag_saturation (float): saturation magnetization at 0 K [J/T/m³]. + magnetization (list[float]): magnetization amplitudes, phi, and gamma angle of each atom in the unit cell. """