{ "cells": [ { "cell_type": "markdown", "id": "846698bd-c572-4f60-8e55-79033da5dbda", "metadata": {}, "source": [ "## pyMACS Introduction" ] }, { "cell_type": "code", "execution_count": 1, "id": "462ec767-d862-4a36-a67d-d0a92f294af9", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "outputs": [], "source": [ "import pyMACS\n", "from pyMACS.virtualMACS import VirtualMACS\n", "import matplotlib.pyplot as plt\n", "import mcstasscript as ms\n", "import numpy as np" ] }, { "cell_type": "markdown", "id": "91f54b24-8e19-4cc4-a634-078a48ea8c66", "metadata": { "editable": true, "slideshow": { "slide_type": "" }, "tags": [] }, "source": [ "Welcome to a basic introduction of the pyMACS package. Here we will go through some of the basic functionality, use cases, and limitations of the package itself. Before doing anything, please make sure that \n", "1) You have a valid McStas 3.* installation.\n", "2) You have installed mcstasscript and properly set up its configurator to point to your McStas installation.\n", "\n", "After importing pyMACS, we import the VirtualMACS class in the call \n", ">from pyMACS.virtualMACS import VirtualMACS\n", "\n", "The VirtualMACS class is essentially a virtual MACS experiment. It contains all of the information about the sample, the instrument, and the output data. This class is broken down into the following components:\n", "\n", "1. VirtualMACS.monochromator, contains all instrumental settings and python methods relevant to the monochromator\n", "2. VirtualMACS.kidney, contains all instrumental settings and python methods relevant to the 20-channel detector geometry (kidney)\n", "3. VirtualMACS.sample, contains the sample information such as the alignment, lattice parameters, and various assosicated methods.\n", "4. VirtualMACS.data, class that handles all input and output data of both real ng0 files and simulated data.\n", "\n", "Let's begin by creating a simple experiment. " ] }, { "cell_type": "code", "execution_count": 2, "id": "ae70ea5f-3e5b-4af8-ab8e-b705ae0582ab", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "#########################\n", "Old simulations found in /mnt/c/Users/tjh/OneDrive - NIST/GitHub/pyMACS/docs/source/notebooks/test/Kidney_simulations/\n", " \n", "Successfully combined old simulations into /mnt/c/Users/tjh/OneDrive - NIST/GitHub/pyMACS/docs/source/notebooks/test/Kidney_simulations/test_total.csv\n", "\n", "Data matrix instantiated and ready to use.\n", "#########################\n" ] } ], "source": [ "macs = VirtualMACS(exptName='test',cifName=\"TiO2.cif\")" ] }, { "cell_type": "markdown", "id": "da437c21-540b-41b0-9836-987d6c5fff0e", "metadata": {}, "source": [ "Now, define sample parameters relevant to the simulation. Here, we will align the sample in the (H0L) plane. \n" ] }, { "cell_type": "code", "execution_count": 3, "id": "f976472a-20a4-4120-9c2d-cb8fd3e272ef", "metadata": {}, "outputs": [], "source": [ "macs.sample.formula_weight=79.87\n", "macs.sample.sample_widx=5e-3\n", "macs.sample.sample_widz=5e-3\n", "macs.sample.sample_widy=5e-3\n", "\n", "#Alignment, orient_u is defined as perpendicular to the beam, orient_v is parallel\n", "macs.sample.orient_u=[1,0,0]\n", "macs.sample.orient_v=[0,0,1]" ] }, { "cell_type": "markdown", "id": "ac90bbc0-ece6-4b6f-bdf0-f17e0f8a4799", "metadata": {}, "source": [ "McStas requires lattice vector inputs in the lab frame. This function automatically performs that projection given that the orient u and v vectors have been specified. \n" ] }, { "cell_type": "code", "execution_count": 4, "id": "e2da0ea5-bf68-4d51-867a-7d26fb91ee44", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Projection of TiO2 lattice parameters in (H0L) plane;\n", "Format is [[ax,ay,az],[bx,by,bz],[cx,cy,cz]]\n", "[[4.6001 0. 0. ]\n", " [0. 4.6001 0. ]\n", " [0. 0. 2.9288]]\n", "Projection of TiO2 lattice parameters in (HHL) plane;\n", "Format is [[ax,ay,az],[bx,by,bz],[cx,cy,cz]]\n", "[[ 3.25276 -3.25276 0. ]\n", " [ 3.25276 3.25276 0. ]\n", " [ 0. 0. 2.9288 ]]\n" ] } ], "source": [ "macs.sample.project_sample_realspace()\n", "#Print the projection\n", "labproj_h0l = macs.sample.labframe_mat\n", "print(\"Projection of TiO2 lattice parameters in (H0L) plane;\\nFormat is [[ax,ay,az],[bx,by,bz],[cx,cy,cz]]\")\n", "print(labproj_h0l)\n", "#Now try reorienting the sample into the (HHL) frame:\n", "macs.sample.orient_u=[1,1,0]\n", "macs.sample.orient_v=[0,0,1]\n", "macs.sample.project_sample_realspace()\n", "#Print the projection\n", "labproj = macs.sample.labframe_mat\n", "print(\"Projection of TiO2 lattice parameters in (HHL) plane;\\nFormat is [[ax,ay,az],[bx,by,bz],[cx,cy,cz]]\")\n", "print(labproj)" ] }, { "cell_type": "markdown", "id": "95fc12f3-c196-4271-b961-21b7c8397965", "metadata": {}, "source": [ "There are a few more options available in the sample class, but for now this is the minimum to start a simulation." ] }, { "cell_type": "markdown", "id": "a2c997bf-0e91-42e3-a1df-d672c71ee99b", "metadata": {}, "source": [ "**A key part of the achitecture of pyMACS is the definition the scattering in the sample environment**\n", "\n", "There are two mandatory objects that must be defined and to run the simulation. They are :\n", "1) A scattering definition, which dictates the various possible scattering processes in the sample. Common choices are incoherent scattering and single crystal Bragg scattering. More advanced options are covered later in the documentation.\n", "2) The scattering geometry, including the sample holder. Using the UNION notation, one must specify the size and shape of the sample and its holder. Scattering processes for Aluminum have already been defined, support for more sample holder materials may be added in a future update." ] }, { "cell_type": "code", "execution_count": 5, "id": "1c33b2ce-640d-4b4c-b657-0ac751b12148", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", "Conversion of CIF to crystallographical LAU file successful. \n" ] } ], "source": [ "# The scattering definition comes first\n", "scattering_def = ms.McStas_instr(\"scattering_definition\",checks=False)\n", "# At launch of pyMACS, only \"Incoherent_process\", \"Single_crystal_process\",\n", "# and \"SQW4_process\" are supported. \n", "inc_scatter = scattering_def.add_component(\"inc_scatter\",\"Incoherent_process\")\n", "inc_scatter.sigma=macs.sample.sigma_inc\n", "inc_scatter.unit_cell_volume = macs.sample.cell_vol\n", "inc_scatter.packing_factor = 1\n", "inc_scatter.set_AT([0,0,0])\n", "\n", "#Single crystal process. \n", "crystal_scatter = scattering_def.add_component(\"crystal_scatter\",\"Single_crystal_process\")\n", "#Information about the mosaic is provided below\n", "crystal_scatter.delta_d_d=0.005\n", "crystal_scatter.mosaic = 30.0\n", "#Projections of lattice vectors onto lab frame is handled by the previous helper process.\n", "labproj = macs.sample.labframe_mat\n", "crystal_scatter.ax = labproj[0,0]\n", "crystal_scatter.ay = labproj[0,1]\n", "crystal_scatter.az = labproj[0,2]\n", "crystal_scatter.bx = labproj[1,0]\n", "crystal_scatter.by = labproj[1,1]\n", "crystal_scatter.bz = labproj[1,2]\n", "crystal_scatter.cx = labproj[2,0]\n", "crystal_scatter.cy = labproj[2,1]\n", "crystal_scatter.cz = labproj[2,2]\n", "# This requires a call to the function \"sample.cif2lau()\", which translates the input cif\n", "macs.sample.cif2lau()\n", "crystal_scatter.reflections='\\\"'+\"TiO2.lau\"+'\\\"'\n", "crystal_scatter.barns=1\n", "crystal_scatter.packing_factor=1\n", "crystal_scatter.powder=0\n", "crystal_scatter.PG=0\n", "crystal_scatter.interact_fraction=0.8\n", "crystal_scatter.set_AT([0,0,0])\n", "crystal_scatter.set_ROTATED([0,0,0])\n", "\n", "#Now, we combine these scattering processes to form a single TiO2 material\n", "scattering = scattering_def.add_component(\"TiO2\",\"Union_make_material\")\n", "scattering.process_string='\"crystal_scatter,inc_scatter\"'\n", "scattering.my_absorption=macs.sample.rho_abs\n", "scattering.set_AT([0,0,0])\n", "\n", "#IMPORTANT: This pseudo-instrument will be saved as the scattering definition of the sample. \n", "macs.sample.scattering_def = scattering_def" ] }, { "cell_type": "markdown", "id": "a899ce02-3fb3-4d62-b29e-349fcba73eb3", "metadata": {}, "source": [ "Define a geometry object representing the sample and its holder. " ] }, { "cell_type": "code", "execution_count": 6, "id": "c71db26b-ec7b-46b3-be5f-588f91a51537", "metadata": {}, "outputs": [], "source": [ "#Make a second object for the geometry. This particular case replicates the validation experiment for this package.\n", "geo_def = ms.McStas_instr(\"geometry_definition\",checks=False)\n", "\n", "sample_cube=geo_def.add_component(\"sample_cube\",\"Union_box\")\n", "sample_cube.xwidth=1.0*macs.sample.sample_widx\n", "sample_cube.yheight=1.0*macs.sample.sample_widy\n", "sample_cube.zdepth=1.0*macs.sample.sample_widz\n", "sample_cube.priority=100\n", "sample_cube.material_string='\\\"TiO2\\\"'\n", "sample_cube.number_of_activations=\"number_of_activations_sample\" #Do not change. \n", "sample_cube.set_AT([0,0,0],RELATIVE='crystal_assembly')\n", "sample_cube.set_ROTATED([0,0,0],RELATIVE='crystal_assembly')\n", "\n", "\n", "sample_plate = geo_def.add_component(\"sample_plate\",\"Union_cylinder\")\n", "sample_plate.radius=0.006\n", "sample_plate.yheight=0.002\n", "sample_plate.priority=40\n", "sample_plate.material_string='\"Al\"'\n", "plate_distance = macs.sample.sample_widy+0.002\n", "sample_plate.set_AT([0,plate_distance,0],RELATIVE=\"target\")\n", "sample_plate.set_ROTATED([0,0,0],RELATIVE=\"target\")\n", "\n", "sample_plate_rod = geo_def.add_component(\"sample_plate_rod\",\"Union_cylinder\")\n", "sample_plate_rod.radius=0.00125\n", "sample_plate_rod.yheight=0.0633\n", "sample_plate_rod.priority=41\n", "sample_plate_rod.material_string='\"Al\"'\n", "sample_plate_rod.set_AT([0,plate_distance+0.001+0.031,0], RELATIVE=\"target\")\n", "sample_plate_rod.set_ROTATED([0,0,0],RELATIVE=\"target\")\n", "\n", "sample_base = geo_def.add_component(\"sample_base\",\"Union_cylinder\")\n", "sample_base.radius=0.0065\n", "sample_base.yheight=0.013\n", "sample_base.priority=42\n", "sample_base.material_string='\\\"Al\\\"'\n", "sample_base.set_AT([0,0.0628,0],RELATIVE=\"target\")\n", "sample_base.set_ROTATED([0,0,0],RELATIVE=\"target\")\n", "\n", "sample_base_gap = geo_def.add_component(\"sample_base_gap\",\"Union_cylinder\")\n", "sample_base_gap.radius=0.004\n", "sample_base_gap.yheight=0.009\n", "sample_base_gap.priority=43\n", "sample_base_gap.material_string='\"Vacuum\"'\n", "sample_base_gap.set_AT([0,0.0668,0], RELATIVE=\"target\")\n", "sample_base_gap.set_ROTATED([0,0,0],RELATIVE=\"target\")\n", "\n", "# IMPORTANT: Assign the geometry definition to the sample.\n", "macs.sample.geometry_def = geo_def\n" ] }, { "cell_type": "markdown", "id": "c23f395d-4c33-47c5-a723-b937e27f9787", "metadata": {}, "source": [ "While this may seem intimidating at first, this is the most difficult part of setting up the instrument. Many different sample geometries can be built up using the mcstasscript language, the backend of the MACS simulation is constructed in this way.\n", "\n", "**Define parameters relevant to the McStas simulation:**\n", "\n", "There are a number of attributes of the virtualMACS object that dictate the Monte-Carlo simulation parameters. \n", "\n", "By default, McStas will create a new directory in the project folder containing all of the necessary files for the experiment. If the \"useOld\" option is flagged as true, the object will attempt to load in all previous simulated results. It will also preserve the directory, instead of deleting it and overwriting it with new files." ] }, { "cell_type": "code", "execution_count": 7, "id": "6dc44c09-06e8-4674-95e5-c5f5913591d2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING: Old instrument directory found. Older files deleted, instrument will need to be recompiled.\n", "/mnt/c/Users/tjh/OneDrive - NIST/GitHub/pyMACS/docs/source/notebooks\n", "#################\n", "\n", "Starting compilation of monochromator.\n", "\n", "Compilation of monochromator geometry successful.\n", "\n", "#################\n", "\n", "#################\n", "\n", "Starting compilation of sample kidney geometry.\n", "\n", "Compilation of sample kidney geometry successful.\n", "\n", "#################\n", "\n" ] } ], "source": [ "# It is usually a good idea to leave this flag as True, however if you want to \n", "# start from scratch it can be a good idea to make it False. \n", "macs.useOld=False\n", "\n", "if macs.useOld==True:\n", " macs.useOld=True\n", "else:\n", " macs.data.data_matrix=False\n", " # prepare_expt_directory populates the a folder in the base directory with all necessary files\n", " # to perform the simulation.\n", " macs.prepare_expt_directory()\n", " #The below command write the McStas .instr file for the full MACS simulation based on the \n", " # user-provided definitions above\n", " macs.edit_instr_file()\n", " macs.compileMonochromator()\n", " macs.compileInstr()\n" ] }, { "cell_type": "markdown", "id": "3309a458-f0c6-4c4c-b718-5d46d29153ac", "metadata": {}, "source": [ "All of the relevant McStas files have now been prepared, it may be instructive to browse them in \n", ">exptName/Instrument files/\n", "\n", "We assign a few more parameters relevant to the simulation. Here we are doing the simplest possible scan, which is defining a single instrumental configuration and running." ] }, { "cell_type": "markdown", "id": "292fd2e2-2b7d-4758-9e54-d937d0196b0d", "metadata": {}, "source": [ "**Assign Instrument Parameters**\n", "\n", "In this example, we use Ei=5meV = Ef" ] }, { "cell_type": "code", "execution_count": 13, "id": "1cc98114-b832-4b0a-85ee-d7418fbdfe67", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Scan complete. Saved to test_Ei_9.078_Ef_9.078_A3_67.3700_kidney_3.0000_dataMatrix.csv.\n" ] } ], "source": [ "macs.monochromator.Ei=9.078\n", "macs.kidney.Ef=9.078\n", "macs.A3_angle = 67.37\n", "macs.kidney.kidney_angle=3.0\n", "\n", "#The parameters n_sample and n_mono are the number of Monte-Carlo counts for the \n", "# sample end and the monochromator end of the simulation respectively. It is usually\n", "# appropriate for n_mono=10*n_sample. \n", "macs.n_sample=1e5\n", "macs.n_mono = 1e6\n", "\n", "\n", "macs.runMonoScan()\n", "csvname = macs.runKidneyScan()\n", "\n", "print(f\"Scan complete. Saved to {csvname}.\")" ] }, { "cell_type": "markdown", "id": "3fb89b9d-f22d-4507-8e84-0b57fdb3c0af", "metadata": {}, "source": [ "Simulation results live in the VirtualMACS.data.data_matrix, which is a pandas dataframe containing all simulation results. Results are also written to .csv files and .ng0 files which can be found in the simulation directory.\n", "\n", "There are a number of useful methods here for exporting and importing data. We start by loading the result of the previous scan, and appending it to the data matrix. We can also write it to an ng0 file to examine in DAVE, if you are more comfortable in that environment." ] }, { "cell_type": "code", "execution_count": 14, "id": "31181dd3-2194-4903-b51d-a664f34dba25", "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#The files are saved as csv's for now, add to the data_matrix manually.\n", "# The replace is due to a bad naming convention that I plan to fix in a future update.\n", "macs.data.load_data_matrix_from_csv(csvname.replace(macs.exptName,''))\n", "# Save this to a DAVE-readable ng0 file. \n", "macs.data.write_data_to_ng0(filename='test.ng0')" ] }, { "cell_type": "markdown", "id": "0e66bcb9-2e5f-486c-8dee-11d260d593c3", "metadata": {}, "source": [ "We can use the built in tools to visualize the data below:" ] }, { "cell_type": "code", "execution_count": 16, "id": "faab3110-8006-4772-a345-c964e2535543", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'TiO2 A3 Scan, Elastic')" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# The data must be converted from detector numbers and angles to the sample frame. \n", "macs.data.project_data_QE()\n", "U,V,I = macs.data.bin_constE_slice(120,120,[-2,2],[-2,2],[-1,1])\n", "\n", "plt.figure()\n", "plt.pcolormesh(U,V,I.T,vmin=0,vmax=20)\n", "plt.xlabel('[HH0]')\n", "plt.ylabel('[00L]')\n", "plt.title(\"TiO2 A3 Scan, Elastic\")\n" ] }, { "cell_type": "markdown", "id": "0b2b6e30-6b66-46a2-97d2-f013c15db8a5", "metadata": {}, "source": [ "As expected, a single scan won't do much good to visualize sample scattering. Below is an example showing a scripted A3/A4 scan.\n", "\n", "This method automatically appends the calculations to the data_matrix." ] }, { "cell_type": "code", "execution_count": 17, "id": "4d1c9a1e-26ed-419a-8883-9a6c70ef07db", "metadata": { "scrolled": true }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "63ca8e6f7ca54b939b3cdd4fe8b907de", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Total Scans: 0%| | 0/1 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "macs.data.project_data_QE()\n", "U,V,I = macs.data.bin_constE_slice(90,90,[-2,2],[-2,2],[-1,1])\n", "\n", "plt.figure()\n", "plt.pcolormesh(U,V,I.T,vmin=0,vmax=5000)\n", "plt.xlabel('[HH0]')\n", "plt.ylabel('[00L]')\n", "plt.title(\"TiO2 A3 Scan, Elastic\")" ] }, { "cell_type": "markdown", "id": "9b4a5fdc-b09c-4bc0-9771-f12cf6f0feab", "metadata": {}, "source": [ "With this, the most simple iteration of a pyMACS project is complete. " ] } ], "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.10.14" } }, "nbformat": 4, "nbformat_minor": 5 }