diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml index 656620e..b8ed6fc 100644 --- a/.github/workflows/docs.yaml +++ b/.github/workflows/docs.yaml @@ -17,10 +17,12 @@ jobs: steps: - name: Check out repo - uses: actions/checkout@v4 + uses: actions/checkout@v6 + with: + fetch-depth: 0 - name: Set up Python - uses: actions/setup-python@v5 + uses: actions/setup-python@v6 with: python-version: "3.12" cache: pip diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml index 8ed0517..b72600f 100644 --- a/.github/workflows/release.yaml +++ b/.github/workflows/release.yaml @@ -10,9 +10,9 @@ jobs: permissions: id-token: write steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - - uses: actions/setup-python@v5 + - uses: actions/setup-python@v6 with: python-version: "3.12" diff --git a/.gitignore b/.gitignore index c2ade99..edc0580 100644 --- a/.gitignore +++ b/.gitignore @@ -67,3 +67,6 @@ env/ ENV/ env.bak/ venv.bak/ + +# UV ignore +uv.lock diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ecaa7b..eb408fb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,20 +4,67 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [0.2.0] + +### Added + +- `SimpCalc` class for generating SIMPSON input files from Python. +- `simulate_spectrum()` convenience function with smart defaults (auto-calculates sw, offset, and ref from chemical shifts). +- CPMAS pulse sequence template. +- Support for custom pulse sequences via `CustomPulseSequence`. +- `Simpy` unified data container with lazy FID/spectrum conversion and automatic ppm calculation. +- `.csdf` (csdmpy) file format support, both reading and writing (`Simpy.write(format='csdf')`). +- GUI support for opening `.xreim` / `.csdf` files and saving in all supported formats. +- Comprehensive test suite. + +### Changed + +- Renamed `SimpSim` to `SimpCalc`. +- Bumped minimum Python version to 3.10. +- Replaced `print()` statements with `warnings.warn()` and `logging`. +- Replaced bare `except Exception:` catches with specific exception types. +- Added type hints and NumPy-style docstrings across all modules. +- Made VASP OUTCAR parser (`converter.py`) more robust with clear error messages for missing sections. +- DRY-ed up isotope data loading in `utils.py`. + +### Fixed + +- Time unit conversion bug (`* 10e3` should be `* 1e3` for seconds to milliseconds). +- `generate_spinsys()` double-wrapping mutation bug on repeated calls. +- `write_simp()` had wrong parameter names and caused circular import. +- `from_spe()` unnecessarily truncated spectral width with `int()`. +- `add_spectra()` accessed private `_spe_data` and crashed on FID-only input. +- `get_larmor_freq()` had copy-pasted docstring from `hz2ppm()`. +- Uninitialized variables in `read_spe()` / `read_fid()` gave confusing errors on malformed files. +- `read_simp()` was called with `format=` while its keyword was `fmt`, crashing `SimpCalc.run(read_output=True)`, `simulate_spectrum()`, and GUI file opening. The keyword is now `format` everywhere. +- `Simpy.write(format='xreim')` wrote a SIMP-header file without the time axis; it now writes the 3-column `time real imag` format that SIMPSON's `-xreim` flag produces and `read_simp()` expects. +- `Simpy.write(format='spe')` now preserves a shifted frequency axis via the `REF` header and writes `NP` as an integer. +- `read_csdf()` underestimated the spectral width by one bin (used the coordinate span instead of N x step). +- `_proton_freq_to_b0()` passed kHz/GHz strings through unconverted, causing a downstream `ValueError`; all Hz-based units are now normalised to MHz. +- GUI `open_files()` crashed with `UnboundLocalError` on uppercase or unknown file extensions; unsupported files are now skipped with a warning. +- `SimpCalc.run()` cleanup no longer deletes pre-existing files that share the output file name. +- `hz2ppm()` / `ppm2hz()` used the signed Larmor frequency, mirroring the ppm axis of every negative-gamma nucleus (e.g. 29Si, 15N, 17O). SIMPSON places +delta at +delta*|nu_L| regardless of the sign of gamma, so both conversions now use the magnitude (verified empirically against SIMPSON for 13C and 29Si). +- `simulate_spectrum()` spectral-width estimation used the signed Larmor frequency, collapsing the SW for negative-gamma nuclei; widths now use |nu_L|. +- `simulate_spectrum()` auto-centering put negative-gamma peaks off by 2x the center: the carrier `offset` follows the sign of gamma (rotating-frame frequency) while `ref` is always `-center_hz` (absolute axis). +- `_proton_freq_to_b0()` rejected scientific notation; `'8e8'` now parses to `'800.0MHz'`. +- `channels`/`nuclei` extraction regexes used `[\w\s]+`, which matches newlines and swallowed the following spinsys lines, so per-site nucleus detection from `detect_operator` could pick a token from the wrong line. +- `pulse_90` template failed on multi-channel spin systems (`pulse: arguments must match number of channels`); extra channels are now padded with `0 0`. +- `add_spectra()` set the combined spectral width to the coordinate span ((N-1) x step) instead of N x step when interpolating onto a common grid. + ## [0.1.1] -- Added a GUI for Simpyson -- Implemented FID to SPE convertion within GUI -- Implemented Hz to ppm convertion within GUI +- Added a GUI for Simpyson. +- Implemented FID to SPE conversion within the GUI. +- Implemented Hz to ppm conversion within the GUI. ## [0.1.0] -## Added +### Added -- Tutorial on converting DFT structures to Simpson simulations. -- Tutorial on reading and processing Simpson simulation results. -- Added isotopes data to convert from Hz to ppm. -- Added `SimpSim` class to prepare Simpson input files. +- Tutorial on converting DFT structures to SIMPSON simulations. +- Tutorial on reading and processing SIMPSON simulation results. +- Added isotope data to convert from Hz to ppm. +- Added `SimpSim` class to prepare SIMPSON input files. - Added `read_vasp` to convert VASP NMR tensors into a format readable by Soprano. - Templates for 90-degree pulse `pulse_90` and no-pulse `no_pulse` experiments. diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..f77c2b4 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,60 @@ +cff-version: 1.2.0 +title: Simpyson +message: >- + If you use this software, please cite it using the + metadata from this file. +type: software +authors: + - given-names: Carlos + family-names: Bornes + affiliation: >- + Department of Physical and Macromolecular Chemistry, + Faculty of Science, Charles University in Prague, 128 + 43, Prague, Czech Republic + orcid: 'https://orcid.org/0000-0002-0325-2356' + - given-names: Márcio + family-names: Soares + affiliation: >- + Department of Chemistry & CICECO-Aveiro Institute of + Materials, University of Aveiro, 3810-193, Aveiro, + Portugal + orcid: 'https://orcid.org/0000-0001-8012-2662' + - given-names: Daniel + family-names: Pereira + affiliation: >- + Institute of Molecular Physical Science, + Department of Chemistry and Applied Biosciences, + ETH Zürich, Vladimir-Prelog-Weg 1-5 / 10, + 8093 Zurich, Switzerland + orcid: 'https://orcid.org/0000-0001-7329-2516' + - given-names: J. Kane + family-names: Shenton + affiliation: >- + Scientific Computing, Science & Technology Facilities + Council, Rutherford Appleton Laboratory, Harwell Science + Campus, Oxfordshire, OX11 0QX, United Kingdom + orcid: 'https://orcid.org/0000-0003-4485-3446' +identifiers: + - type: doi + value: 10.5281/zenodo.20042403 +repository-code: 'https://github.com/nuts-org/simpyson' +url: 'https://nuts-org.github.io/simpyson/' +abstract: >- + Simpyson is a Python interface to the SIMPSON solid-state NMR simulation + software. It provides tools for building SIMPSON input files from DFT + outputs (VASP, CASTEP, Quantum ESPRESSO), running simulations + programmatically, and reading simulation results into a unified data + container. Key features include automatic spectral width and offset + estimation, built-in pulse sequence templates (including CPMAS), CSDM + file support for interoperability with EasyNMR, and an interactive GUI + for visualising and combining spectra. +keywords: + - solid-state NMR + - NMR simulation + - SIMPSON + - DFT + - computational chemistry + - Python +license: MIT +version: 0.2.0 +date-released: '2026-05-20' diff --git a/README.md b/README.md index 7d9756f..7c85780 100644 --- a/README.md +++ b/README.md @@ -1,25 +1,64 @@ # SimPYson: A Pythonic Interface for SIMPSON [![DOI](https://zenodo.org/badge/813117518.svg)](https://doi.org/10.5281/zenodo.14041918) +![Python - Version](https://img.shields.io/pypi/pyversions/simpyson) +![PyPI - Version](https://img.shields.io/pypi/v/simpyson?color=blue) -SimPYson is a Python package designed to simplify the use of [SIMPSON](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson), a powerful code to simulate solid-state NMR experiments. Born out of the need to streamline the process, SimPYson makes it easier to prepare input files from DFT calculations and analyze results from SIMPSON simulations all within a Python. +SimPYson is a Python package that makes it easier to work with [SIMPSON](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson), a code for simulating solid-state NMR experiments. It handles preparing input files from DFT calculations, running simulations, and reading results — all from Python. -## Features 🤌 +## Features -- **Convert DFT data to SIMPSON input files**: Prepare SIMPSON input files from DFT data (CASTEP, Quantum Espresso, VASP). +- **Run SIMPSON simulations from Python**: Use `simulate_spectrum()` for smart defaults or `SimpCalc` for full control over spin systems, pulse sequences, and output. +- **Convert DFT data to SIMPSON input files**: Prepare spin systems from CASTEP, Quantum Espresso, and VASP calculations via ASE and Soprano. +- **Read SIMPSON output files**: Load `.spe`, `.fid`, `.xreim`, and `.csdf` files into a unified `Simpy` object with automatic FID↔spectrum conversion and ppm scaling. +- **Pulse sequence templates**: Built-in templates for no-pulse, 90° pulse, and CPMAS experiments. Custom Tcl sequences are also supported. +- **Graphical User Interface**: Launch with `simpyson gui` to inspect and process spectra without any coding. -- **Read SIMPSON output files**: Load and manipulate NMR data from SIMPSON `.spe`, `.fid`, and `.xreim` files directly in Python for further analysis and visualization. +## Quick Start -- **Graphical User Interface**: You can type `simpyson gui` in your terminal to get Simpyson graphical user interface, and manipulate the data without any coding required. +**Read a SIMPSON output file:** -- **Templates for common experiments**: Use ready-made templates for typical Simpson NMR simulations, currently 90-degree pulse and no-pulse. More soon. +```python +from simpyson import read_simp -## Documentation 📖 +data = read_simp("ethanol.spe", b0="400MHz", nucleus="1H") +print(data.ppm['ppm']) # ppm axis, auto-calculated +print(data.spe['hz']) # Hz axis +``` -To learn more about simpyson, including some tutorials check the [documentation](https://nuts-org.github.io/simpyson/). +Accessing `.fid` on a spectrum file (or `.spe` on a FID) triggers automatic conversion via FFT — no manual processing needed. -# Planned Features 🔜 +**Simulate a spectrum directly from Python:** -- **Expand number of pulse sequences**: Additional templates for more complex NMR experiments. +```python +from simpyson import simulate_spectrum -- **Expand number of DFT codes**: Improve the support of other DFT codes, suggestions are welcomed. +spinsys = """ +channels 13C +nuclei 13C 13C +shift 1 10p 0 0 0 0 0 +shift 2 50p 0 0 0 0 0 +""" + +result = simulate_spectrum(spinsys, proton_frequency=400e6, spin_rate=10000) +print(result.ppm['ppm']) +``` + +`simulate_spectrum()` automatically estimates the spectral width and carrier offset from the chemical shifts. For full control over all parameters, use `SimpCalc` directly — see the [documentation](https://nuts-org.github.io/simpyson/). + +## Installation + +```bash +pip install git+https://github.com/nuts-org/simpyson.git +``` + +Requires Python ≥ 3.10 and a working [SIMPSON](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson) installation for running simulations. + +## Documentation + +Full documentation and tutorials are available at [nuts-org.github.io/simpyson](https://nuts-org.github.io/simpyson/). + +## Planned Features + +- Additional pulse sequence templates for more complex NMR experiments. +- Broader support for DFT codes — suggestions welcome. diff --git a/docs/about/contributors.md b/docs/about/contributors.md index fa155c1..55dd0f0 100644 --- a/docs/about/contributors.md +++ b/docs/about/contributors.md @@ -1,6 +1,6 @@ # People -SimPYson was originally developed by [Carlos Bornes](https://physchem.cz/people/carlos-bornes/). +SimPYson is currently maintained by Carlos, Márcio and Daniel as part of NUTS. ## Active Maintainers diff --git a/docs/images/gui.png b/docs/images/gui.png new file mode 100644 index 0000000..e8cdc02 Binary files /dev/null and b/docs/images/gui.png differ diff --git a/docs/index.md b/docs/index.md index 3646450..da68737 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,18 +1,20 @@ -`SimPYson` is a Python package developed to streamline the use of [SIMPSON](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson), a simulation software for solid-state NMR. Born out of the frustration of trying to learn and use SIMPSON on my own, SimPYson aims to simplify the process of converting DFT calculation results into SIMPSON input files and read Simpson simulation, all within python +`SimPYson` is a Python package developed to streamline the use of [SIMPSON](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson), a simulation software for solid-state NMR. Born out of the frustration of trying to learn and use SIMPSON on our own, SimPYson aims to simplify the process of converting DFT calculation results into SIMPSON input files, running simulations, and reading SIMPSON output all within Python. -## Current features 🤌 +## Current features -- Convert results from DFT calculations (e.g., CASTEP, Quantum Espresso, VASP) into SIMPSON input files. -- Read and process output files from SIMPSON simulations. -- Provide ready-to-use templates for common SIMPSON NMR experiments, such as 90-degree pulse and no-pulse. +- **Convert DFT data to SIMPSON input**: Prepare SIMPSON input files from DFT calculations (CASTEP, Quantum Espresso, VASP) using [ASE](https://ase-lib.org/) and [Soprano](https://ccp-nc.github.io/soprano/intro.html). +- **Run simulations from Python**: Use `SimpCalc` or `simulate_spectrum()` to generate, execute, and read SIMPSON simulations without writing Tcl manually. +- **Read and process output files**: Load `.spe`, `.fid`, `.xreim`, and `.csdf` files from SIMPSON into the unified `Simpy` data container. +- **Pulse sequence templates**: Ready-made templates for no-pulse, 90-degree pulse, and CPMAS experiments, plus support for custom pulse sequences. +- **Graphical User Interface**: Launch with `simpyson gui` to view, combine, and convert spectra interactively (PyQt5 + Plotly). -## Why choose SimPYson? 🙎‍♂️ +## Why choose SimPYson? -No particular reason. One possible advantage lies in its seamless integration with other Python packages, making it easy to incorporate into your existing Python workflow. However, depending on your needs/taste, there are a few alternatives that may better suit you, hera are some examples: +One possible advantage lies in its seamless integration with other Python packages, making it easy to incorporate into your existing Python workflow. However, depending on your needs/taste, there are a few alternatives that may better suit you, here are some examples: -- [Simplot](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson): From the developers of Simpson offers a user-friendly interface to analyze the results. -- [Simview](https://github.com/zdetos/Simpson-View): From [Zdeněk Tošner](https://optimal-nmr.net/about.html) (Simpson dev) provides a GUI to run SIMPSON simulations and plot results within a clean, intuitive interface +- [Simplot](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson): From the developers of SIMPSON, offers a user-friendly interface to analyze the results. +- [Simview](https://github.com/zdetos/Simpson-View): From [Zdenek Tosner](https://optimal-nmr.net/about.html) (SIMPSON dev), provides a GUI to run SIMPSON simulations and plot results within a clean, intuitive interface. - [EasyNMR](https://easynmr.pastis.dk/): A cloud-based platform that allows you to run and analyze SIMPSON simulations remotely. -## Future -We are open to suggestions. \ No newline at end of file +## Future +We are open to suggestions. diff --git a/docs/installation/install.md b/docs/installation/install.md index 2a488a0..c0af3f0 100644 --- a/docs/installation/install.md +++ b/docs/installation/install.md @@ -1,15 +1,31 @@ # Installation -If you have Python and pip installed, you can easily install SimPYson with the following command: +## Prerequisites + +- **Python >= 3.10** +- **SIMPSON** -- required only for *running* simulations (not needed for reading/converting files). Download from the [SIMPSON website](https://inano.au.dk/about/research-centers-and-projects/nmr/software/simpson) and make sure the `simpson` command is available in your PATH. + +## Install SimPYson + +If you have Python and pip installed, you can install SimPYson with: ```bash pip install git+https://github.com/nuts-org/simpyson.git ``` -All dependecies are installed automatically. +All dependencies are installed automatically. + +## Verify the installation -To verify that the package has been installed successfully, open a Python console and run: +Open a Python console and run: ```python import simpyson +print(simpyson.__version__) +``` + +To check that the GUI works: + +```bash +simpyson gui ``` diff --git a/docs/user_guide/01_reading_files.ipynb b/docs/user_guide/01_reading_files.ipynb new file mode 100644 index 0000000..6655032 --- /dev/null +++ b/docs/user_guide/01_reading_files.ipynb @@ -0,0 +1,480 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "60119bd5", + "metadata": {}, + "source": [ + "# Read SIMPSON files with SimPYson" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "217bccd6", + "metadata": { + "id": "d8c1d6a1", + "language": "python" + }, + "outputs": [], + "source": [ + "from simpyson.io import read_simp\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "853b0122", + "metadata": { + "id": "509f03d6", + "language": "markdown" + }, + "source": [ + "## Introduction\n", + "\n", + "SimPYson provides a unified interface to read and work with SIMPSON NMR data. \n", + "In the `examples` folder, you can find various SIMPSON files:\n", + "\n", + "- `ethanol.in`: A standard input file for a SIMPSON simulation of the ethanol molecule\n", + "- `ethanol.fid`: The simulated free induction decay (FID) of the ethanol molecule\n", + "- `ethanol.spe`: The NMR spectrum of the ethanol molecule\n", + "\n", + "The `read_simp()` function reads SIMPSON files into a unified `Simpy` object that handles conversions between formats automatically." + ] + }, + { + "cell_type": "markdown", + "id": "2a319e88", + "metadata": {}, + "source": [ + "## The Simpy object\n", + "\n", + "The `Simpy` class provides a unified interface for working with Simpson NMR data in various formats. Its key features are:\n", + "\n", + "- Reading SIMPSON files (FID, SPE, XREIM)\n", + "- Automatically convert between time and frequency domains\n", + "- Convert Hz to ppm when magnetic field (B0) and nucleus (e.g. 1H) are provided\n", + "- Export data to SIMPSON formats and csv" + ] + }, + { + "cell_type": "markdown", + "id": "8f72d4b8", + "metadata": {}, + "source": [ + "## Reading FID files\n", + "\n", + "Let's start by reading a FID file. The `read_simp()` function automatically detects the file format from its extension." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7b76cb21", + "metadata": { + "id": "84b1c6f7", + "language": "python" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real: array with 4096 points, first 5: [95.9999136 63.5468932 20.9678205 15.3255165 7.47400991]\n", + "imag: array with 4096 points, first 5: [ 0. 52.0761046 48.2650021 34.3591044 39.1643879]\n", + "np: 4096.0\n", + "sw: 10000.0\n", + "time: array with 4096 points, first 5: [0. 0.1 0.2 0.3 0.4]\n" + ] + } + ], + "source": [ + "# Read a FID file\n", + "data = read_simp('../../examples/read/ethanol.fid')\n", + "\n", + "# Access the data through the fid property\n", + "fid_data = data.fid\n", + "for key, value in fid_data.items():\n", + " if isinstance(value, np.ndarray) and len(value) > 5:\n", + " print(f\"{key}: array with {len(value)} points, first 5: {value[:5]}\")\n", + " else:\n", + " print(f\"{key}: {value}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5fca5e0b", + "metadata": { + "id": "6a9bdb92", + "language": "markdown" + }, + "source": [ + "### Plotting FID data\n", + "\n", + "The FID data can be easily plotted using matplotlib:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1c85ebee", + "metadata": { + "id": "6db9f882", + "language": "python" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plt.plot(data.fid['time'], data.fid['real'], label='Real')\n", + "plt.plot(data.fid['time'], data.fid['imag'], label='Imaginary')\n", + "plt.xlabel('Time (ms)')\n", + "plt.ylabel('Intensity')\n", + "plt.title('Free Induction Decay (FID)')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a9f104c4", + "metadata": { + "id": "a6bd76fd", + "language": "markdown" + }, + "source": [ + "## Reading SPE files\n", + "\n", + "When reading a spectrum (SPE) file, data is accessible through the `spe` property:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a0bae490", + "metadata": { + "id": "378eff83", + "language": "python" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real: array with 4096 points, first 5: [0.18006085 0.19032725 0.1798519 0.19019057 0.17964413]\n", + "imag: array with 4096 points, first 5: [-20.1918974 -20.1791859 -20.0945303 -20.0819291 -19.9973317]\n", + "np: 4096.0\n", + "sw: 10000.0\n", + "hz: array with 4096 points, first 5: [-5000. -4997.55859375 -4995.1171875 -4992.67578125\n", + " -4990.234375 ]\n" + ] + } + ], + "source": [ + "# Read a SPE file\n", + "spe_data = read_simp('../../examples/read/ethanol.spe')\n", + "\n", + "# Examine the spectrum data\n", + "for key, value in spe_data.spe.items():\n", + " if isinstance(value, np.ndarray) and len(value) > 5:\n", + " print(f\"{key}: array with {len(value)} points, first 5: {value[:5]}\")\n", + " else:\n", + " print(f\"{key}: {value}\")" + ] + }, + { + "cell_type": "markdown", + "id": "028f2919", + "metadata": { + "id": "963c18f0", + "language": "markdown" + }, + "source": [ + "### Plotting Spectrum Data\n", + "\n", + "The 1H NMR spectrum of ethanol shows three distinct 1H NMR peaks:\n", + "\n", + "- A triplet from the CH3 group\n", + "- A quartet from the CH2 group\n", + "- A singlet from the OH group\n", + "\n", + "You can edit the J-coupling parameters in the `examples/ethanol.in` file to see the effect on peak splitting." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "13cbffe5", + "metadata": { + "id": "05959409", + "language": "python" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plt.plot(spe_data.spe['hz'], spe_data.spe['real'])\n", + "plt.xlabel('Frequency (Hz)')\n", + "plt.ylabel('Intensity')\n", + "plt.title('¹H NMR Spectrum of Ethanol')\n", + "plt.xlim(3000, 0) # Reverse x-axis to match conventional NMR display\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d4ba185c", + "metadata": { + "id": "7bd8c08c", + "language": "markdown" + }, + "source": [ + "## Converting to Chemical Shift (ppm)\n", + "\n", + "To display the spectrum in chemical shift (ppm) units, provide the magnetic field (`b0`) and nucleus when reading the file. The ppm scale is automatically calculated:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8cbfec25", + "metadata": { + "id": "f8e98e7f", + "language": "python" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA18AAAHaCAYAAAD/pPMrAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAh/RJREFUeJzt3Xd8FGX+B/DPzG520xMIKdQAovSOQqyoSA6RE+VUBBUV9dSAB/zOwp2HgJ5YzkNUBLGA3smpoKJioYkoGopolCLYQBBIoSQhbdvM74/NzM7sbnqyM8t+3q8Xr+zOzs4+2YeZzPcp30eQZVkGERERERERtSjR6AIQERERERFFAgZfREREREREIcDgi4iIiIiIKAQYfBEREREREYUAgy8iIiIiIqIQYPBFREREREQUAgy+iIiIiIiIQoDBFxERERERUQgw+CIiIiIiIgoBBl9EREREREQhwOCLiKiFLFq0CIMGDUJUVBRmz55tdHGIiIjIYAy+iIhaSNu2bTF79myMGzfO6KIQERGRCTD4IiJqIWPHjsUf//hHJCcnG10UItX27dtx7rnnIi4uDoIgIC8vr8U+a/bs2RAEAceOHWuxz2gOy5YtgyAIOHDggNFFIaLTHIMvIiKDKDd8X3/9ddDXhw8fjj59+tTrGNHR0Th8+HC9jqG8RxAEbN68OeA9siyjY8eOEAQBV1xxRdD3CYIAq9WK9u3b4+abbw762TXZuXMn/vSnPyEzMxPR0dFo3749LrvsMjz77LP1PkZL+eqrrzB79mwUFxcbXZQW4XK5cM011+DEiROYP38+/vOf/yAzMzPovv717f9vy5Yt6r6n+/dGRNRcrEYXgIiIms7hcOCxxx5rUAATHR2N5cuX4/zzz9dt37RpE37//XfY7fag75s7dy66dOmCqqoqbNmyBcuWLcPmzZuxa9cuREdH1/qZX331FS6++GJ06tQJt99+OzIyMnDo0CFs2bIFCxYswNSpU+td/pbw1VdfYc6cObj55ptPyx7LX375Bb/99htefPFF3HbbbfV6j1Lf/rp166Y+Pt2/NyKi5sLgi4joNDBgwAC8+OKLmDlzJtq1a1ev91x++eVYsWIFnnnmGVitvj8Hy5cvx+DBg2scKjZq1CgMGTIEAHDbbbehTZs2ePzxx/H+++/j2muvrfUz//nPfyIpKQnbt28PuEkvLCysV7nNpLy8HHFxcUYXo96U77ghAZK2vomIqGk47JCI6DTwt7/9DR6PB4899li933P99dfj+PHjWLdunbrN6XRi5cqVmDBhQr2Pc8EFFwDw9qrU5ZdffkHv3r2D3vynpaXpnivzhfbu3Ytrr70WiYmJSElJwV/+8hdUVVXp9j18+DBuvfVWpKenw263o3fv3njllVcCPuPw4cOYPHky2rVrB7vdji5duuCuu+6C0+nE7Nmzce+99wIAunTpog6vU+YBKeXZs2cPJkyYgFatWqm9hjfffDM6d+4c8HnKe/yf//jjj7jhhhuQlJSE1NRU/OMf/4Asyzh06BCuvPJKJCYmIiMjA0899VSd36ni22+/xahRo5CYmIj4+HhceumluqGBN998My666CIAwDXXXANBEDB8+PB6H78mdX1vAFBcXKz2iiUlJeGWW25BRUWF7ji//fYb7r77bnTv3h0xMTFISUnBNddcEzAPS/kOf/755zqPWdd3QkQUauz5IiJqIW63G263Gx6PB263G1VVVYiKioLFYtHtV1JSErSXyeVy1fuzunTpgptuugkvvvgiHnjggXr1fnXu3BlZWVn43//+h1GjRgEAPv74Y5SUlGD8+PF45pln6vXZys1xq1at6tw3MzMTubm52LVrV53z2RTXXnstOnfujHnz5mHLli145plncPLkSbz22msAgIKCAgwbNgyCIGDKlClITU3Fxx9/jMmTJ6O0tBTTpk0DABw5cgTnnHMOiouLcccdd6BHjx44fPgwVq5ciYqKClx99dX48ccf8b///Q/z589HmzZtAACpqam68lxzzTU488wz8eijj0KW5Xr9Dv6uu+469OzZE4899hg+/PBDPPLII2jdujVeeOEFXHLJJXj88cfx+uuv469//SvOPvtsXHjhhbUeb/fu3bjggguQmJiI++67D1FRUXjhhRcwfPhwbNq0CUOHDsWf//xntG/fHo8++ijuuecenH322UhPT6+zrMH+fwqCgJSUFACo1/d27bXXokuXLpg3bx6++eYbvPTSS0hLS8Pjjz+u7rN9+3Z89dVXGD9+PDp06IADBw5g0aJFGD58OPbs2YPY2FhdGeo6Zn2+EyKikJOJiKhFPPTQQzIA3b+lS5eqry9dujTgdf9/vXv3rvUzlGNs375d/uWXX2Sr1Srfc8896usXXXRRwDG073nuuefkhIQEuaKiQpZlWb7mmmvkiy++WJZlWc7MzJRHjx4d8L7169fLRUVF8qFDh+SVK1fKqampst1ulw8dOlTnd7J27VrZYrHIFotFzsrKku+77z55zZo1stPprPH7++Mf/6jbfvfdd8sA5O+++06WZVmePHmy3LZtW/nYsWO6/caPHy8nJSWpv9tNN90ki6Iob9++PeCzJEmSZVmWn3zySRmAvH///hrLc/311we8NmnSJDkzM7PG9/g/v+OOO9Rtbrdb7tChgywIgvzYY4+p20+ePCnHxMTIkyZNCjiuv7Fjx8o2m03+5Zdf1G1HjhyRExIS5AsvvFDdtnHjRhmAvGLFijqPWdv/T7vdrtu3pu9N+X1vvfVW3farrrpKTklJ0W1T6kkrNzdXBiC/9tprDT5mfb8T7e8arN6JiJoThx0SEbWQ2bNnQ5Zl3b+bb745YL+FCxdi3bp1Af/69evXoM/r2rUrbrzxRixZsgRHjx6t13uuvfZaVFZWYvXq1Th16hRWr15d55DDESNGIDU1FR07dsSf/vQnxMXF4f3330eHDh3q/LzLLrsMubm5+OMf/4jvvvsOTzzxBLKzs9G+fXu8//77Qd+Tk5Oje64k5fjoo48gyzLefvttjBkzBrIs49ixY+q/7OxslJSU4JtvvoEkSVi1ahXGjBkTdP6SdmhgXe68885671sTbbILi8WCIUOGQJZlTJ48Wd2enJyM7t2749dff631WB6PB2vXrsXYsWPRtWtXdXvbtm0xYcIEbN68GaWlpY0ua7D/nx9//HGDjuH/nV1wwQU4fvy4rlwxMTHqY5fLhePHj6Nbt25ITk7GN99806BjtvR3QkTUWBx2SERksHPOOSdoQNCqVasGr4/04IMP4j//+Q8ee+wxLFiwoM79U1NTMWLECCxfvhwVFRXweDz405/+VOt7Fi5ciLPOOgslJSV45ZVX8Pnnn9eYGTGYs88+G++88w6cTie+++47vPvuu5g/fz7+9Kc/IS8vD7169dLtf+aZZ+qen3HGGRBFEQcOHEBRURGKi4uxZMkSLFmyJOjnFRYWoqioCKWlpfUe6libYJn/GqpTp06650lJSYiOjlaH7Gm3Hz9+vNZjFRUVoaKiAt27dw94rWfPnpAkCYcOHULv3r0bVdaa/n82hP/vqwxRPXnyJBITEwEAlZWVmDdvHpYuXYrDhw/rhnSWlJQ06JgVFRUt+p0QETUWgy8iotNI165dccMNN2DJkiV44IEH6vWeCRMm4Pbbb0d+fj5GjRpVZyY87c342LFjcf7552PChAnYt28f4uPj611Wm82Gs88+G2effTbOOuss3HLLLVixYgUeeuihWt+n7aWSJAkAcMMNN2DSpElB9+/Xr1+j52YFo+2hCVYmLY/HE3S7/7y/mrYBaNayG6U+v9vUqVOxdOlSTJs2DVlZWUhKSoIgCBg/frxazw09JhGR2TD4IiI6zTz44IP473//q0tmUJurrroKf/7zn7Flyxa8+eabDfosi8WCefPm4eKLL8Zzzz1X74DPnxLMBRsu+dNPP+l6m37++WdIkoTOnTsjNTUVCQkJ8Hg8GDFiRI3HlyQJiYmJ2LVrV63laMjwQ61WrVoFXWD4t99+a9TxGiI1NRWxsbHYt29fwGt79+6FKIro2LFji5ahsd+b1sqVKzFp0iRdhseqqqpGLdxshu+EiCgYzvkiIjrNnHHGGbjhhhvwwgsvID8/v8794+PjsWjRIsyePRtjxoxp8OcNHz4c55xzDp5++umAFPD+Nm7cGLRn4qOPPgKAoMPEFi5cqHuuLCQ9atQoWCwWjBs3Dm+//XbQwKqoqAgAIIoixo4diw8++ABff/11wH5KmZQ1uxp6w3/GGWegpKQE33//vbrt6NGjePfddxt0nMawWCwYOXIk3nvvPV1a9oKCAnURbWVoX0tp7PemZbFYAv5vPPvsszX2HtZ1LKO/EyKiYNjzRUR0Gvr73/+O//znP9i3b1+95rXUNGSvvu69915cc801WLZsWa0JKaZOnYqKigpcddVV6NGjB5xOJ7766iu8+eab6Ny5M2655ZaA9+zfvx9//OMf8Yc//AG5ubn473//iwkTJqB///4AgMceewwbN27E0KFDcfvtt6NXr144ceIEvvnmG6xfvx4nTpwAADz66KNYu3YtLrroItxxxx3o2bMnjh49ihUrVmDz5s1ITk7G4MGDAXi/v/HjxyMqKgpjxoypcyHl8ePH4/7778dVV12Fe+65BxUVFVi0aBHOOuusoMkimtsjjzyCdevW4fzzz8fdd98Nq9WKF154AQ6HA0888USTjv3xxx9j7969AdvPPfdcNZlFTd9bQ1xxxRX4z3/+g6SkJPTq1Qu5ublYv369mtK+oVryOyEiaiwGX0REp6Fu3brhhhtuwKuvvhqSz7v66qtxxhln4F//+hduv/32Gufj/Otf/8KKFSvw0UcfYcmSJXA6nejUqRPuvvtuPPjgg0Hnm7355puYNWsWHnjgAVitVkyZMgVPPvmk+np6ejq2bduGuXPn4p133sHzzz+PlJQU9O7dWzf0sn379ti6dSv+8Y9/4PXXX0dpaSnat2+PUaNGqWtInX322Xj44YexePFifPLJJ5AkCfv3768z+EpJScG7776LGTNm4L777lPXn/rpp59CEnz17t0bX3zxBWbOnIl58+ZBkiQMHToU//3vf5u8ntWsWbOCbl+6dKkafNX0vTXEggULYLFY8Prrr6OqqgrnnXce1q9fj+zs7EaVuyW/EyKixhJkzkwlIiITmj17NubMmYOioqKALIBEREThiHO+iIiIiIiIQoDBFxERERERUQgw+CIiIiIiIgoBzvkiIiIiIiIKAfZ8ERERERERhQCDLyIiIiIiohBg8EVERERERBQCXGS5HiRJwpEjR5CQkABBEIwuDhERERERGUSWZZw6dQrt2rWDKDasL4vBVz0cOXIEHTt2NLoYRERERERkEocOHUKHDh0a9B4GX/WQkJAAAPjtt9+QnJxsbGEilCRJKCoqQmpqaoNbGKh5sA6MxzowHuvAeKwD47EOjMc6MFZxcTEyMzPVGKEhGHzVgzLUMDExEYmJiQaXJjJJkoSqqiokJibyImMQ1oHxWAfGYx0Yj3VgPNaB8VgHxpIkCQAaNR2JtUVERERERBQCDL6IiIiIiIhCgMEXERERERFRCDD4IiIiIiIiCgEGX0RERERERCHA4IuIiIiIiCgEGHwRERERERGFAIMvIiIiIiKiEGDwRUREREREFAIMvoiIiIiIiEKAwRcREREREVEIMPgiIiIiIiIKAQZfREREREREIcDgi4iIiIgoTGw/cAI3L92OgyerjC4KNYLV6AIQEREREVH9XLM4FwBw8HgZPu3eyeDSUEOx54uIiIiIKMwcLnEYXQRqBAZfRERERERhxuWRjS4CNQKDLyIiIiIiohBg8EVERERERBQCDL6IiIiIiIhCgMEXERERERFRCDD4IiIiIiIiCgEGX0RERERERCHA4IuIiIiIiCgEGHwRERERERGFAIMvIiIiIqIwIQpGl4CagsEXEREREVGYiLLw9j2csfaIiIiIiMIEg6/wxtojIiIiIgoTVgvHHYYzBl9ERERERGGCPV/hjbVHRERERBQmophxI6wx+CIiIiIiChNRVt6+hzPWHhERERFRmLCy5yusMfgiIiIiIgoT2jlfsiwbWBJqDAZfRERERERhQht8OT2SgSWhxjA0+OrcuTMEQQj4l5OTAwCoqqpCTk4OUlJSEB8fj3HjxqGgoEB3jIMHD2L06NGIjY1FWloa7r33Xrjdbt0+n332GQYNGgS73Y5u3bph2bJlofoViYiIiIiajTbVvNPN4CvcGBp8bd++HUePHlX/rVu3DgBwzTXXAACmT5+ODz74ACtWrMCmTZtw5MgRXH311er7PR4PRo8eDafTia+++gqvvvoqli1bhlmzZqn77N+/H6NHj8bFF1+MvLw8TJs2DbfddhvWrFkT2l+WiIiIiKiJRMEXfHkkDjsMN1YjPzw1NVX3/LHHHsMZZ5yBiy66CCUlJXj55ZexfPlyXHLJJQCApUuXomfPntiyZQuGDRuGtWvXYs+ePVi/fj3S09MxYMAAPPzww7j//vsxe/Zs2Gw2LF68GF26dMFTTz0FAOjZsyc2b96M+fPnIzs7O+S/MxERERFRc2DoFX4MDb60nE4n/vvf/2LGjBkQBAE7duyAy+XCiBEj1H169OiBTp06ITc3F8OGDUNubi769u2L9PR0dZ/s7Gzcdddd2L17NwYOHIjc3FzdMZR9pk2bVmNZHA4HHA6H+ry0tBQAIEkSJIndu0aQJAmyLPP7NxDrwHisA+OxDozHOjAe68BgmiQbHg/vTY3QlO/cNMHXqlWrUFxcjJtvvhkAkJ+fD5vNhuTkZN1+6enpyM/PV/fRBl7K68prte1TWlqKyspKxMTEBJRl3rx5mDNnTsD2oqIiOJ3ORv1+1DSSJKGkpASyLEMUmSfGCKwD47EOjMc6MB7rwHisA2M5XS71cWFREaRKu4GliUwlJSWNfq9pgq+XX34Zo0aNQrt27YwuCmbOnIkZM2aoz0tLS9GxY0ekpqYGBIMUGpIkQRAEpKam8kJvENaB8VgHxmMdGI91YDzWgbGs1l/Ux23atEFaYmBHArUsm83W6PeaIvj67bffsH79erzzzjvqtoyMDDidThQXF+sCnoKCAmRkZKj7bNu2TXcsJRuidh//DIkFBQVITEwM2usFAHa7HXZ7YCuCKIq8yBhIEATWgcFYB8ZjHRiPdWA81oHxWAfG0Q94E1gHBmjKd26K2lq6dCnS0tIwevRoddvgwYMRFRWFDRs2qNv27duHgwcPIisrCwCQlZWFnTt3orCwUN1n3bp1SExMRK9evdR9tMdQ9lGOQUREREQULrQLKzPhRvgxPPiSJAlLly7FpEmTYLX6OuKSkpIwefJkzJgxAxs3bsSOHTtwyy23ICsrC8OGDQMAjBw5Er169cKNN96I7777DmvWrMGDDz6InJwctefqzjvvxK+//or77rsPe/fuxfPPP4+33noL06dPN+T3JSIiIiJqLE3sBUlm+BVuDB92uH79ehw8eBC33nprwGvz58+HKIoYN24cHA4HsrOz8fzzz6uvWywWrF69GnfddReysrIQFxeHSZMmYe7cueo+Xbp0wYcffojp06djwYIF6NChA1566SWmmSciIiKisKMNuBh7hR/Dg6+RI0fquk+1oqOjsXDhQixcuLDG92dmZuKjjz6q9TOGDx+Ob7/9tknlJCIiIiIymnZdZQZf4cfwYYdERERERFQ/+jlfjL7CDYMvIiIiIqIwIbPnK6wx+CIiIiIiChPa3i4m3Ag/DL6IiIiIiMKEbs6XccWgRmLwRUREREQUJrS9XRKjr7DD4IuIiIiIKFxoAy4OOww7DL6IiIiIiMIEe77CG4MvIiIiIqIwoV/ni9FXuGHwRUREREQUJvTZDg0sCDUKgy8iIiIiojAhSb7HjL3CD4MvIiIiIqIwxGGH4YfBFxERERFRmNAm3GDsFX4YfBERERERhQld8MWBh2GHwRcRERERUZjQ9nYx4Ub4YfBFRERERBQm9KnmjSsHNQ6DLyIiIiKiMCHr5nwx+go3DL6IiIiIiMKEXMNjCg8MvoiIiIiIwoQ24YbEnq+ww+CLiIiIiChMyJzzFdYYfBERERERhQl9qnkKNwy+iIiIiIjChC7VPHPNhx0GX0REREREYYIZDsMbgy8iIiIiojAh6RZZZiAWbhh8ERERERGFCd2cL8ZeYYfBFxERERFRmNDGW+z5Cj8MvoiIiIiIwoTMbIdhjcEXEREREVGY4Dpf4Y3BFxERERFRmNDP+WL0FW4YfBERERERhQlttkOGXuGHwRcRERERURjw7+liwo3ww+CLiIiIiCgM+MdajL3CD4MvIiIiIqIw4N/TxTlf4YfBFxERERFRGPAPtRh6hR8GX0REREREYcC/50ti9BV2GHwREREREYWBwDlfjL7CDYMvIiIiIqIwwIQb4c/w4Ovw4cO44YYbkJKSgpiYGPTt2xdff/21+rosy5g1axbatm2LmJgYjBgxAj/99JPuGCdOnMDEiRORmJiI5ORkTJ48GWVlZbp9vv/+e1xwwQWIjo5Gx44d8cQTT4Tk9yMiIiIiag6Bww4ZfYUbQ4OvkydP4rzzzkNUVBQ+/vhj7NmzB0899RRatWql7vPEE0/gmWeeweLFi7F161bExcUhOzsbVVVV6j4TJ07E7t27sW7dOqxevRqff/457rjjDvX10tJSjBw5EpmZmdixYweefPJJzJ49G0uWLAnp70tERERE1FgMtcKf1cgPf/zxx9GxY0csXbpU3dalSxf1sSzLePrpp/Hggw/iyiuvBAC89tprSE9Px6pVqzB+/Hj88MMP+OSTT7B9+3YMGTIEAPDss8/i8ssvx7/+9S+0a9cOr7/+OpxOJ1555RXYbDb07t0beXl5+Pe//60L0oiIiIiIzIoJN8KfocHX+++/j+zsbFxzzTXYtGkT2rdvj7vvvhu33347AGD//v3Iz8/HiBEj1PckJSVh6NChyM3Nxfjx45Gbm4vk5GQ18AKAESNGQBRFbN26FVdddRVyc3Nx4YUXwmazqftkZ2fj8ccfx8mTJ3U9bQDgcDjgcDjU56WlpQAASZIgSVKLfBdUO0mSIMsyv38DsQ6MxzowHuvAeKwD47EOjOPx6L9z3psaoynfuaHB16+//opFixZhxowZ+Nvf/obt27fjnnvugc1mw6RJk5Cfnw8ASE9P170vPT1dfS0/Px9paWm6161WK1q3bq3bR9ujpj1mfn5+QPA1b948zJkzJ6C8RUVFcDqdTfiNqbEkSUJJSQlkWYYoGj5VMSKxDozHOjAe68B4rAPjsQ6MU1Ll1j0vLilBYWGUQaWJXCUlJY1+r6HBlyRJGDJkCB599FEAwMCBA7Fr1y4sXrwYkyZNMqxcM2fOxIwZM9TnpaWl6NixI1JTU5GcnGxYuSKZJEkQBAGpqam80BuEdWA81oHxWAfGYx0Yj3VgHGu5vhMgISExoBOCWp52NF1DGRp8tW3bFr169dJt69mzJ95++20AQEZGBgCgoKAAbdu2VfcpKCjAgAED1H0KCwt1x3C73Thx4oT6/oyMDBQUFOj2UZ4r+2jZ7XbY7faA7aIo8iJjIEEQWAcGYx0Yj3VgPNaB8VgHxmMdGEMQBP8NrAMDNOU7N7S2zjvvPOzbt0+37ccff0RmZiYAb/KNjIwMbNiwQX29tLQUW7duRVZWFgAgKysLxcXF2LFjh7rPp59+CkmSMHToUHWfzz//HC6XS91n3bp16N69e8CQQyIiIiIiM/JPsMFM8+HH0OBr+vTp2LJlCx599FH8/PPPWL58OZYsWYKcnBwA3uh+2rRpeOSRR/D+++9j586duOmmm9CuXTuMHTsWgLen7A9/+ANuv/12bNu2DV9++SWmTJmC8ePHo127dgCACRMmwGazYfLkydi9ezfefPNNLFiwQDe0kIiIiIjIzGS/aEtm8vmwY+iww7PPPhvvvvsuZs6ciblz56JLly54+umnMXHiRHWf++67D+Xl5bjjjjtQXFyM888/H5988gmio6PVfV5//XVMmTIFl156KURRxLhx4/DMM8+oryclJWHt2rXIycnB4MGD0aZNG8yaNYtp5omIiIgobPiHWkw1H34MDb4A4IorrsAVV1xR4+uCIGDu3LmYO3dujfu0bt0ay5cvr/Vz+vXrhy+++KLR5SQiIiIiMpL/Ol/+PWFkfpyhR0REREQUBjjnK/wx+CIiIiIiCgOBc74o3DD4IiIiIiIKA/49XRInfYUdBl9ERERERGHAP/hi6BV+GHwREREREYUB/4Qb/s/J/Bh8ERERERGFgcBshwYVhBqNwRcRERERURhgrBX+GHwREREREYUB/2yHHHYYfhh8ERERERGFAa7zFf4YfBERERERhYGAVPOMvsIOgy8iIiIiojAQkHDDoHJQ4zH4IiIiIiIKA4HZDhl+hRsGX0REREREYSBgkWXGXmGHwRcRERERURjgnK/wx+CLiIiIiCgMyOCcr3DH4IuIiIiIKAww1Xz4Y/BFRERERBQGmHAj/DH4IiIiIiIKA0y4Ef4YfBERERERhQH/ni4m3Ag/DL6IiIiIiMJAwJwvY4pBTcDgi4iIiIgoDAT2fBlUEGo0Bl9ERERERGEgINjisMOww+CLiIiIiCgMcJ2v8Mfgi4iIiIgoDPh3dHHYYfhh8EVEREREFAa4zlf4Y/BFRERERBQG2PMV/hh8ERERERGFgYCeL876CjsMvoiIiIiIwoB/zxdHHYYfBl9ERERERGEgINshg6+ww+CLiIiIiCgMSJLfc0ZfYYfBFxERERFRGAhYY9mQUlBTMPgiIiIiIgoDTDUf/hh8ERERERGFAf9gi7FX+GHwRUREREQUBpjtMPwx+KKw4JFknKpyG10MIiIiIsP4L6rMhBvhx9Dga/bs2RAEQfevR48e6utVVVXIyclBSkoK4uPjMW7cOBQUFOiOcfDgQYwePRqxsbFIS0vDvffeC7dbf5P+2WefYdCgQbDb7ejWrRuWLVsWil+PmtGEl7bissXf4cDxcqOLQkRERGSIwEWWKdwY3vPVu3dvHD16VP23efNm9bXp06fjgw8+wIoVK7Bp0yYcOXIEV199tfq6x+PB6NGj4XQ68dVXX+HVV1/FsmXLMGvWLHWf/fv3Y/To0bj44ouRl5eHadOm4bbbbsOaNWtC+ntS02w/cBIAsOrbIwaXhIiIiMgY/sEWe77Cj9XwAlityMjICNheUlKCl19+GcuXL8cll1wCAFi6dCl69uyJLVu2YNiwYVi7di327NmD9evXIz09HQMGDMDDDz+M+++/H7Nnz4bNZsPixYvRpUsXPPXUUwCAnj17YvPmzZg/fz6ys7ND+rtS0/ESQ0RERJEqILshb4zCjuHB108//YR27dohOjoaWVlZmDdvHjp16oQdO3bA5XJhxIgR6r49evRAp06dkJubi2HDhiE3Nxd9+/ZFenq6uk92djbuuusu7N69GwMHDkRubq7uGMo+06ZNq7FMDocDDodDfV5aWgoAkCQJkv/qdhRSrAPjSJIEWZb5/RuIdWA81oHxWAfGYx0Yx+P3nXt4X2SIpnznhgZfQ4cOxbJly9C9e3ccPXoUc+bMwQUXXIBdu3YhPz8fNpsNycnJuvekp6cjPz8fAJCfn68LvJTXlddq26e0tBSVlZWIiYkJKNe8efMwZ86cgO1FRUVwOp2N/n2p6U6VlaOwsNDoYkQkSZJQUlICWZYhioaPWI5IrAPjsQ6MxzowHuvAOCUlpbrnlZVVvC8yQElJSaPfa2jwNWrUKPVxv379MHToUGRmZuKtt94KGhSFysyZMzFjxgz1eWlpKTp27IjU1NSAYJBCS0msQqEnSRIEQUBqair/2BqEdWA81oHxWAfGYx0YJ/53fSeAPTqa90UGsNlsjX6v4cMOtZKTk3HWWWfh559/xmWXXQan04ni4mJdwFNQUKDOEcvIyMC2bdt0x1CyIWr38c+QWFBQgMTExBoDPLvdDrvdHrBdFEVeZIwmCKwDAwnV3z/rwDisA+OxDozHOjAe68Aogu6ZDLAODNCU79xUtVVWVoZffvkFbdu2xeDBgxEVFYUNGzaor+/btw8HDx5EVlYWACArKws7d+7UdbeuW7cOiYmJ6NWrl7qP9hjKPsoxKLwwqw8RERFFKt4GhT9Dg6+//vWv2LRpEw4cOICvvvoKV111FSwWC66//nokJSVh8uTJmDFjBjZu3IgdO3bglltuQVZWFoYNGwYAGDlyJHr16oUbb7wR3333HdasWYMHH3wQOTk5as/VnXfeiV9//RX33Xcf9u7di+effx5vvfUWpk+fbuSvTo3Fiw4RERFFKP9GaDZKhx9Dhx3+/vvvuP7663H8+HGkpqbi/PPPx5YtW5CamgoAmD9/PkRRxLhx4+BwOJCdnY3nn39efb/FYsHq1atx1113ISsrC3FxcZg0aRLmzp2r7tOlSxd8+OGHmD59OhYsWIAOHTrgpZdeYpr5MMVLDBEREUUq//sgxl7hx9Dg64033qj19ejoaCxcuBALFy6scZ/MzEx89NFHtR5n+PDh+PbbbxtVRjIXtvAQERFRpGLPV/gz1ZwvorpIvMYQERFRhApYY5n3RWGHwReFlYCV3YmIiIgihP99EG+Lwg+DLwovvMgQERFRhPIfASTzxijsMPiisMJhh0RERBSp/Hu+eF8Ufhh8kelpLzRs4SEiIqJI5R9sMeFG+GHwRaanvdDwGkNERESRyj/Y4n1R+GHwRabnkbQ9X0REREQEsOcrHDH4ItPTXlh4kSEiIqJIxXW+wh+DLzI9Xc8XrzFEREQUobjOV/hj8EWm59Em3OBVhoiIiCKU0h4tCPrnFD4YfJHpSZJ22KGBBSEiIiIykDLM0Cp6oy82SocfBl9kerpsh0y5QURERBHOUh18cc5X+GHwRabHOV9EREREvtFAFkEJvowsDTUGgy8yPW2rjssjGVgSIiIiIuMowZaFww7DFoMvMj1tz5eHTTxEREQUoZTpF1aRPV/hisEXmZ424HLzKkNEREQRSrkNEjnnK2wx+CLT015Y2PNFREREEav6nsjCnq+wxeCLTE8bcLk8vMoQERFRZFJ7vpSFvtjzFXYYfJHpaVt1PBITbhAREVFk8l/niz1f4YfBF5kehx0SERERQV3tlOt8hS8GX2R6HHZIRERE5Au2OOcrfDH4ItNjqnkiIiIi3xQvrvMVvhh8kelpu9SZap6IiIgilRww54v3ReGGwReZnr7niwk3iIiIKDIFrvNlYGGoURoVfE2aNAmff/55c5eFKCjthcXNOV9EREQUodRhhwJ7vsJVo4KvkpISjBgxAmeeeSYeffRRHD58uLnLRaTisEMiIiKiwIQbjL3CT6OCr1WrVuHw4cO466678Oabb6Jz584YNWoUVq5cCZfL1dxlpAinHXbIawwRERFFKjkg+OKdUbhp9Jyv1NRUzJgxA9999x22bt2Kbt264cYbb0S7du0wffp0/PTTT81ZTopgkib4Yvc6ERERRSrlLoiLLIevJifcOHr0KNatW4d169bBYrHg8ssvx86dO9GrVy/Mnz+/OcpIEc6jCbjYwkNERESnu237T+D+ld+juMKp2640QovMdhi2rI15k8vlwvvvv4+lS5di7dq16NevH6ZNm4YJEyYgMTERAPDuu+/i1ltvxfTp05u1wBR59NkODSwIERERUQhc+0Ku+vjxP/VTHyu3RFbO+QpbjQq+2rZtC0mScP3112Pbtm0YMGBAwD4XX3wxkpOTm1g8In2rDlt4iIiIKFL8eqxM99x/kWXeF4WfRgVf8+fPxzXXXIPo6Oga90lOTsb+/fsbXTAihXZpLw47JCIiokjhP6dLTbghcM5XuGrUnK+NGzcGzWpYXl6OW2+9tcmFItLy6Hq+DCwIERERUQj5NzorTznnK3w1Kvh69dVXUVlZGbC9srISr732WpMLRaTFbIdEREQUifzvepT7ICtTzYetBg07LC0thSzLkGUZp06d0g079Hg8+Oijj5CWltbshaTIps92aGBBiIiIiELIf8SP8lzksMOw1aDgKzk5GYIgQBAEnHXWWQGvC4KAOXPmNFvhiAB9tkP2fBEREVHE8B92WN0XZrVU93yFvEDUVA0adrhx40Zs2LABsixj5cqV+PTTT9V/mzdvxsGDB/H3v/+9UQV57LHHIAgCpk2bpm6rqqpCTk4OUlJSEB8fj3HjxqGgoED3voMHD2L06NGIjY1FWloa7r33Xrjdbt0+n332GQYNGgS73Y5u3bph2bJljSojGUPinC8iIiKKQIEJN7w/1Z4v3hiFnQb1fF100UUAgP3796NTp04Qqiu+qbZv344XXngB/fr1022fPn06PvzwQ6xYsQJJSUmYMmUKrr76anz55ZcAvEMdR48ejYyMDHz11Vc4evQobrrpJkRFReHRRx9Vyzp69GjceeedeP3117FhwwbcdtttaNu2LbKzs5ul/NSytNkO2fNFREREkcL/vodzvsJfvYOv77//Hn369IEoiigpKcHOnTtr3Nc/iKpNWVkZJk6ciBdffBGPPPKIur2kpAQvv/wyli9fjksuuQQAsHTpUvTs2RNbtmzBsGHDsHbtWuzZswfr169Heno6BgwYgIcffhj3338/Zs+eDZvNhsWLF6NLly546qmnAAA9e/bE5s2bMX/+/BqDL4fDAYfDoT4vLS0FAEiSBEniKr+h5tZ855Issw4MIkkSZH7/hmIdGI91YDzWgfFYB6Hj/z0rPV2+db7AejBAU77zegdfAwYMQH5+PtLS0jBgwAAIghA02hYEAR6Pp94FyMnJwejRozFixAhd8LVjxw64XC6MGDFC3dajRw906tQJubm5GDZsGHJzc9G3b1+kp6er+2RnZ+Ouu+7C7t27MXDgQOTm5uqOoeyjHd7ob968eUHnrhUVFcHpdNb7d6PmUVxSqj72eGQUFhYaWJrIJUkSSkpKIMsyRLFRiVKpiVgHxmMdGI91YDzWQei4XG7dfU9lVRUAwFHlzTrukSTeFxmgpKSk0e+td/C1f/9+pKamqo+bwxtvvIFvvvkG27dvD3gtPz8fNpsNycnJuu3p6enIz89X99EGXsrrymu17VNaWorKykrExMQEfPbMmTMxY8YM9XlpaSk6duyI1NTUgPJQy4uLq1IfywAzahpEkiQIgoDU1FT+sTUI68B4rAPjsQ6MxzoIHdFq1d332O2HAQDxcbEAABkC74sMYLPZGv3eegdfmZmZQR831qFDh/CXv/wF69at06WsNwO73Q673R6wXRRFXmQMoO1fZSubsQRB4HlgMNaB8VgHxmMdGI91ECIydN+xck9ktXi38b7IGE35zhu9yPKHH36oPr/vvvuQnJyMc889F7/99lu9jrFjxw4UFhZi0KBBsFqtsFqt2LRpE5555hlYrVakp6fD6XSiuLhY976CggJkZGQAADIyMgKyHyrP69onMTExaK8XmY8+1byBBSEiIiIKIdkvmbwy1cjCdb7CVqOCr0cffVQNXHJzc/Hcc8/hiSeeQJs2bTB9+vR6HePSSy/Fzp07kZeXp/4bMmQIJk6cqD6OiorChg0b1Pfs27cPBw8eRFZWFgAgKysLO3fu1I11XbduHRITE9GrVy91H+0xlH2UY5D5aS8szHZIREREkSIg1Tz8E27wvijcNCjVvOLQoUPo1q0bAGDVqlX405/+hDvuuAPnnXcehg8fXq9jJCQkoE+fPrptcXFxSElJUbdPnjwZM2bMQOvWrZGYmIipU6ciKysLw4YNAwCMHDkSvXr1wo033ognnngC+fn5ePDBB5GTk6MOG7zzzjvx3HPP4b777sOtt96KTz/9FG+99Zau547Mjet8ERERUSTyT26n3AcpwRdvi8JPo3q+4uPjcfz4cQDA2rVrcdlllwEAoqOjUVlZ2WyFmz9/Pq644gqMGzcOF154ITIyMvDOO++or1ssFqxevRoWiwVZWVm44YYbcNNNN2Hu3LnqPl26dMGHH36IdevWoX///njqqafw0ksvcY2vMOLfqMM1LYiImu5EuRNPr/8Rv5+sMLooRFSDmu6BLFznK2w1qufrsssuw2233YaBAwfixx9/xOWXXw4A2L17Nzp37tzownz22We659HR0Vi4cCEWLlxY43syMzPx0Ucf1Xrc4cOH49tvv210uchYgQsMApbmWd+biChizXpvF1Z/fxSvbz2I7X8fUfcbiCjk/EMr5ZbIKnLOV7hqVM/XwoULkZWVhaKiIrz99ttISUkB4E2icf311zdrAYk8NazuTkREjffNbycBAEWnHAaXhIhqEtgA7X0ucs5X2GpUz1dycjKee+65gO3BFiYmair/6wovNERETZeaYMeRkqq6dySikJJ1c9319zzKMyXboSx79xcEDgkKF40KvgCguLgY27ZtQ2FhISQl7yW86z7ceOONzVI4IgCQ/PrUNf/diIioFifLnVi3pwCX92uLeLv+T35qQjSAEmMKRkQ10i6xE9gA7f2pzPlS9mHsFT4aFXx98MEHmDhxIsrKypCYmKiLthl8UXPzH8/Mni8iovr58392YNuBE/j8pyI8N2GQ7rXUBLv6uNLpQYzNEuriEVEQ7lqCL/+EG4D3vkgEo69w0ag5X//3f/+HW2+9FWVlZSguLsbJkyfVfydOnGjuMlKE45wvIqLG2XbA+zd59fdHA16L1QRbR0uaL1MxETWNvufLb9hhkJ4vJt0IL40Kvg4fPox77rkHsbGxzV0eogA1rXFBRESNp73BK3d4DCwJEWnper78XlMaoK1+PV8UPhoVfGVnZ+Prr79u7rIQBRUw2ZQXGSKiJpNqmdRPRMapfc6XPtshhZ9GzfkaPXo07r33XuzZswd9+/ZFVFSU7vU//vGPzVI4IiDYnC9jykFEdDrR3uD5D+8mIuO4NZnF3FLwYYe19Xz9WHAKBaVVuODM1JYrJDVao4Kv22+/HQAwd+7cgNcEQYDHw+EL1HxqWuOCiIgaT9fzxVYtItPQNoy4/VI8q3O+hJrnfI2c/zkA4LO/DkfnNnEtU0hqtEYNO5QkqcZ/DLyouQWkmmfwRUTUZG6PpueLwReRaeiCL49fzxcChx1q74tcHl+wdpTr+JlSo4IvraoqViy1LP97AsZeRERNpx1qyGGHROahDb6cHn3PlxRk2KGs2eV4mVN9nBDd6OV8qQU1KvjyeDx4+OGH0b59e8THx+PXX38FAPzjH//Ayy+/3KwFJOKwQyKi5qcdVcDF64nMwy3VPCRYTbghBO/5KjrlUB/zdsmcGhV8/fOf/8SyZcvwxBNPwGazqdv79OmDl156qdkKRwQEXjw4PIaIqOm0o5nY80VkHrUlw1ETbliCB1/HynzBF89rc2pU8PXaa69hyZIlmDhxIiwW3yKN/fv3x969e5utcERAsFTzBhWEiOg04tF0dzHhBpF5aOd5ybJ+iR3lsVBDwg1tzxcbq82p0Yssd+vWLWC7JElwuVxNLhSRlv/Fg8MOiYiaTte6zps0ItMIvO8JfGwRBCjTvrTBWVEZgy+za1Tw1atXL3zxxRcB21euXImBAwc2uVBEWlzni4io+Wnn8bNRi8g8/NPLB2soEQVA6fzS3heVO9xB30fm0ag0KLNmzcKkSZNw+PBhSJKEd955B/v27cNrr72G1atXN3cZKcLJTLhBRNTsdOt88bpKZBq1jfhRE26IAgQI8CafDz5HjMGXOTWq5+vKK6/EBx98gPXr1yMuLg6zZs3CDz/8gA8++ACXXXZZc5eRIlzgnC9eTIiImsqta003sCBEpOP2C5qC9Xxphx3qhiXWkqyDzKHRCwBccMEFWLduXXOWhSgo/5sCNuQQEdWPKNR8zeRNGpE5+fdYeYL0fFlEwTfsULsocy1p6skcGtXz1bVrVxw/fjxge3FxMbp27drkQhFpcdghEVHjWDQLsfrz8CaNyJT8e750a/JVPxQE31pfcg09X/7HIXNoVPB14MABeDyegO0OhwOHDx9ucqGItAIWWebwGCKietEuxOqPc0OIzMlTj4Qbup4vOXgvNs9rc2rQsMP3339ffbxmzRokJSWpzz0eDzZs2IDOnTs3W+GIgGDZDnkxISKqD23PlyzLurWBalvIlYiM4z/dIlhAZREEiPCez1INARfvl8ypQcHX2LFjAXgXdps0aZLutaioKHTu3BlPPfVUsxWOCAjS88WLCRFRvVg0wZbLI8NmDR58cdghkXn491hpb3u0iywHS7jh4bBD02tQ8CVVd4N26dIF27dvR5s2bVqkUERagcGXQQUhIgozoqbny+mRYLP6ZhvUNFSJiIzlf98TrJfaIvrW+ZJ1PV+a4/CGyZQale1w//79zV0Oohr5z/FizxcRUf1ohx063RJg973mCTKJn4iMF5DtMMiyEKIgqMOIdanmZfZ8mV2jU81v2LABGzZsQGFhodojpnjllVeaXDAiBdf5IiJqHN2NmKfmSfxsIScyj9qmW8hBUs1rF1lmqnnza1TwNWfOHMydOxdDhgxB27ZtdRN4iZpbYMINY8pBRBRuPJ6ahxYGy6BGRMarz7BDURDUlOVSDUMNOZzYnBoVfC1evBjLli3DjTfe2NzlIQoQsM4XbxKIiOrFXUuAFWzhViIynn+2w2DZDEVRUJeSqCnbIYcdmlOj1vlyOp0499xzm7ssREH5t9zwWkJEVD/6oYX61yT2fBGZkn8jc7AkGhZBm3DD9zqHHZpfo4Kv2267DcuXL2/ushAF5X/t4JwvIqL6cWsiLrf/wq3MdkhkSrUNO1QeWmro+aqpF4zMo1HDDquqqrBkyRKsX78e/fr1Q1RUlO71f//7381SOCIgyLBDXkuIiOokSXKNWdAA/XwwtpATmUfgiJ/AhhJB8CXcqCngYvBlTo0Kvr7//nsMGDAAALBr167mLA9RAC6yTETUcIEJNmp+3f81IjKOf2OIrmdLHXZY9yLL7NE2p0YFXxs3bmzuchDVqLZJ4kREFJzbU/PQJe9zzWNeV4lMw7/DKvgiy751vmT2fIWVBgVfV199dZ37CIKAt99+u9EFIvLHOV9ERA3nP8erPmsHEZHx/IMm5VyVZVlNriEKgKC+rnkv53yZXoOCr6SkpJYqB1GNAlPNG1QQIqIwEtjTpX+uXXSZN2lE5hGYcEPZ7tvmTTXvfSwHGZbofR/PazNqUPC1dOnSZv3wRYsWYdGiRThw4AAAoHfv3pg1axZGjRoFwJvY4//+7//wxhtvwOFwIDs7G88//zzS09PVYxw8eBB33XUXNm7ciPj4eEyaNAnz5s2D1er71T777DPMmDEDu3fvRseOHfHggw/i5ptvbtbfhVpO4CLLvJgQEdXFf42f2pbt4LBDIvOoqeFEu90i+IYdas/f2tb2I3NoVKr55tKhQwc89thj2LFjB77++mtccskluPLKK7F7924AwPTp0/HBBx9gxYoV2LRpE44cOaIb+ujxeDB69Gg4nU589dVXePXVV7Fs2TLMmjVL3Wf//v0YPXo0Lr74YuTl5WHatGm47bbbsGbNmpD/vtQ4gUNlDCoIEVEYCRi6VEtPGLMdEplHTY3O2vshURRgqe760o4ICpYZkcylUQk3msuYMWN0z//5z39i0aJF2LJlCzp06ICXX34Zy5cvxyWXXALA2/PWs2dPbNmyBcOGDcPatWuxZ88erF+/Hunp6RgwYAAefvhh3H///Zg9ezZsNhsWL16MLl264KmnngIA9OzZE5s3b8b8+fORnZ0d8t+ZGs7/poBzE4iI6hbQ81VLTxizHRKZR03zM7XbLYIAS/WwQ+38TjaqmJ+hwZeWx+PBihUrUF5ejqysLOzYsQMulwsjRoxQ9+nRowc6deqE3NxcDBs2DLm5uejbt69uGGJ2djbuuusu7N69GwMHDkRubq7uGMo+06ZNq7EsDocDDodDfV5aWgoAkCQJEicchVxgumTWgxEkSYIsy/zuDcQ6MF441YHL7dE9d3v01059VrTwua6GUx2crlgHLcvt1xqinLu6c1qW1EWWtee2ttHF5Qmf8zrcNOV7NTz42rlzJ7KyslBVVYX4+Hi8++676NWrF/Ly8mCz2ZCcnKzbPz09Hfn5+QCA/Px8XeClvK68Vts+paWlqKysRExMTECZ5s2bhzlz5gRsLyoqgtPpbPTvSo3jdLp0z08Wl6Cw0GJQaSKXJEkoKSmBLMsQRUNHLEcs1oHxwqkOCk9W6Z4fP3kShYW+mzdt8FVWXoHCwsKQla0pwqkOTlesg5ZVeqpM9/zEyWIUFsoorXKr244fOwZZ8mhe927X3jOF03kdbkpKShr9XsODr+7duyMvLw8lJSVYuXIlJk2ahE2bNhlappkzZ2LGjBnq89LSUnTs2BGpqakBwSC1PIv1R93zhMREpKWlGVSayCVJEgRBQGpqKv/YGoR1YLxwqoMS+ZTueWJiEtLSUgEEDkeyRUeHzXU1nOrgdMU6aFmxscW658p9j7Xc1wGQkZ4GW9RPABy6+yJB3KvuYw+j8zrc2Gy2Rr/X8ODLZrOhW7duAIDBgwdj+/btWLBgAa677jo4nU4UFxfrAp6CggJkZGQAADIyMrBt2zbd8QoKCtTXlJ/KNu0+iYmJQXu9AMBut8NutwdsF0WRFxkDaNe08N4vCKwHgwiCwPPAYKwD44VLHUjqKkBesuba6ZH1Q2ZkGab/fbTCpQ5OZ6yDluM/oE2Sq89dwXdOWyyiL+GG7Du39Qk3wuu8DidN+V5NVyOSJMHhcGDw4MGIiorChg0b1Nf27duHgwcPIisrCwCQlZWFnTt36rpU161bh8TERPTq1UvdR3sMZR/lGGR+ytAY5SLD1KlERHWrbZ2vmhZxJSLj+SfAURNuVJ+3olAd/FbHYjWlmmfCDXMytOdr5syZGDVqFDp16oRTp05h+fLl+Oyzz7BmzRokJSVh8uTJmDFjBlq3bo3ExERMnToVWVlZGDZsGABg5MiR6NWrF2688UY88cQTyM/Px4MPPoicnBy15+rOO+/Ec889h/vuuw+33norPv30U7z11lv48MMPjfzVqQGUi45VFODyyLxJICKqh4CFWuWagy9mOyQyj8BFlqvX+ZL1jdFKwg2phoDLP+MpmYOhwVdhYSFuuukmHD16FElJSejXrx/WrFmDyy67DAAwf/58iKKIcePG6RZZVlgsFqxevRp33XUXsrKyEBcXh0mTJmHu3LnqPl26dMGHH36I6dOnY8GCBejQoQNeeuklppkPI8o1yFp9sWHsRURUt9rW+QpccJkXViKz8O+x8qWa9z5Xgi5rkBFB2nObPV/mZGjw9fLLL9f6enR0NBYuXIiFCxfWuE9mZiY++uijWo8zfPhwfPvtt40qIxlP8mvp4U0CEVHd/IOv2oYjcTg3kXnU1DjiG3ao9HwF7l9TIEbmYbo5X0T+1G726osM7xGIiOpW27yugAWYeZNGZBqBjSPKT79hh8F6vjjs0PQYfJHpKevYseeLiKj+Aheor7nni8OTiMwjoOfLb86X0uNlEWoPvnhemxODLzI9WZNwQ/uciIhqJvkl0ahtOBKHHRKZh//pqJyvst80DIuo7F/DsEOe16bE4ItMT7l2+Hq+DCwMEVGYqC2pBlPNE5lXTXMyleGHvjlftSfcYPBlTgy+yPT8E27wYkJEVLea5o14H7Pni8isamocUbaLYs3Bl7bHm3M5zYnBF5mectGJ4pwvIqJ6Cwiwau35CkmRiKgeahoWrDZGC/phh+z5Ci8Mvsj0lGuH1cKeLyKi+qpp0j4Q2IjFRi0i8/A/HQOCL2XOl9LzpZkTxjlf5sfgi0xP8ku4wdSpRER1q21ooaeWZBxEZCz/81EJxpTt1TGXOvxQUoOz2o9D5sDgi0xPuahY/S4yRERUs9rX+ZJq3ZeIjBMw7FCuqefL+7rSKM25nOGBwReZnnINUocdcngMEVGd/IcS1jQpP9i+RGScurIdWvyyHUo1BV88r02JwReZnsc/4QZbcoiI6lRrwg2u80VkWgFzMv3mfCnDDtUs0Eo2xFrmeZJ5MPgi0/Of88WWHCKiugUMO6xlIr6Hl1Ui01B6uPzve5Rz2KKmmtfv739ec468OTH4ItMLzHZoYGGIiMJE4LBD7WO2kBOZldrobPEbVli9XVRTzSv3RVL1T/ZohwMGX2R6sl/PF+cmEBHVLSCjYS3r/7CFnMg81PVNqxfy8iXc8L5e354vBl/mxOCLTE+5eKjd77yYEBHVyeOXVaPWdb54XSUyDeU+x6YEX9WnsnKe+vd8SX7ZENXjsLHalBh8ken5hh0qFyFeTIiI6lJrwo2Ani+O5yYyC/9hh8oIIOW8Ff0XWa7e7t+DzUYVc2LwRaYma24WotjzRURUb/5JNDy1JNzgZZXIPHwjfvSNzkoDirK+lzrsUAnOPP6NKjyxzYjBF5ma9rrBbIdERPVX01pB/o8B9nwRmYlyetqs3tt0JYhSGqTVOV/KfZFH6fmqeagxmQeDLzI17Q2Cf9YfIiKqWW1reanrJ6rX1dCVi4hqJ/nN+ZLUYYfe1wXBb9ih37BEBRurzYnBF5ma9kISZeGwQyKi+gocWqhJuCHps6mx54vIPJSgyR7lPT9dHv9hh0rCDe/+Ug1zvni/ZE4MvsjUtK02Nr+Uq0REVLPahh0qN2nKsCaun0hkHv49X0rm0sBFluvo+WLwZUoMvsjUtJNHozjskIio3gIyn2l7vuTgN3dEZDzl1PX1TOtTyYt+wZe7hp4vJtwwJwZfZGqeINkOeTEhIqpbwJo/QRJu+Hq+eF0lMgvlfFSGHbo9+p4tJcuh/7BDpRGlOiZjY7VJMfgiU3NrLiT+iwkSEVHNAocgBb7mm9AfsmIRUR0Ce6b1PV8W/4Qb1a8rc8PsVk7TMDMGX2RqykgYqyj4xjbzLoGIqE7+N15SkEWWfamsOeyQyCxqOj+V4ErJ/iz6NUr7N6rwfsmcGHyRqSkXHFEQ1O51TgwnIqqbL6NhYMOVEpgpN3eMvYjMw7/nSxl26K6+AbJWb1cWW/af82WzWgAw+DIrBl9katqeLw47JCKqP6WhKipIplj/bGrs+SIyDyVmUud8+QVXyhx45b7I4zfnSxl2KMm+hZnJPBh8kampPV8cdkhE1CCSupCy0rsVOOwwysKbNCKzqWn4oG/YoXe7cl+knOtuvzlf2veSeTD4IlNTLhreOV/ebez5IiKqW+C8kZrX+dLuT0TG8j93XdXd2MqwQ2UosXJf5Ov5CnJe857JdBh8kampq7mLgprVx+3hhYSIqC5uv9Zzbc+XJPMmjcisZL/zU+35Uhukq+d8KdMxqkcNK+e8PcqiHouNKubD4ItMTQm0LKIAUUm4wRsEIqI6KcGWPUjPlzIfjD1fROajJsSxeIModc6XmnBDn2pemaKh/LRbeF6bGYMvMjVJ0/Oljm3mhYSIqE7+GQ21STX8s6kBvEkjMgul4Tk6Sn/uuv3mavoapfXvUxJ1AMxkakYMvsjUlAuNRfANO2TPFxFR3QJ6vjRDtpXHDL6IzEe594muHj6onK/K3C+rqO/5kvznfGnOa2YyNR8GX2RqygXFIvrW+WLPFxFR3fx7vmpb58v/dSIyjkfS93x51GGH/tkO9fsrQZvVIkBQXmODtekw+CJTc0uBww55ISEiqptH7fnytp67tAk3dNdW/f5EZCx17pbVb85X9faa1/nyJeSw+iXjIPNg8EWmpu/5Ui4yRpaIiCg8+Gc09GjuwpRGLFHQXFvZsEVkCp6AZDnec7emdb6Uc1fb8yX6JeMg8zA0+Jo3bx7OPvtsJCQkIC0tDWPHjsW+fft0+1RVVSEnJwcpKSmIj4/HuHHjUFBQoNvn4MGDGD16NGJjY5GWloZ7770Xbrdbt89nn32GQYMGwW63o1u3bli2bFlL/3rUDNxBWmc57JCIqG7+C65q53x5NDdpSvDFZTyIzMF/zpfHo892qKzzpWQ9VLYrDSzaBmvGXuZjaPC1adMm5OTkYMuWLVi3bh1cLhdGjhyJ8vJydZ/p06fjgw8+wIoVK7Bp0yYcOXIEV199tfq6x+PB6NGj4XQ68dVXX+HVV1/FsmXLMGvWLHWf/fv3Y/To0bj44ouRl5eHadOm4bbbbsOaNWtC+vtSw3mCZDtkKw4RUd2Unq/gqeY1PV/KpH32fBEZTpJkKKeicu4qQ4Z963x5z1ll+KFLTcjhe11tVOE9k+lYjfzwTz75RPd82bJlSEtLw44dO3DhhReipKQEL7/8MpYvX45LLrkEALB06VL07NkTW7ZswbBhw7B27Vrs2bMH69evR3p6OgYMGICHH34Y999/P2bPng2bzYbFixejS5cueOqppwAAPXv2xObNmzF//nxkZ2cHlMvhcMDhcKjPS0tLAQCSJEHif+KQcrs9ALwZfbTzElgPoSdJEmSZ372RWAfGC6c68E9L7fb4/oZ5qlvKRcE3b8TlCY+/ceFUB6cr1kHLcVTf9wC+Hi5P9bnpcvt6tiRJgpJR3ln9utIDps0Q7Q6T8zrcNOU7NTT48ldSUgIAaN26NQBgx44dcLlcGDFihLpPjx490KlTJ+Tm5mLYsGHIzc1F3759kZ6eru6TnZ2Nu+66C7t378bAgQORm5urO4ayz7Rp04KWY968eZgzZ07A9qKiIjidzqb+mtQAx08WAwAkjxsV5WUAAJfbjcLCQgNLFZkkSUJJSQlkWYYocrqoEVgHxgunOqiq8jYiSi7vT4fLd+0sq6jw7lNZAQHeIK2o6BjipfIgRzKXcKqD0xXroOVUunzBV8Up732xyyOhsLAQ5ZVV3n3Ky1BYWIjKCu99kXJul57yPnc6qiAI1ef1seNIREUof4WIoMQsjWGa4EuSJEybNg3nnXce+vTpAwDIz8+HzWZDcnKybt/09HTk5+er+2gDL+V15bXa9iktLUVlZSViYmJ0r82cORMzZsxQn5eWlqJjx45ITU0NKAu1rPgC70Uo2m5DUmKCd6NgQVpamoGlikySJEEQBKSmpvKPrUFYB8YLpzqwRB0AACQlxAEoAgRRvXba7N4gLDE+DlFWCwAPklq1RlpagjGFbYBwqoPTFeug5ZRWudTH7dLaAAAkGUhLS4No/Q0A0Do5CWlpaWhd6gTwOzyS93V7TDEAICEuFlGWUgBuJCW3QlpaYoh/i9OfzWZr9HtNE3zl5ORg165d2Lx5s9FFgd1uh91uD9guiiIvMiEmoXpSqXbyKFvaDCMIAs8Dg7EOjBcudaCMilEXapV8105l+pfVImqurTD976QIlzo4nbEOWoYsC+rjaJv3Nt1Vfe4qSXGirN7vXVlM2eXxvq7Mk4+y+s5rGQLrqAU05Ts1RW1MmTIFq1evxsaNG9GhQwd1e0ZGBpxOJ4qLi3X7FxQUICMjQ93HP/uh8ryufRITEwN6vchcdKnmBf16FkREVDP/hZTdmnU61IQbogCrGpDx2kpkNGWupiD4Em54/Nf5qg66lGyHTo93Dp6SFdEiilxCwsQMDb5kWcaUKVPw7rvv4tNPP0WXLl10rw8ePBhRUVHYsGGDum3fvn04ePAgsrKyAABZWVnYuXOnbg7QunXrkJiYiF69eqn7aI+h7KMcg8xLl2peZEYuIqL68l9kWZftUMkkKwhQGnDdbNgiMpxHCsxY6JFkyLKsZjNUgi8l2yHgPX/dQd/LZBtmY+iww5ycHCxfvhzvvfceEhIS1DlaSUlJiImJQVJSEiZPnowZM2agdevWSExMxNSpU5GVlYVhw4YBAEaOHIlevXrhxhtvxBNPPIH8/Hw8+OCDyMnJUYcO3nnnnXjuuedw33334dZbb8Wnn36Kt956Cx9++KFhvzvVj77ny7uNNwhERHVTerqio/St54D+2qr2fPHaSmQ4pXdLe256t8vqa0qPlxKEAd6kHNr3+kYLhaTY1ACG9nwtWrQIJSUlGD58ONq2bav+e/PNN9V95s+fjyuuuALjxo3DhRdeiIyMDLzzzjvq6xaLBatXr4bFYkFWVhZuuOEG3HTTTZg7d666T5cuXfDhhx9i3bp16N+/P5566im89NJLQdPMk7moPV+Cb50vDjskIqqb0kquzvnSLKIcbAF7NmwRGc+trtUlqkEW4L33Ued8ifphhwDgcstBe824zpf5GNrzJddj+Fh0dDQWLlyIhQsX1rhPZmYmPvroo1qPM3z4cHz77bcNLiMZS7fIcnVTAVtniYjqptyIKT1f2pswSWbPF5EZaRtGLH7DCl0efc+XRfDODZNl77wvJTizWDRJyhh7mY4pEm4Q1URZCFTXhc45X0REdXJV33XFVPd8SbIvwHJpWtdFtYWc11YioymNJlEWAVZt8OWRNAune7cLgqAOPXR5pODzxXjPZDoMvsjU9ENj2IpDRFRfSiu4vTr4AnzXVGU+mPYGjzdpRMbTzdvyT6ihaTRR2JSMh25Jk3BDZMINE2PwRaamDI3xts56t/EGgYiobkqAFaMJvjx+PV9RFl/Pl8fDayuR0TyaAEoQNI0jQYYdAgje82XRzpMPWdGpnhh8kakprTiiCN06X/WZL0hEFMlc6pwvbc+X907M6fGtF6Tcx7Fhi8h42hE/2p8u3bBD3+278tjpl+1QG7SRuTD4IlOTgnShA965C0REVDP/VPPebcGGHQamoiciY2jnbWl/6nq+xGA9X9phib61UXlemw+DLzI1tedLADTXGl5MiIjqoNyI2Sz6tYIA/2GH3td4XSUynkuTaAwAoqy+YYVuT7CeL1/PmNKjbbda1ACNqebNh8EXmZq250uX9YcXEyKiWinZDqMsonqDplw7XZphh+z5IjIPj9+wQ3t18FXlkgIWWQZ8jSsutwSHy/u6zSrCWr3dzbmcpsPgi0xNO+dLG3y5eDEhIqqVOgRJs+aPss2lGXbIVPNE5uE/r8tu9c7ZrHB6fAunW33zOG1W35wvh9tT/R5RzYLIxmrzYfBFpubRZDvUtvS4mb6HiKhGsizr0k77926p63xZfDdpTElNZDwl66jSYKLM2SypdKn7xNh8wZd2zpfDrR12qARlbFQxGwZfZGrKRUgUAVEQNFl/eDEhIqqJdghhlEVQG6/8hx3aLKImWxqvq0RGc/sl3FB6voornOo+ylBEwG/OlxJ8RYnqXDE2VpsPgy8yNW3Lrfen7yJDRETBaYcQWi2iZvK9X8INq6DODXG5eV0lMpr/nC//ni+71bv+l0KbkMPX8yUiivdLpsXgi0xNWWRZGXGotNBybgIRUc20N1xW0ZdO3n/Ol1UUdS3nRGQs/6Qavp4vb/ClHXIIaNb5cvvmfHkTbnCkkFkx+CJT819skDcJRER102Y4s4qahBuSPviyWURftjReV4kM51bnfHnPS6Xnq7jSO+xQm2wD0GQ79MhqtkO71aKZC8bz2mwYfJGpSQHBFy8mRER1cWmSZ1hE35wvJamGWzPskHO+iMzDf5Fle1RdPV/e/Zxuj37YIVPNmxaDLzI1l9+CguxGJyKqm28xVgGCIPjmfHlkyLKsLsbqHXbIRi0iswhMuBE450srujo4q3B5NIssczixmTH4IlPTLgQKAFEis/cQEdVFXeNLTVbkmy+rzYRos4iIsiqBmf66WuF048Cx8lAUl4iqefzmfEX79XwpzxWx1T1hJRW+VPT2KIsvkQ4bq02HwReZmnYhUO1PXkyIiGrm8ruBs2pawbXXT6tF0M0Z0br6+a8w/F+fYdfhklAUmYigneuuLLKsn/MV4xd8KcMQT2pS0WuXkGDPl/kw+CJTU9asUFKpWnkxISKqk9tvyLZyA+d0S+rQJOV135wv/XV1b/4pAMC6PQUtXl4i8vKf86X0dJWoPV/6W/fY6tdPlHtfFwRvQ3WUqF/bj8yDwReZmlOTkQvQpprnxYSIqCZqumq/hVodbkk3vFC7ALN2nS9lfgkAtE2KbvHyEpGXy6NPNKY0nJRWuQEEJtyItVkB+BZhVtYB863/xZFCZsPgi0zNFRB8cdghEVFdfHO+lIxp3muow+0bdmgVvck4gqWa/+24b66XKPoWdCWiluXxazjxn+Pln2peCcaK1YQcFt37OVLIfBh8kamp2Q6VYYe8mBAR1cm3UKt+2KHD7QlMZBRkzteB4xXqY4eb11uiUFGmW9iqz9lov+yG9hoSbig9X8r7lJ9MNW8+DL7I1AISbvBiQkRUJ7V3q/raaVOGHbqkIImMAud8lWgm7ztcnpYvMBEBABx+I378gy3/hBuxasINfSp6JcOp/1xOMh6DLzI1NeGGRX8xYc8XEVHN1IQbon/PlxSwfmKw9YCqXNrHDL6IQsVRfe4pQ4X9E2wEJNyoDr6URB1q8GUJvoQEGY/BF5laYMINzvkiIqqLf6r52oYd2qyBjVoOty/g0gZiRNSyfPc93qAqrjqhhqJVrE33PMbvdaWXu6YlJMh4DL7I1GoaHsNsh0RENVMTbqhzvnzZDtXrqlV/XXW5fTdp2oBLG4gRUcvyn/OVEq8Ptvyfx/oNQ0ywe4Mxa5AebTIHBl9kasrNgC0g4QZbcoiIAOCD747g8gVfYP8xX4ZCZahRlH+2Q5dm2KGov6462fNFZLiA4CvOrnu9dZx/z5c++EqOjQIALrJsYgy+yNTqMzyGiCiSTf3ft9hztBT/WLVL3eaSgq8VFDTboTVwRAHnfBEZwz/4au3X09UmXh+MxdYYfCmLLLOx2mwYfJGpBSbc4ARSIqJgSqt8CyO7/QIs7bDDCqc3mIq2+c0N0Q079AVcTDVPFDpKr7O9+rxMsFvVQAoI7PlKiNbP+UqunhOmZjHl+Ws6DL7I1PwTbljVlMhsySEi0rJoFkNWeq6UzGjabIcVTjcA31yRYMOTtAEXe76IQke571GGCguCoJ6jQGDwFWuz6gIwpedLyQ7Nni/zYfBFphaYcIM9X0REwShzuABN63l1gOWb8+VBZXXPlzJcSbmuOj3BA64qtpwThYw67NAS/BY92i/BBgBkJEarj5NjvMGZzcqEG2bF4ItMyyPJUBpslLHPvmyHbMkhIvJoroVBe76qhxsGG3YYY6tfzxcXWSYKHf85XwBwRb+2AID7/tA96HsyknzBVyv/ni+OFDIda927EBlDeyMQZRHhBMcwExFplVT65nlZLdrgq3peV8CwQw8qXfqeL18io+BzvtjzRRQ6jiDB16NX9cW0EWehXXJM0PekJviScCQx26HpseeLTMvpF3wBmoQbXOeLiAgnK5zq42BJMuxqz1eQOV/Vi7OqS3i42fNFZLRgww6tFrHGwAsAOmheOzMtAYBvODGDL/NhzxeZlrZ3y3/OlzYrFxFRpCrWBF+nqtzq44Cer+p5Ig5X4LBDpYXdUcOcL2Y7JAodteEkyNyumvxpcEfsKziFCUMz1V4wm6bBhcyFwReZljbZhiAoa9Uo8xbYEktEVKoJuLTBl3KNVCbnKz1fTo/kS7hR/VpM9U+nW4JHkmERBV3jF7MdEoWOf5bn+uiUEosXbhyi26ac11UuD2RZVu+jyHiGDjv8/PPPMWbMGLRr1w6CIGDVqlW612VZxqxZs9C2bVvExMRgxIgR+Omnn3T7nDhxAhMnTkRiYiKSk5MxefJklJWV6fb5/vvvccEFFyA6OhodO3bEE0880dK/GjUDpXdLm2JVacXVLgBKRBSptEMCyxya4MulDDv0XjOVIKzS6Qno+YrRLNKqzAfTzfli8EUUMsESbjSGso6fJOuncZDxDA2+ysvL0b9/fyxcuDDo60888QSeeeYZLF68GFu3bkVcXByys7NRVVWl7jNx4kTs3r0b69atw+rVq/H555/jjjvuUF8vLS3FyJEjkZmZiR07duDJJ5/E7NmzsWTJkhb//ahp1NYfqzb4qr6B4M0AEZGuIepUlQuy7G20qvLr+VLWASqtcqnBlzLnS8mICECdD+aoYf4XEbUsdZmIJgZfMZphi2ywNhdDhx2OGjUKo0aNCvqaLMt4+umn8eCDD+LKK68EALz22mtIT0/HqlWrMH78ePzwww/45JNPsH37dgwZ4u1uffbZZ3H55ZfjX//6F9q1a4fXX38dTqcTr7zyCmw2G3r37o28vDz8+9//1gVpZD6+YYe+C5C2G52IKNJpr4WS7A2UoqMsAYssJ0Z7M6CVOdwodygJN7zXU1EUEBNlQaXLgyqnFHBcDlsiCp3m6vmKsoiwiAI8kowqlwdJMVHNUTxqBqad87V//37k5+djxIgR6rakpCQMHToUubm5GD9+PHJzc5GcnKwGXgAwYsQIiKKIrVu34qqrrkJubi4uvPBC2Gy+FcGzs7Px+OOP4+TJk2jVqlXAZzscDjgcDvV5aWkpAECSJEjMshcyVdUtsFEWAZIkQZZlddHASpeHdRFiSh3wezcO68B4ZquDSqdb97zc4YLNIqjBk80iQpIkxNu9N3KyDBSe8o4eiY4S1d8j1uYNvsocLng8Hl16eUn2Dm9s6s1gczFbHUQi1kHLcHskdX3TKBG1fr/1qYOYKBFlDg/KHS5Ikq3G/ajhmvJ/37TBV35+PgAgPT1dtz09PV19LT8/H2lpabrXrVYrWrdurdunS5cuAcdQXgsWfM2bNw9z5swJ2F5UVASn0xmwnVrGkcJTAACbCBQWFqKkpASOcu8f//JKBwoLC40sXsSRJAklJSWQZRmiaI6bsEjDOjCe2ergWHGp7vmhI4VwJdpwqsIbYFVVnFKvlXarAIdbxtGSSgCAo/wUCgu9DVrKtK8jBUWIl8p1izcDwOGjBYiz1z/7WksyWx1EItZBy9BOqSg5eRzOsprPufrUga06Q/SRgmOI9ZQ3b2EjXElJSaPfa9rgy0gzZ87EjBkz1OelpaXo2LEjUlNTkZycbFzBIoz9hPdnQowdaWlpEAQBGXbvf1mXLAQE3tSyJEmCIAhITU3lH1uDsA6MZ7Y6sNj0NwCxiclIS4uHJHiTU6WntEZaWioAICnGhsJTDlRUDy3skJ6CtDRvA2R8tA0odcIel4j45MSAz4lPbq1byNVIZquDSMQ6aBnadfvaZ6TDWkvGw/rUQaw9Cicq3IhNSEJaWnJzFzeiaUfUNZRpg6+MjAwAQEFBAdq2batuLygowIABA9R9/Hs/3G43Tpw4ob4/IyMDBQUFun2U58o+/ux2O+z2wD8yoijyIhNCjupshzE2C0RRhCAIiLV5xyxXuSTWhQEEQeB5YDDWgfHMVAcOvyxmVW7vtVFJkhFjs6rlTIqJQuEp35D6tMQY9TVl/pfDLaOy+tprs4oQBe/11ukxVw+HmeogUrEOml+V5tyzRdV9i15XHajz5N28Z2puTfk+TVsTXbp0QUZGBjZs2KBuKy0txdatW5GVlQUAyMrKQnFxMXbs2KHu8+mnn0KSJAwdOlTd5/PPP4fL5VL3WbduHbp37x50yCGZh5J1K1aTBlmZPM5sh0REvpTyCiWTof8iywCQ6Dfhvk28r5FRSTdf4fKo88hibRY1WyIzHhK1PCUZTpyteYb4Kue1/3WCjGVo8FVWVoa8vDzk5eUB8CbZyMvLw8GDByEIAqZNm4ZHHnkE77//Pnbu3ImbbroJ7dq1w9ixYwEAPXv2xB/+8Afcfvvt2LZtG7788ktMmTIF48ePR7t27QAAEyZMgM1mw+TJk7F79268+eabWLBggW5YIZmTEmDpgy9eSIiIFP6ZXyvV4EtZ58t3/UyM9rWkx9utuvW9lLTzlU43yh3eY8TZrGoaemaYJWp5avBlb56Bacr5ywZrczF02OHXX3+Niy++WH2uBESTJk3CsmXLcN9996G8vBx33HEHiouLcf755+OTTz5BdHS0+p7XX38dU6ZMwaWXXgpRFDFu3Dg888wz6utJSUlYu3YtcnJyMHjwYLRp0wazZs1imvkwoNxEREcFBl9OjwSPJMMiMvUxEUUu/6BI6flyBOn50qaabhOvn6+g9nz5LcKsLPmhrD1ERC1HOffibM0UfNl8i6uTeRgafA0fPlxdEDIYQRAwd+5czJ07t8Z9WrdujeXLl9f6Of369cMXX3zR6HKSMXwLgfqCL/2igZ5max0iIgpH/ounVjjdkGUZ5dVDB+M118hOKXHqY//kGcq11Rt8+YY+VbmEoJ9DRM1PXYOvmTKLxlQ3vlSx8cRUTDvni8g37NB386Bd8Z3d6EQU6fyvg5UuD8qdHnWtoIRoX29Xj4wE9bF2vhfga+Sqcul7vpSeM/Z8EbW85u75UhpV2PNlLgy+yLSCDTsURUENwDgHgYginX9ijQqnB6WV3gRTURZBN+ywuyb4GtY1RXccpZGr3KHt+bKqc8bY80XU8sqDJBprCuX+ifdL5sIxW2RawYYdAt6LicMt8WJCRBGvqjoLYetYG46UVKHC6cGpKu8NXEJ0FATBNy+2c0ocerZNhNsj4dohHXXHUeaDFVc6dT1fzuo5X7zeErW8Zk+4EcWEG2bE4ItMq9IVvAUoJsqCkkoXKp1siSWiyKYk1mgV5w2+Kp1unKry9nwlROv/xFtEAR/dcz48khyweGur2Orgq8KlG/qkpJhnqnmilqdkGm2uni/lGlBW3SBD5sBhh2RawYYdAkBc9UTUUw5XwHuIiCKJ0iPVOs6bvbDc6UFpdfCVGB0VsL8gCAGBFwAkx3rff7LCqQ47jLFZOMybKITUIb/N1POlBF+lDL5MhcEXmVZNww6VhUJP8WJCRBGurLqlvF1SDACgpNKlGXZY/xs4bc+XtvU9hsOWiEKmvJkTbigNMEpvOJkDhx2SaQVbZBnwZe9i8EVEkU6ZI9K+VXXwVeFSW7mD9XzVpFWcr+freLkTgLc3TWkEq3Aw+CJqaRXqnK/mGnbovQaUVvJ+yUzY80WmVVIZfOiM0prLlhwiimQeSVYbqdone4OvkxXOGud81Sa5uuerpNKFwtIqAN61wJSbwDIHb96IWppy3xPfTMMOE2OUYYe8XzITBl9kWspFSMnCpUhUgy/eDBBR5FLmhwC+nq/iCpd67UxoSM9X9ZwvWQZ+KSoH4F0LLN7uPQaDL6KWd7LCe+4qczibiiOFzInBF5mSJMnqWjX+wVcCxzATEalzs6yigPTEaABKz5UDAJCeaK/xvf6iLKLaU3aszPv+1AQ74qt7vsoZfBG1uJMV3iG/rZop+EqMZs+XGTH4IlMqc7ohyd7Hif7BV3V3PMcwE1EkU3qjYm0WNWFGmcONgycqAAAZSdENOl7nlDjd8zbxdjXrGnu+iFreyer5lkpPdFMpjdVlDjck5aaKDMfgi0yppLrrPTpKDEg1r875Yqp5IopgyrDDeLu1ekFl7/YfjpYCANpVzwOrr66pvuDLIgpIjoli8EUUIm6PpCbLURpTmkq5X5Jlb6M2mQODLzKlmuZ7AUw1T0QE+AKiOLsVFlFQr5dKhsK2Dez56tomXn3cLjkaoiioIw047JCoZRVX3/cIQvB7n8aIjvKt1ac0apPxGHyRKdUWfPlSp/JCQkSRS5nzpfROdWwVq74mCFDngdVXj7YJ6uNBnVrpjl3OVPNELUoZcpgYHRV0IfTGSk3wzv0sPOVotmNS0zD4IlOqLfhKifeOhT5W5gxpmYiIzKTcb02gHhm+4KlzShyiGngDd0mPNDVJx6g+bauPzaU9iELhhDrfq3l6vRRKI4yyhAQZj4sskykpGX+SYgInnabGe28OisockGUZgjLRgYgogqjDDm3eP+U92iaqr53TuXWDjxdlEfH+lPPxzW8nkd07HYBvzki508PrLVELyq8OjhraY12XNPZ8mQ57vsiUCmpJlax0oTvdEjMeElHEUoKv+OoAaWgXX8B1/pltGnXM9MRojOrbVg2ylJ4vjySjyiU1pbhEVIujJd7gq6FzNeuiBHMF7PkyDfZ8kSkV1tICFB1lQWK0FaVVbhSVVSGpmbvoiYjCgTJMKaV6TaA+7ZOwZtqF2H+sDNm9M5rlM+JsFkRZBLg8Mk5UONHe1rAMikRUP/lK8NXALKV1URqslUZtMh57vsiUlBaajBq639PUMcy8mBBRZFIWQ06J940Q6J6RgD/0adtswwMFQUCb6uMf47AlohZzpLgSANCumXu+lPuo/NLKZj0uNR6DLzKl/OqgKi3IsEOAY5iJiI5XJx1qHdc8C7LWRGk5L+L1lqjF+IYdNm/PV8fW3iyoyuLrZDwGX2RKtQ07BHwXp8PFbMkhosikDDtsE9+ywZfa81XG4IuoJciyjAPHygH4gqXmkpniPd6R4iq4PJy3aQYMvsh0yh1uHK++qWhXQwtQJ6Ul5zhbcogoMh1Xhh3GBR8h0FzUDLPs+SJqEfmlVTjlcMMqCujSJq5Zj52WYEd0lAiPJOPwSTZYmwGDLzKd/dWtP63jbDUm01BactiNTkSRSJZlHFMSbrR0z1eCsrYigy+ilvBjQRkAoHObONiszXtrLgiC2mCt3F+RsRh8ken8Wn1x6FpL6w/HMBNRJCupdMHp9g4hahPfsj1faQne4d/KnBQial778ksBAGelx7fI8XtVrwH47aHiFjk+NQyDLzKdX4u8LUC1db13VsYwl1Sqa90QEUWKA9VDrtMT7YiOsrToZykjDQ4cZ6s5UUvIqw6K+nVIbpHjD65edH3Hbyda5PjUMAy+yHT2HFFagBJq3Ccl3o62SdGQZd/+RESR4rfqQCgzpXnnhwSjNIT9drwCkiS3+OcRRZpvDxYDAAZ0TG6R4w/JbKV+jptJNwzH4ItM57vfiwEA/eu4CPVtnwQA+L56fyKiSKHM3VBGAbSk9skxiLIIcLglHC3l0EOi5vRjwSkcLamCzSKiX4ekFvmMs9ITkBBtRYXTg735p1rkM6j+GHyRqRwtqURBqQMWUUCf9om17qsEZzt+OxmCkhERmcfPhb4J+i3NahHVHra9RznSgKg5rf7+KADgwrPaINZmbZHPsIgCBnXy9n5t+fV4i3wG1R+DLzKVz38sAgD0aZ9U50VoWNcUAEDur8c5FIaIIooyTKl/C80R8Teok/dzth9gYxdRc5FlGau/PwIAuKJfuxb9rEt6pAEAVu74HbLMeyYjMfgiU1n/QyEA4JLuaXXu269DEuLtVhRXuPA1e7+IKELkl1ThcHElRKHu4dnN5ezqCftb97PVnKi5fHOwGL8WlcNmFXFpz7rve5pi7MD2iI4SsTf/FL6pbrwhYzD4ItM4We7EZ/u8wdfI3ul17h9lEXFFv7YAgOVbf2vRshERmcWne73XyT7tvQ1QoXD+mW0AeLOyFXLeF1GTybKMxz/ZCwC4sn87JEQHX9e0uSTFRKm9a4s3/dKin0W1Y/BFprH0y/1weWT0aZ+Inm1rn++lmDg0EwDw0c58HOcCoEQUAd7LOwwA+EOfjJB9ZtukGAzomAxZBlZ+83vIPpfodPX+d0ewbf8J2K0ipl92Vkg+8/YLusIqCli3pwBvbj8Yks+kQAy+yBTyS6qw5ItfAQBTLu5W7/f17ZCEfh2S4PRI+NfafS1VPCIiU/j6wAls3X8CVlHAlQPah/Szbxzmbexa9NkvOFnuDOlnE51O8g4V44G3dwIA/nxhV7RLjgnJ53bPSFADvX+s2q2uL0ahxeCLDOdwe/CXN75FlUvC2Z1bIbt3w1pz/355TwDA/7Ydwtrd+S1RRCIiw5VUuvC3d703bH8a3AHtQ3TDphg7sD16ZCTgVJUbs97fzURHRA0kyzL+t+0grn0hF5UuDy44sw3uufTMkJbhrovOwMhe6XB6JNyydJua6IxCh8EXGaqkwoU7/7MDW/efQLzdikfG9oUgCA06xtCuKbj53M4AgCnLv8V7eYeZyYeITiv5JVW4eek2/FhQhjbxNtyb3T3kZbCIAh4a0xsWUcAH3x3BX1d+h3KHO+TlIAo3sizjq5+P4fbXdmDmOzvhdEu4tEcaFk4cBKsltLfioijgqWv7o1fbRJyscOGmV7Zh+pt56vIV1PIiKvhauHAhOnfujOjoaAwdOhTbtm0zukgR61SVCy9+/isu/fdn2LivCDariOcnDkL3jIRGHe/vo3vi8r4ZcHok/OWNPEx4cSu+PnCCLbNEFNZ+KSrDI6v34LJ/b8K3B4uRGG3Fa7cORUq83ZDyZJ2Rgqeu6Q9BAN755jAueeozPPHJXvxYwIVbibRcHgm7Dpdg8aZfcMlTmzDhpa1Y/0MBRAG47w/d8eJNQ5DYwkk2apIQHYV37j4X1w7pAAB499vDuGz+Jlz7Qi5e2bwfPxeeYiN2CxLkCPl233zzTdx0001YvHgxhg4diqeffhorVqzAvn37kJZWe3rP0tJSJCUl4eTJk0hOTg5NgU8jsizjZIULe46UYteREnx94CQ+/6kITrcEAOicEovnJgxCn/Y1r+wuSRIKCwuRlpYGUQzeZuD2SHhmw09Y/Pmv6rHbxNtw4ZmpuKh7Knq1TUTH1rGIjrI0/y8ZAepTB9SyWAfGa4k6kCQZpVUuHC934tgpB344Worvfy9B3u/eNNSK/h2S8NS1/dEtrXGNVM3pq1+O4d4V3+NwcaW6rUdGAoZ0boWz0hOQnhiN1AQ70hLsSE2ww25tvusuzwPjsQ68KpxunKxw4USZE7+dKMdvxytw4Fg5Dhwvx67Dpah0edR94+1WXDmgHW4YllnvpGK1aa46+ObgSTy74Sds3KcffpgUE4VebRNxVno8MlPi0KFVDNomxSAt0Y7WcTZEhbjHzmyKi4vRqlUrlJSUIDGxYfUZMcHX0KFDcfbZZ+O5554D4P1P27FjR0ydOhUPPPBAre8Nl+BLlmVIsu+nVF21kt92yMo2GXL1695t8G2TZHg3+47lcEmocntQ5VL+SahyeVCpeVzl8qDc4cHxcgeOlzlReKoKh09WotzpCSjvGalx+POFZ+CqQe3rPIkbcpE5dKIC89f/iDW78oN+bpzNgqSYKCTF2pAUY0VyjA3JsVHV26KQHGPzPo6Jgj1KhFUUEGUREWURYbUIsIoCrBYRUdU/LYIAUQREQYAoCBAE72OLKEAU0OBhlGbFP7bGYx00D+Va6JFk9VqoXv8k6K6NcvW10y3JcHtkOD0eFB07hlatWkOGoG5zumV4JBkeWYbLrVwrvddFh1uC0y2h0unG8XInTlY4cbzM+/NEuRMnK1zw1NBLLwrAxd3TMGFoJwzvngaLaJ7ridMtYe2efKz69gg2/VgIl6fm24nk2Cg1EEtLiEZSTBSiLN5rqFUUYBX9rq8W7zU0ShRhEQVYLd7rsEUUYBGAstIStElpDZvV4t1P2b+G4ymPRc31WBAAAYLmse96LSjbTpPrd3Nr6rVIe58ia+5XfK9Df25K3nNSlpWf3sce2XtequcqvOe1W5ICtrs93vPQ6ZG852r1+e9we89TjwS4JQnlDg8cbg/cHhkVTg/KHC443BIqnR4UV7hQWuVCpcuDE2VOnKpj2G1itBX9OyZjdN+2GNO/HeKacWmI5v57cOhEBT74/gg+21uE7w8Xo8ol1bivIACtYm2ItopIjrUhJd6GeLsVURYR8dFWJEZHqfdO8dFW2K0iREFAdJSImCgLRNF75sXYLOr9n1UUYLdaoJxydqsIq0WEJMuwCAJsVhGC4K17q+g9361+v7coAlZRhCh691N4rxsCxGa8fjL4qoPT6URsbCxWrlyJsWPHqtsnTZqE4uJivPfee7r9HQ4HHA5f2vLS0lJ07NgRw2a/D2t0nLpd+8Vpv0VZ80pN3672a1cvJFCCHuUPvz6g8r8ZkJT3VG8zu8yUWPRpl4je7RIxvHsauqfH1/sPmyRJKCoqQmpqar0vMk63hG8OnsSmH48h99fj+LWoDGWOwGCspSnBmPrHvHqj77kSpHn/0Cs3AILfMdTH0N8Q6N9XR1mCvLfeZG89WCxiQPkaoin3MrV9qoy6T4Ka3t+U99bn/cHeW5/rhP93JcuAx+OBKFpq/MRg76lvOf3fE+zPg/b/j+5GKFhZNI+116na/uxoj6ccP3gZlWtj4O+lvUYqN2/hIN5uRUqcDV1T49CvOpNr/w7JaB1nM7podTpZ4cQXPx3DD0dPYf+xchSeqkLhKQeOnXLAWUtQFk7U6zcCr7na67pvX0H/epDj1fBJDdi3bvrTre7rjnYv9ZyF5vzVHkBbML/rQbjcmzRVlEVAcqwNnVrFIDMlDpkpschMicWZafHonp7QrDf8Wo25L6qvKpcHPxaUYW9+KX4uLMdvx8txpKQK+SVVOFnhDJtral1EQWk41/8NEwRvsKYEe8rfGO8273Z3VTn2Pj6uUcFXaFZnNNixY8fg8XiQnq5fuDc9PR179+4N2H/evHmYM2dOwPbDxVUQ7adfa7MA739AKP8J4Xus/LERBQE2iwC7VYTdKiI6yvvTblEe+16LiRKRHBOF1rFWtI6NQkaCDemJ3hYSn0oUFVUGK05QkiShpKQEsiw36CLTNR7oOqgVbhnUCrIso9ThQWmVG6eqvD9LqzwodVT/rHLjlMP381SVG05PdYt3dau3+lhtNau7DLIMeAL+Ap0mVy6i05xyg+1tZVX+IMuwCCIEEYiq7nVRelosgtKC670eKtdNm1X0thLHWJEUY0WrGCuS/f4FGwHgLi9GYXlgucxoWFsrhrVtBaCVuk257h4vd+FYuUv9WebwqNdR7U/9NqjXXo+svw47XW7Igqj2fCg/de+r/tdcdI0MQaOKSLyuG/c7i9XnpSh4b4oBANWPrdXnqyj6Gr+iLMq56usFFQSo56pFAKwWATFRFtiqe1JjoyyItYnqPknRVsTbLYiJ8j5uExeFWJtYQ0NyFY4da7kFyRt7X1RfGTYgo5MdwzvZAbRWt8uyjJOVbpyscMPhllBc6UZxpRuVLgkuj4QypwdlDg88sgynW0a50wOXx9ux4PTIqHB5qns2AYdbUnvMPZIMh0cCqs8zl0eCW5IhQIBU/V7la5YkGc3RpqMdJaZX98GlJjTmR0Tw1VAzZ87EjBkz1OdKz9ertwxRo1td74H/AXS9FPpX/XswtNtFJaKGLxpXezU00bnSmqYd4qYGScoFBb4eEfVY8D3X/gwHkiRBEIQmt/Ck171Lg0jVf9yVVkFJ9t44KAGX+rh6H0DzB1yG7n1Kbyf8WuqD9ZL6HmuPWfvFwr/VUtuiWb/fVcLJk8Vo1SoZgiCqZavv/yG1rH5l8n97sKMF62WWg+xbW1H8r6/a99d0Xmo/W9+DVL/3at+vLUew1nD/79G/3gV4/5+UFBcjOTkZoijW2vuo+35quSbp3yPrhmH5lzHY8X37CTV+/7rfuZZeWmU/pcFHqN4xWJ1YtNexGnoKRM11zv/3EUVfy6ZFfVz39bElW5tPV+kAmjOZdkPrQDsMTdejGuxaCl/Pqfa5Qtsbq73u6gOzGnqKNGrq/Q2+b52/YtDj1DZ6oj4ChmDC1/UnSxJOnDiB1q1b6+pA2+OnHWkR7HoiagIg3b7K635D+pUOpHC5b2lpzXVf1BjNfS/VGMpwcOV/gwzfPZlHkqH8d1W2Kw3mgv/26nsu7d8lZairVH2Po3yGdhrPqdISDHq6cWWPiOCrTZs2sFgsKCgo0G0vKChARkbgmlJ2ux12e2AmqYGdWpl6ztfpThAEiKJoqhseUYyQkwjV48uj3UhLa22qOogkkiShMIZ1YDQzXosiTUPqQBSBKDDRUnOSJAk2dznSWsfxPDBQpF+LLAae1sX2mufE1SUiastms2Hw4MHYsGGDuk2SJGzYsAFZWVkGloyIiIiIiCJFpDTaY8aMGZg0aRKGDBmCc845B08//TTKy8txyy23GF00IiIiIiKKABETfF133XUoKirCrFmzkJ+fjwEDBuCTTz4JSMJBRERERETUEiIm+AKAKVOmYMqUKUYXg4iIiIiIIlBEzPkiIiIiIiIyGoMvIiIiIiKiEGDwRUREREREFAIMvoiIiIiIiEKAwRcREREREVEIMPgiIiIiIiIKAQZfREREREREIcDgi4iIiIiIKAQYfBEREREREYUAgy8iIiIiIqIQsBpdgHAgyzIAoLS0FKLIeNUIkiTh1KlTiI6OZh0YhHVgPNaB8VgHxmMdGI91YDzWgbFKS0sB+GKEhmDwVQ/Hjx8HAGRmZhpcEiIiIiIiMoPjx48jKSmpQe9h8FUPrVu3BgAcPHiwwV8wNY/S0lJ07NgRhw4dQmJiotHFiUisA+OxDozHOjAe68B4rAPjsQ6MVVJSgk6dOqkxQkMw+KoHpTs3KSmJ/8ENlpiYyDowGOvAeKwD47EOjMc6MB7rwHisA2M1ZsgnB4kSERERERGFAIMvIiIiIiKiEGDwVQ92ux0PPfQQ7Ha70UWJWKwD47EOjMc6MB7rwHisA+OxDozHOjBWU75/QW5MjkQiIiIiIiJqEPZ8ERERERERhQCDLyIiIiIiohBg8EVERERERBQCDL6IiIiIiIhCgMFXLTweD/7xj3+gS5cuiImJwRlnnIGHH34YzFESOp07d4YgCAH/cnJyjC5aRDl8+DBuuOEGpKSkICYmBn379sXXX39tdLEixuzZswPOgR49ehhdrIj12GOPQRAETJs2zeiiRIxFixahX79+6oKyWVlZ+Pjjj40uVkSZN28ezj77bCQkJCAtLQ1jx47Fvn37jC5WxPn8888xZswYtGvXDoIgYNWqVUYXKSItXLgQnTt3RnR0NIYOHYpt27bV+70Mvmrx+OOPY9GiRXjuuefwww8/4PHHH8cTTzyBZ5991uiiRYzt27fj6NGj6r9169YBAK655hqDSxY5Tp48ifPOOw9RUVH4+OOPsWfPHjz11FNo1aqV0UWLKL1799adC5s3bza6SBFp+/bteOGFF9CvXz+jixJROnTogMceeww7duzA119/jUsuuQRXXnkldu/ebXTRIsamTZuQk5ODLVu2YN26dXC5XBg5ciTKy8uNLlpEKS8vR//+/bFw4UKjixKx3nzzTcyYMQMPPfQQvvnmG/Tv3x/Z2dkoLCys1/uZar4WV1xxBdLT0/Hyyy+r28aNG4eYmBj897//NbBkkWvatGlYvXo1fvrpJwiCYHRxIsIDDzyAL7/8El988YXRRYlYs2fPxqpVq5CXl2d0USJaWVkZBg0ahOeffx6PPPIIBgwYgKefftroYkWs1q1b48knn8TkyZONLkpEKioqQlpaGjZt2oQLL7zQ6OJEJEEQ8O6772Ls2LFGFyWiDB06FGeffTaee+45AIAkSejYsSOmTp2KBx54oM73s+erFueeey42bNiAH3/8EQDw3XffYfPmzRg1apTBJYtMTqcT//3vf3Hrrbcy8Aqh999/H0OGDME111yDtLQ0DBw4EC+++KLRxYo4P/30E9q1a4euXbti4sSJOHjwoNFFijg5OTkYPXo0RowYYXRRIprH48Ebb7yB8vJyZGVlGV2ciFVSUgLAGwQTRQqn04kdO3bo/g6IoogRI0YgNze3XsewtlThTgcPPPAASktL0aNHD1gsFng8Hvzzn//ExIkTjS5aRFq1ahWKi4tx8803G12UiPLrr79i0aJFmDFjBv72t79h+/btuOeee2Cz2TBp0iSjixcRhg4dimXLlqF79+44evQo5syZgwsuuAC7du1CQkKC0cWLCG+88Qa++eYbbN++3eiiRKydO3ciKysLVVVViI+Px7vvvotevXoZXayIJEkSpk2bhvPOOw99+vQxujhEIXPs2DF4PB6kp6frtqenp2Pv3r31OgaDr1q89dZbeP3117F8+XL07t0beXl5mDZtGtq1a8ebTgO8/PLLGDVqFNq1a2d0USKKJEkYMmQIHn30UQDAwIEDsWvXLixevJjnQYhoe9v79euHoUOHIjMzE2+99RaHXIXAoUOH8Je//AXr1q1DdHS00cWJWN27d0deXh5KSkqwcuVKTJo0CZs2bWIAZoCcnBzs2rWLc0+JGoHBVy3uvfdePPDAAxg/fjwAoG/fvvjtt98wb9483nSG2G+//Yb169fjnXfeMbooEadt27YBNzc9e/bE22+/bVCJKDk5GWeddRZ+/vlno4sSEXbs2IHCwkIMGjRI3ebxePD555/jueeeg8PhgMViMbCEkcFms6Fbt24AgMGDB2P79u1YsGABXnjhBYNLFlmmTJmC1atX4/PPP0eHDh2MLg5RSLVp0wYWiwUFBQW67QUFBcjIyKjXMTjnqxYVFRUQRf1XZLFYIEmSQSWKXEuXLkVaWhpGjx5tdFEiznnnnReQTvjHH39EZmamQSWisrIy/PLLL2jbtq3RRYkIl156KXbu3Im8vDz135AhQzBx4kTk5eUx8DKIJElwOBxGFyNiyLKMKVOm4N1338Wnn36KLl26GF0kopCz2WwYPHgwNmzYoG6TJAkbNmyo9xxU9nzVYsyYMfjnP/+JTp06oXfv3vj222/x73//G7feeqvRRYsokiRh6dKlmDRpEqxW/pcNtenTp+Pcc8/Fo48+imuvvRbbtm3DkiVLsGTJEqOLFjH++te/YsyYMcjMzMSRI0fw0EMPwWKx4Prrrze6aBEhISEhYF5LXFwcUlJSON8lRGbOnIlRo0ahU6dOOHXqFJYvX47PPvsMa9asMbpoESMnJwfLly/He++9h4SEBOTn5wMAkpKSEBMTY3DpIkdZWZlu1MP+/fuRl5eH1q1bo1OnTgaWLHLMmDEDkyZNwpAhQ3DOOefg6aefRnl5OW655Zb6HUCmGpWWlsp/+ctf5E6dOsnR0dFy165d5b///e+yw+EwumgRZc2aNTIAed++fUYXJWJ98MEHcp8+fWS73S736NFDXrJkidFFiijXXXed3LZtW9lms8nt27eXr7vuOvnnn382ulgR7aKLLpL/8pe/GF2MiHHrrbfKmZmZss1mk1NTU+VLL71UXrt2rdHFiigAgv5bunSp0UWLKBs3bgxaD5MmTTK6aBHl2WeflTt16iTbbDb5nHPOkbds2VLv93KdLyIiIiIiohDgnC8iIiIiIqIQYPBFREREREQUAgy+iIiIiIiIQoDBFxERERERUQgw+CIiIiIiIgoBBl9EREREREQhwOCLiIiIiIgoBBh8ERERERERhQCDLyIiajBBELBq1aqQf+5nn30GQRBQXFzcLMc7cOAABEFAXl5eix5j2bJlSE5O1m1bsmQJOnbsCFEU8fTTTzfoM/ft24eMjAycOnWq4QVuZseOHUNaWhp+//13o4tCRGR6DL6IiEgnPz8fU6dORdeuXWG329GxY0eMGTMGGzZsMLpoOPfcc3H06FEkJSWF7DP379+PCRMmoF27doiOjkaHDh1w5ZVXYu/evfU+xnXXXYcff/xRfV5aWoopU6bg/vvvx+HDh3HHHXdg+PDhmDZtWr2ON3PmTEydOhUJCQkN/XWaXZs2bXDTTTfhoYceMrooRESmZzW6AEREZB4HDhzAeeedh+TkZDz55JPo27cvXC4X1qxZg5ycnAYFHC3BZrMhIyMjZJ/ncrlw2WWXoXv37njnnXfQtm1b/P777/j4448b1PsWExODmJgY9fnBgwfhcrkwevRotG3btkFlOnjwIFavXo1nn322Qe9rSbfccgsGDx6MJ598Eq1btza6OEREpsWeLyIiUt19990QBAHbtm3DuHHjcNZZZ6F3796YMWMGtmzZotv32LFjuOqqqxAbG4szzzwT77//vu71Xbt2YdSoUYiPj0d6ejpuvPFGHDt2TH19+PDhmDp1KqZNm4ZWrVohPT0dL774IsrLy3HLLbcgISEB3bp1w8cff6y+J9iwwy+//BLDhw9HbGwsWrVqhezsbJw8eRIA8Mknn+D8889HcnIyUlJScMUVV+CXX36p9/exe/du/PLLL3j++ecxbNgwZGZm4rzzzsMjjzyCYcOG6fb99ddfcfHFFyM2Nhb9+/dHbm6u+pp22OGyZcvQt29fAEDXrl0hCAJuvvlmbNq0CQsWLIAgCBAEAQcOHAhaprfeegv9+/dH+/btA46/atUqnHnmmYiOjkZ2djYOHTqk7jN79mwMGDAAL7zwAjp27IjY2Fhce+21KCkpUfe5+eabMXbsWDz66KNIT09HcnIy5s6dC7fbjXvvvRetW7dGhw4dsHTpUl2ZevfujXbt2uHdd9+t93dLRBSJGHwREREA4MSJE/jkk0+Qk5ODuLi4gNf95yzNmTMH1157Lb7//ntcfvnlmDhxIk6cOAEAKC4uxiWXXIKBAwfi66+/xieffIKCggJce+21umO8+uqraNOmDbZt24apU6firrvuwjXXXINzzz0X33zzDUaOHIkbb7wRFRUVQcucl5eHSy+9FL169UJubi42b96MMWPGwOPxAADKy8sxY8YMfP3119iwYQNEUcRVV10FSZLq9Z2kpqZCFEWsXLlSPWZN/v73v+Ovf/0r8vLycNZZZ+H666+H2+0O2O+6667D+vXrAQDbtm3D0aNHsWDBAmRlZeH222/H0aNHcfToUXTs2DHo53zxxRcYMmRIwPaKigr885//xGuvvYYvv/wSxcXFGD9+vG6fn3/+GW+99RY++OADfPLJJ/j2229x99136/b59NNPceTIEXz++ef497//jYceeghXXHEFWrVqha1bt+LOO+/En//854A5Xueccw6++OKLWr8jIqKIJxMREcmyvHXrVhmA/M4779S5LwD5wQcfVJ+XlZXJAOSPP/5YlmVZfvjhh+WRI0fq3nPo0CEZgLxv3z5ZlmX5oosuks8//3z1dbfbLcfFxck33nijuu3o0aMyADk3N1eWZVneuHGjDEA+efKkLMuyfP3118vnnXdevX/HoqIiGYC8c+dOWZZlef/+/TIA+dtvv63xPc8995wcGxsrJyQkyBdffLE8d+5c+ZdfflFfV47x0ksvqdt2794tA5B/+OEHWZZleenSpXJSUpL6+rfffisDkPfv369uu+iii+S//OUvdf4O/fv3l+fOnavbtnTpUhmAvGXLFnXbDz/8IAOQt27dKsuyLD/00EOyxWKRf//9d3Wfjz/+WBZFUT569Kgsy7I8adIkOTMzU/Z4POo+3bt3ly+44AL1uVJP//vf/3RlmD59ujx8+PA6y09EFMnY80VERAAAWZYbtH+/fv3Ux3FxcUhMTERhYSEA4LvvvsPGjRsRHx+v/uvRowcA6Ib9aY9hsViQkpKiDskDgPT0dABQj+tP6fmqyU8//YTrr78eXbt2RWJiIjp37gzAO2+qvnJycpCfn4/XX38dWVlZWLFiBXr37o1169bp9tP+Lso8rprK3RSVlZWIjo4O2G61WnH22Werz3v06IHk5GT88MMP6rZOnTrphitmZWVBkiTs27dP3da7d2+Iou/2ID09XVcnSj35/24xMTE19lASEZEXE24QEREA4Mwzz4QgCPVOqhEVFaV7LgiCOpyvrKwMY8aMweOPPx7wPm2CiWDH0G4TBAEAahwmqE1iEcyYMWOQmZmJF198Ee3atYMkSejTpw+cTmet7/OXkJCAMWPGYMyYMXjkkUeQnZ2NRx55BJdddlnQ36WucjdFmzZt1DltLaGuOlG2+f9uJ06cQGpqaouVi4jodMCeLyIiAgC0bt0a2dnZWLhwIcrLywNeb0h2v0GDBmH37t3o3LkzunXrpvsXbD5ZY/Xr16/GFPjHjx/Hvn378OCDD+LSSy9Fz549myVoEQQBPXr0CPodNYXNZqtzXhkADBw4EHv27AnY7na78fXXX6vP9+3bh+LiYvTs2VPddvDgQRw5ckR9vmXLFoiiiO7duzex9N4EKwMHDmzycYiITmcMvoiISLVw4UJ4PB6cc845ePvtt/HTTz/hhx9+wDPPPIOsrKx6HycnJwcnTpzA9ddfj+3bt+OXX37BmjVrcMstt9QrwKivmTNnYvv27bj77rvx/fffY+/evVi0aBGOHTuGVq1aISUlBUuWLMHPP/+MTz/9FDNmzGjQ8fPy8nDllVdi5cqV2LNnD37++We8/PLLeOWVV3DllVc22+8BAJ07d8bWrVtx4MABHDt2rMZes+zsbOTm5gZ8j1FRUZg6dSq2bt2KHTt24Oabb8awYcNwzjnnqPtER0dj0qRJ+O677/DFF1/gnnvuwbXXXtvk9P0VFRXYsWMHRo4c2aTjEBGd7hh8ERGRqmvXrvjmm29w8cUX4//+7//Qp08fXHbZZdiwYQMWLVpU7+O0a9cOX375JTweD0aOHIm+ffti2rRpSE5O1s0naqqzzjoLa9euxXfffYdzzjkHWVlZeO+992C1WiGKIt544w3s2LEDffr0wfTp0/Hkk0826PgdOnRA586dMWfOHAwdOhSDBg3CggULMGfOHPz9739vtt8DAP7617/CYrGgV69eSE1NrXFe2qhRo2C1WtWMiYrY2Fjcf//9mDBhAs477zzEx8fjzTff1O3TrVs3XH311bj88ssxcuRI9OvXD88//3yTy/7ee++hU6dOuOCCC5p8LCKi05kgN3SGNRERERlq4cKFeP/997FmzRoA3nW+pk2bVuvQ0NmzZ2PVqlXIy8tr9vIMGzYM99xzDyZMmNDsxyYiOp0w4QYREVGY+fOf/4zi4mKcOnUKCQkJhpbl2LFjuPrqq3H99dcbWg4ionDA4IuIiCjMWK3WZh/22Fht2rTBfffdZ3QxiIjCAocdEhERERERhQATbhAREREREYUAgy8iIiIiIqIQYPBFREREREQUAgy+iIiIiIiIQoDBFxERERERUQgw+CIiIiIiIgoBBl9EREREREQhwOCLiIiIiIgoBP4fL3v5xF1GqdIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Read spectrum with b0 and nucleus specified\n", + "spe_ppm = read_simp('../../examples/read/ethanol.spe', b0='400MHz', nucleus='1H')\n", + "\n", + "# Access the ppm data through the ppm property\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(spe_ppm.ppm['ppm'], spe_ppm.ppm['real'])\n", + "plt.xlabel('Chemical Shift (ppm)')\n", + "plt.ylabel('Intensity')\n", + "plt.title('$^1$H NMR Spectrum of Ethanol')\n", + "plt.xlim(8, 0) # Conventional ppm range for ¹H\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "44dfc478", + "metadata": { + "id": "0100b9b5", + "language": "markdown" + }, + "source": [ + "## Automatic Format Conversion\n", + "\n", + "One of the key features of the new `Simpy` class is automatic format conversion. If you load a FID file but need spectrum data, simply access the `spe` property and the conversion happens automatically:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b8f1739f", + "metadata": { + "id": "da84411b", + "language": "python" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Read a FID file\n", + "fid_data = read_simp('../../examples/read/ethanol.fid')\n", + "\n", + "# Access the spectrum data - automatic FID→SPE conversion happens here\n", + "auto_converted_spe = fid_data.spe\n", + "\n", + "# Compare with directly loaded SPE file\n", + "spe_data = read_simp('../../examples/read/ethanol.spe')\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(auto_converted_spe['hz'], auto_converted_spe['real'], label='Auto-converted from FID')\n", + "plt.plot(spe_data.spe['hz'], spe_data.spe['real'], label='Directly loaded SPE')\n", + "plt.xlim(3000, 0)\n", + "plt.xlabel('Frequency (Hz)')\n", + "plt.ylabel('Intensity')\n", + "plt.title('Comparison of Spectrum Data')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4be3953e", + "metadata": {}, + "source": [ + "Similarly, if you load a spectrum file but need FID data, access the `fid` property for automatic conversion:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "417ddef2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1UAAAHWCAYAAACfRKOZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAf0hJREFUeJzt3Xd4FFXbBvB7dje76QmBVAgJPXRCCwGlSROkCDZACF0RUMCKBYj6SvlERRFsNBUERQQbKCCiIh1CLxJC6CSQ3svM90fIZGc3pCc7E+7fdeV9M2fOzjy7OUgezjnPCJIkSSAiIiIiIqIy0dk6ACIiIiIiIi1jUkVERERERFQOTKqIiIiIiIjKgUkVERERERFROTCpIiIiIiIiKgcmVUREREREROXApIqIiIiIiKgcmFQRERERERGVA5MqIiIiIiKicmBSRUREqiQIAubOnWvrMMrtq6++QlBQEOzs7ODu7m7rcIiIqBIwqSIiUqnIyEg89dRTqF+/Puzt7eHq6oouXbpg8eLFSE9Pt3V4VAJnzpzBmDFj0KBBA3z++ef47LPP7tp37ty5EASh0K9PPvlE7icIAqZOnSofX7x4UdHXzs4OtWrVQufOnfHqq6/i0qVLJY7X/DoGgwEeHh5o164dnnvuOZw6dapsHwKAtLQ0zJ07F3/++WeZr0FEpGYGWwdARETWfvnlFzz66KMwmUwYPXo0WrRogaysLPzzzz948cUXcfLkySJ/Qa8O0tPTYTBo+6+pP//8E6IoYvHixWjYsGGJXrNs2TI4Ozsr2kJCQop93fDhw9G/f3+Iooj4+HgcOHAAH3zwARYvXozly5fjiSeeKNH9e/fujdGjR0OSJCQmJuLo0aNYvXo1li5digULFmDmzJkluo65tLQ0hIeHAwC6d+9e6tcTEamdtv+2IiKqhqKiovDEE08gICAAf/zxB3x9feVzU6ZMwfnz5/HLL7/YMMLKI4oisrKyYG9vD3t7e1uHU24xMTEAUKplf4888ghq1apV6nu1bdsWTz75pKItOjoaffr0QVhYGJo2bYrWrVsXe53GjRtbXWf+/PkYOHAgnn/+eQQFBaF///6ljo+IqDrj8j8iIpVZuHAhUlJSsHz5ckVCla9hw4Z47rnn5OOcnBy89dZbaNCgAUwmEwIDA/Hqq68iMzNT8brAwEA89NBD+PPPP9G+fXs4ODigZcuW8pKsjRs3omXLlrC3t0e7du1w5MgRxevHjBkDZ2dnXLhwAX379oWTkxP8/Pzw5ptvQpIkRd93330XnTt3Rs2aNeHg4IB27dphw4YNVu8lfynbmjVr0Lx5c5hMJmzdulU+Z76nKjk5GdOnT0dgYCBMJhO8vLzQu3dvHD58WHHN7777Du3atYODgwNq1aqFJ598ElevXi30vVy9ehVDhgyBs7MzPD098cILLyA3N/cuPxmlpUuXyjH7+flhypQpSEhIUHzec+bMAQB4enraZI9YQEAAVq1ahaysLCxcuLDM16lZsybWrVsHg8GA//3vf3J7VlYWZs+ejXbt2sHNzQ1OTk64//77sXPnTrnPxYsX4enpCQAIDw+XlxfmfxbHjh3DmDFj5GWuPj4+GDduHG7fvl3meImIqhqTKiIilfnpp59Qv359dO7cuUT9J0yYgNmzZ6Nt27Z4//330a1bN8ybN6/Q5V7nz5/HiBEjMHDgQMybNw/x8fEYOHAg1qxZgxkzZuDJJ59EeHg4IiMj8dhjj0EURcXrc3Nz0a9fP3h7e2PhwoVo164d5syZIycP+RYvXozg4GC8+eabeOedd2AwGPDoo48WOsP2xx9/YMaMGXj88cexePFiBAYGFvo+n376aSxbtgzDhg3D0qVL8cILL8DBwQGnT5+W+6xatQqPPfYY9Ho95s2bh4kTJ2Ljxo247777FAlP/nvp27cvatasiXfffRfdunXDokWLSrSscu7cuZgyZQr8/PywaNEiDBs2DJ9++in69OmD7OxsAMAHH3yAhx9+GEDekr6vvvoKQ4cOLfbacXFxuHXrlvwVHx9f7GuKEhoaigYNGmDbtm3luk7dunXRrVs37N27F0lJSQCApKQkfPHFF+jevTsWLFiAuXPnIjY2Fn379kVERASAvIRy2bJlAICHH34YX331leKz2LZtGy5cuICxY8fio48+whNPPIF169ahf//+Vsk6EZFqSUREpBqJiYkSAGnw4MEl6h8RESEBkCZMmKBof+GFFyQA0h9//CG3BQQESACkf//9V2777bffJACSg4ODFB0dLbd/+umnEgBp586dcltYWJgEQJo2bZrcJoqiNGDAAMloNEqxsbFye1pamiKerKwsqUWLFlLPnj0V7QAknU4nnTx50uq9AZDmzJkjH7u5uUlTpky562eRlZUleXl5SS1atJDS09Pl9p9//lkCIM2ePdvqvbz55puKawQHB0vt2rW76z0kSZJiYmIko9Eo9enTR8rNzZXblyxZIgGQVqxYIbfNmTNHAqD4bO4mv6/lV0BAgKIfAMXnEBUVJQGQ/u///u+u1x48eLAEQEpMTCwyBstrW3ruueckANLRo0clSZKknJwcKTMzU9EnPj5e8vb2lsaNGye3xcbGWv0881mOFUmSpG+++UYCIP31119FxktEpBacqSIiUpH8GQAXF5cS9f/1118BwKp4wPPPPw8AVjNDzZo1Q2hoqHycXwChZ8+eqFu3rlX7hQsXrO5pXnkuf/leVlYWtm/fLrc7ODjI38fHxyMxMRH333+/1VI9AOjWrRuaNWtWzDvN25e0b98+XLt2rdDzBw8eRExMDJ555hnFfqwBAwYgKCio0Fmyp59+WnF8//33F/qezW3fvh1ZWVmYPn06dLqCv0YnTpwIV1fXcu93+/7777Ft2zb5a82aNeW6HgC58EVycnKFXkev18NoNALI2w8XFxeHnJwctG/fvtCfdWHMx0pGRgZu3bqFTp06AUCJr0FEZGssVEFEpCKurq4ASv7Lb3R0NHQ6nVVlOR8fH7i7uyM6OlrRbp44AYCbmxsAwN/fv9B2y6VnOp0O9evXV7Q1btwYQN7emXw///wz3n77bURERCj2dgmCYPUe6tWrd9f3Z27hwoUICwuDv78/2rVrh/79+2P06NFyPPnvtUmTJlavDQoKwj///KNos7e3l/f65KtRo0axy+3udh+j0Yj69etbfeal1bVr1zIVqihKSkoKgJIn66W5zurVq7Fo0SKcOXNGXvoIlPznGhcXh/DwcKxbt04u7JEvMTGxXPESEVUVzlQREamIq6sr/Pz8cOLEiVK9rrBkpTB6vb5U7VIZ9rT8/fffGDRoEOzt7bF06VL8+uuv2LZtG0aMGFHo9cxnKory2GOP4cKFC/joo4/g5+eH//u//0Pz5s2xZcuWUscI3P09V0cnTpyAl5eXnLSX5zp6vV5OmL7++mv5OVzLly/H1q1bsW3bNvTs2dNqP97dPPbYY/j888/x9NNPY+PGjfj999/lYiUlvQYRka0xqSIiUpmHHnoIkZGR2LNnT7F9AwICIIoi/vvvP0X7zZs3kZCQgICAgAqNTRRFq+Vx586dAwC5wMT3338Pe3t7/Pbbbxg3bhwefPBB9OrVq0Lu7+vri2eeeQabNm1CVFQUatasKVejy3+vZ8+etXrd2bNnK+yzuNt9srKyEBUVVeGfeXnt2bMHkZGR6NOnT7muc+nSJezatQuhoaHyTNWGDRtQv359bNy4EaNGjULfvn3Rq1cvZGRkKF57t6Q/Pj4eO3bswCuvvILw8HA8/PDD6N27t9VsKBGR2jGpIiJSmZdeeglOTk6YMGECbt68aXU+MjISixcvBgD5eUEffPCBos97770HIG8/UUVbsmSJ/L0kSViyZAns7OzwwAMPAMibARIEQVGa/OLFi9i0aVOZ75mbm2u1FMzLywt+fn7y8sL27dvDy8sLn3zyiWLJ4ZYtW3D69OkK+yx69eoFo9GIDz/8UDHztnz5ciQmJlbKZ15W0dHRGDNmDIxGI1588cUyXycuLg7Dhw9Hbm4uXnvtNbk9f7bP/HPYt2+f1T8IODo6AoBVBcbCXg9Yj2ciIrXjnioiIpVp0KAB1q5di8cffxxNmzbF6NGj0aJFC2RlZeHff//Fd999hzFjxgAAWrdujbCwMHz22WdISEhAt27dsH//fqxevRpDhgxBjx49KjQ2e3t7bN26FWFhYQgJCcGWLVvwyy+/4NVXX5X3Jw0YMADvvfce+vXrhxEjRiAmJgYff/wxGjZsiGPHjpXpvsnJyahTpw4eeeQRtG7dGs7Ozti+fTsOHDiARYsWAQDs7OywYMECjB07Ft26dcPw4cNx8+ZNuUz7jBkzKuQz8PT0xKxZsxAeHo5+/fph0KBBOHv2LJYuXYoOHTpYPTi3qhw+fBhff/01RFFEQkICDhw4gO+//x6CIOCrr75Cq1atSnSdc+fO4euvv4YkSUhKSsLRo0fx3XffISUlRf655nvooYewceNGPPzwwxgwYACioqLwySefoFmzZvL+KyBviWezZs2wfv16NG7cGB4eHmjRogVatGiBrl27YuHChcjOzkbt2rXx+++/IyoqqsI/HyKiSmXDyoNERFSEc+fOSRMnTpQCAwMlo9Eoubi4SF26dJE++ugjKSMjQ+6XnZ0thYeHS/Xq1ZPs7Owkf39/adasWYo+kpRXUn3AgAFW90EhZbQLK9MdFhYmOTk5SZGRkVKfPn0kR0dHydvbW5ozZ46itLgkSdLy5culRo0aSSaTSQoKCpJWrlwplwwv7t7m5/JLcGdmZkovvvii1Lp1a8nFxUVycnKSWrduLS1dutTqdevXr5eCg4Mlk8kkeXh4SCNHjpSuXLmi6JP/XiwVFuPdLFmyRAoKCpLs7Owkb29vafLkyVJ8fHyh1ytNSfXi+lp+Zvk/q/wvg8EgeXh4SCEhIdKsWbMUpfKLY34dnU4nubu7S8HBwdJzzz1XaNl7URSld955RwoICJBMJpMUHBws/fzzz1JYWJhVKfh///1XateunWQ0GhU/2ytXrkgPP/yw5O7uLrm5uUmPPvqodO3atbuWYCciUiNBkvhkPSIiKt6YMWOwYcMGxQwEERERcU8VERERERFRuTCpIiIiIiIiKgcmVUREREREROXAPVVERERERETlwJkqIiIiIiKicmBSRUREREREVA58+K8ZURRx7do1uLi4QBAEW4dDREREREQ2IkkSkpOT4efnB52u6LkoJlVmrl27Bn9/f1uHQUREREREKnH58mXUqVOnyD5Mqsy4uLgAyPvgXF1dbRxN3sxZbGwsPD09i82OiWyN45W0hOOVtITjlbSkOo3XpKQk+Pv7yzlCUZhUmclf8ufq6qqapCojIwOurq6aH5RU/XG8kpZwvJKWcLySllTH8VqSbUHV450SERERERHZCJMqIiIiIiKiclBNUvXXX39h4MCB8PPzgyAI2LRpk+K8JEmYPXs2fH194eDggF69euG///5T9ImLi8PIkSPh6uoKd3d3jB8/HikpKVX4LoiIiIiI6F6jmj1VqampaN26NcaNG4ehQ4danV+4cCE+/PBDrF69GvXq1cMbb7yBvn374tSpU7C3twcAjBw5EtevX8e2bduQnZ2NsWPHYtKkSVi7dm1Vvx0iIiKiUsnNzUV2drZVuyiKyM7ORkZGRrXZo0LVl9bGq52dHfR6fbmvI0iSJFVAPBVKEAT88MMPGDJkCIC8WSo/Pz88//zzeOGFFwAAiYmJ8Pb2xqpVq/DEE0/g9OnTaNasGQ4cOID27dsDALZu3Yr+/fvjypUr8PPzK/a+SUlJcHNzQ2JiomoKVcTExMDLy0sTg5LubRyvpCUcr6Q2KSkpuHLlCgr7tUySJIiiCJ1Ox+dokuppbbwKgoA6derA2dnZ6lxpcgPVzFQVJSoqCjdu3ECvXr3kNjc3N4SEhGDPnj144oknsGfPHri7u8sJFQD06tULOp0O+/btw8MPP2x13czMTGRmZsrHSUlJAPL+shVFsRLfUcmIoigPTCK143glLeF4JTXJzc3FlStX4OjoiFq1ahX6i2h2djbs7OxsEB1R6WllvEqShFu3buHKlSto0KCB1YxVaf6O0ERSdePGDQCAt7e3ot3b21s+d+PGDXh5eSnOGwwGeHh4yH0szZs3D+Hh4VbtsbGxyMjIqIjQy0UURSQmJkKSJP5LKqkexytpCccrqUl2djZycnLg7u5e6C+i+bNXer1eE//yT/c2rY1Xd3d3JCUl4caNG1Z//pKTk0t8HU0kVZVl1qxZmDlzpnyc/4AvT09P1Sz/EwShWjw8jao/jlfSEo5XUpOMjAwkJyfDzs4OBsPdfzXTwr/8E+XTyni1s7ODTqdDzZo15ToN+SyPi6KJpMrHxwcAcPPmTfj6+srtN2/eRJs2beQ+MTExitfl5OQgLi5Ofr0lk8kEk8lk1a7T6VTzl6wgCKqKh6goHK+kJRyvpBb5e0/yvyxJkiS3a+Ff/uneprXxmv/nrrC/D0rz94Mm/iapV68efHx8sGPHDrktKSkJ+/btQ2hoKAAgNDQUCQkJOHTokNznjz/+gCiKCAkJqfKYiYiIiIjo3qCapColJQURERGIiIgAkFecIiIiApcuXYIgCJg+fTrefvtt/Pjjjzh+/DhGjx4NPz8/uUJg06ZN0a9fP0ycOBH79+/H7t27MXXqVDzxxBMlqvxHRERERFRdFPbcV3OSJGHSpEnw8PCAIAjy7+BUNqpJqg4ePIjg4GAEBwcDAGbOnIng4GDMnj0bAPDSSy9h2rRpmDRpEjp06ICUlBRs3bpVsdZxzZo1CAoKwgMPPID+/fvjvvvuw2effWaT90NERER0L9izZw/0ej0GDBhQptfPnTtX3s5xrysuEapIW7duxapVq/Dzzz/j+vXraNGiRZXctyhRUVEYMWIE/Pz8YG9vjzp16mDw4ME4c+aM3Md8qaybmxu6dOmCP/74Qz4/ZswYRZ/8r379+lVq7KrZU9W9e/dCn82QTxAEvPnmm3jzzTfv2sfDw4MP+iUiIiKqQsuXL8e0adOwfPlyXLt2jSuEyiArKwtGo7FK7xkZGQlfX1907tz5rn2qMq7s7Gz07t0bTZo0wcaNG+Hr64srV65gy5YtSEhIUPRduXIl+vXrh1u3buG1117DQw89hBMnTqB+/foAgH79+mHlypWK1xRWR6EiqWamiiyc+B7CJ53h8u98W0dCREREVUiSJKRl5djkq6h/4C5MSkoK1q9fj8mTJ2PAgAFYtWqV4vyqVavg7u6uaNu0aZNcwGDVqlUIDw/H0aNH5RmF/GtcunQJgwcPhrOzM1xdXfHYY4/h5s2bxca0e/dudO/eHY6OjqhRowb69u2L+Ph4AHnPKH322Wfh5eUFe3t73HfffThw4ID82j///BOCIGDHjh1o3749HB0d0blzZ5w9exYAcO7cOQiCoJg5AYD3338fDRo0kI9PnDiBBx98EM7OzvD29saoUaNw69Yt+Xz37t0xdepUTJ8+HbVq1ULfvn0RGBgIAHj44YchCIJ8DACbN29G27ZtYW9vj/r16yM8PBw5OTny+f/++w9du3aFvb09mjVrhm3bthX5GY0ZMwbTpk2Tt9nk36uwuABg165d6NixI0wmE3x9ffHKK68o7t+9e3dMmzYN06dPh4eHB+rUqYPPP/8cqampGDt2LFxcXNCwYUNs2bLlrjGdPHkSkZGRWLp0KTp16oSAgAB06dIFb7/9Njp16qTo6+7uDh8fH7Ro0QLLli1Denq64j2bTCb4+PgovmrUqFHkZ1JeqpmpIgtpcRBiTkPvXNfWkRAREVEVSs/ORbPZv9nk3qfe7AtHY8l/Pfz2228RFBSEJk2a4Mknn8T06dMxa9asEld9e/zxx3HixAls3boV27dvBwC4ublBFEU5odq1axdycnIwZcoUPP744/jzzz/ver2IiAg88MADGDduHBYvXgyDwYCdO3ciNzcXQN52ku+//x6rV69GQEAAFi5ciL59++L8+fPw8PCQr/Paa69h0aJF8PT0xNNPP41x48Zh9+7daNy4Mdq3b481a9bgrbfekvuvWbMGI0aMAAAkJCSgZ8+emDBhAt5//32kp6fj5ZdfxmOPPaZYprZ69WpMnjwZu3fvBpC34srLy0uehcl/EO3ff/+N0aNH48MPP8T999+PyMhITJo0CQAwZ84ciKKIoUOHwtvbG/v27UNiYiKmT59e5Oe+ePFiNGjQAJ999hkOHDigeOitZVxXr15F//79MWbMGHz55Zc4c+YMJk6cCHt7e8ydO1fxupdeegn79u3DN998g2eeeQabNm3Cww8/jFdffRXvv/8+Ro0ahUuXLsHR0dEqpvxHXGzYsAHTp0+3ehDv3Tg4OADIm1WzJc5UqVX+f4xK+S9GRERERFVl+fLlePLJJwHkLblKTEzErl27Svx6BwcHODs7w2AwyDMKDg4O2LFjB44fP461a9eiXbt2CAkJwZdffoldu3YpZpYsLVy4EO3bt8fSpUvRunVrNG/eHFOnTkWtWrWQmpqKZcuW4f/+7//w4IMPolmzZvj888/h4OCA5cuXK67zv//9D926dUOzZs3wyiuv4N9//0VGRgYAYOTIkfjmm2/kvufOncOhQ4cwcuRIAMCSJUsQHByMd955B0FBQQgODsaKFSuwc+dOnDt3Tn5do0aNsHDhQjRp0gRNmjSBp6cngIJZmPzj8PBwvPLKKwgLC0P9+vXRu3dvvPXWW/j0008BANu3b8eZM2fw5ZdfonXr1ujatSveeeedIj93Nzc3uLi4QK/XK+5VWFxLly6Fv78/lixZgqCgIAwZMgTh4eFYtGgRRFGUX9e6dWu8/vrraNSoEV5++WXY29ujVq1amDhxIho1aoTZs2fj9u3bOHbsWKEx1a5dGx9++CFmz56NGjVqoGfPnnjrrbdw4cKFu76PtLQ0vP7669Dr9ejWrZvc/vPPP8PZ2VnxVdxnUl6cqVIt9df1JyIioornYKfHqTf7yseSJCEnJwcGg6HSn/vjYFey2QEAOHv2LPbv348ffvgBAGAwGPD4449j+fLl6N69e7niOH36NPz9/eHv7y+3NWvWDO7u7jh9+jQ6dOiA5s2bIzo6GgBw//33Y8uWLYiIiMCjjz5a6DUjIyORnZ2NLl26yG12dnbo2LEjTp8+rejbqlUr+fv8Z6TGxMSgbt26eOKJJ/DCCy9g79696NSpE9asWYO2bdsiKCgIAHD06FHs3LkTzs7OhcbQuHFjAEC7du1K9FkcPXoUu3fvxv/+9z+5LTc3FxkZGUhLS5M/K/O9bPmPHCoLy7hOnz6N0NBQxdjr0qULUlJScOXKFdStm7eqyvwz0+v1qFmzJlq2bCm3eXt7A4DVc2XNTZkyBaNHj8aff/6JvXv34rvvvsM777yDH3/8Eb1795b7DR8+HHq9Hunp6fD09MTy5csV9+/RoweWLVumuLb5TGRlYFKlepypIiIiupcIgqBYgidJEnJ0qJKkqjSWL1+OnJwcxS/zkiTBZDJhyZIlcHNzg06ns9qnlZ2dXSH3//XXX+Vr5S8By///8rKzs5O/z//M82dlfHx80LNnT6xduxadOnXC2rVrMXnyZLl/SkoKBg4ciAULFlhdNz9BAwAnJ6cSxZKSkoLw8HAMHTrU6px5FeyKUtK4LJl/ZkDe51bU53g3Li4uGDhwIAYOHIi3334bffv2xdtvv61Iqt5//3306tULbm5uilk28/fQsGHDMr2PsuLyP7Xi8j8iIiJSqZycHHz55ZdYtGiR/JzRiIgIHD16FH5+fvLyOE9PTyQnJyM1NVV+reXzkIxGo7znKV/Tpk1x+fJlXL58WW47deoUEhIS0KxZMwBAQEAAGjZsiIYNG6J27doA8mZLduzYUWjMDRo0gNFolPcKAXkJ3oEDB+RrltTIkSOxfv167NmzBxcuXMATTzwhn2vbti1OnjyJwMBAOb78r+ISFjs7O6vPom3btjh79qzVtRo2bAidTid/VtevX5dfs3fv3lK9n6I0bdoUe/bsUSTHu3fvhouLC+rUqVNh9ymMIAgICgpSjB8gL7Ft2LBhoQmVrTCpUq38f4liUkVERETq8vPPPyM+Ph7jx49HixYtFF/Dhg2T9yiFhITA0dERr776KiIjI7F27VqrCoGBgYGIiopCREQEbt26hczMTPTq1QstW7bEyJEjcfjwYezfvx+jR49Gt27d0L59+7vGNWvWLBw4cADPPPMMjh07hjNnzmDZsmW4desWnJycMHnyZLz44ovYunUrTp06hYkTJyItLQ3jx48v1fsfOnQokpOTMXnyZPTo0UMxWzdlyhTExcVh+PDhOHDgACIjI/Hbb79h7NixVgmTpcDAQOzYsQM3btyQKxbOnj0bX375JcLDw3Hy5EmcPn0a69atw+uvvw4A6NWrFxo3boywsDAcPXoUf//9N1577bVSvZ+iPPPMM7h8+TKmTZuGM2fOYPPmzZgzZw5mzpwJna7iUomIiAgMHjwYGzZswKlTp3D+/HksX74cK1aswODBg0t1rczMTNy4cUPxZV59sTIwqVIrgUkVERERqdPy5cvl5VeWhg0bhoMHD+LYsWPw8PDA119/jV9//RUtW7bEN998o6gYl9+/X79+6NGjBzw9PfHNN99AEARs3rwZNWrUQNeuXdGrVy/Ur18f69evLzKuxo0b4/fff8fRo0fRsWNHhIaGYvPmzTAY8pZTzp8/H8OGDcOoUaPQtm1bnD9/Hr/99lupy23nL1E7evSoXKAin5+fH3bv3o3c3Fz06dMHLVu2xPTp0+Hu7l5sErJo0SJs27YN/v7+CA4OBgD07dsXP//8M37//Xd06NABnTp1wvvvv4+AgAAAgE6nww8//ID09HR07NgREyZMUOy/Kq/atWvj119/xf79+9G6dWs8/fTTGD9+vJzUVZQ6deogMDAQ4eHhCAkJQdu2bbF48WKEh4eXOkncunUrfH19FV/33XdfhcZrSZBK+0CCaiwpKQlubm5ITEyEq6urbYM5tBr46VlkBPaEcfT3FfovAUSVQRRFxMTEwMvLi+OVVI/jldQkIyMDUVFRqFevXqF7ZKqyUAVReWltvBb15680uQH/JlE75rxERERERKrGpEqtNJDZExERERERkyoVY/U/IiIiIiItYFKlVpypIiIiIiLSBCZVqseZKiIiIiIiNWNSpVp5M1UCl/8REREREakakyq14nOqiIiIiIg0gUmVanFPFRERERGRFjCpUj3OVBERERERqRmTKrXKX/7HnIqIiIg0ThAEbNq0SZP3njt3Ltq0aVNh8VTmfS5evAhBEBAREVEhMVHJMalSLe6pIiIiIvUaM2YMBEGAIAiws7ODt7c3evfujRUrVkAURUXf69ev48EHH6zUeKoq+dG67t27yz8386+cnBz5/PTp0wvtbzKZULt2bQwcOBAbN2600TtQJyZVasXnVBEREZHK9evXD9evX8fFixexZcsW9OjRA8899xweeugh+Zd0APDx8YHJZLrrdbKzs6siXLpj4sSJuH79uuLLYDAU2z8yMhLff/89mjVrhieeeAKTJk2qwqjVjUmV2rGkOhER0b1FkoCsVNt8lfL3DpPJBB8fH9SuXRtt27bFq6++is2bN2PLli1YtWqV3M98CV7+ErX169ejW7dusLe3x5o1awAAX3zxBZo2bQp7e3sEBQVh6dKlivtduXIFw4cPh4eHB5ycnNC+fXvs27cPq1atQnh4OI4ePSrPqpjfP1/Pnj0xdepURVtsbCyMRiN27NhRovcsiiLefPNN1KlTByaTCW3atMHWrVsVfV5++WU0btwYjo6OqF+/Pt544w2rxHH+/Pnw9vaGi4sLxo8fj4yMDKt7Ffd57N+/H8HBwbC3t0f79u1x5MiREr0HR0dH+Pj4KL5K0r9OnTro1KkTFixYgE8//RSff/45tm/fXqJ7Vnd3T0nJxrj8j4iI6J6UnQa84ycfCgDsqurer14DjE7lukTPnj3RunVrbNy4ERMmTLhrv1deeQWLFi2Sk4I1a9Zg9uzZWLJkCYKDg3HkyBFMnDgRTk5OCAsLQ0pKCrp164batWvjxx9/hI+PDw4fPgxRFPH444/jxIkT2Lp1q/xLvpubm9U9J0yYgKlTp2LRokXyzNnXX3+N2rVro2fPniV6f4sXL8aiRYvw6aefIjg4GCtWrMCgQYNw8uRJNGrUCADg4uKCVatWwc/PD8ePH8fEiRPh4uKCl156CQDw7bffYu7cufj4449x33334auvvsKHH36I+vXry/cpyefx0EMPoXfv3vj6668RFRWF5557rmQ/pAoQFhaG559/Hhs3bkSvXr2q7L5qxaRKrficKiIiItKooKAgHDt2rMg+06dPx9ChQ+XjOXPmYNGiRXJbvXr1cOrUKXz66acICwvD2rVrERsbiwMHDsDDwwMA0LBhQ/n1zs7OMBgMRc66DB06FFOnTsXmzZvx2GOPAQBWrVol7w8riXfffRcvv/wynnjiCQDAggULsHPnTnzwwQf4+OOPAQCvv/663D8wMBAvvPAC1q1bJydVH3zwAcaPH4/x48cDAN5++21s375dMVtVks9DFEUsX74c9vb2aN68Oa5cuYLJkycX+x6WLl2KL774Qj5+6qmnsGjRohK9/3w6nQ6NGzfGxYsXS/W66opJldpx+R8REdG9xc4xb8boDkmSkJOTA4PBUOJf/Mt17wogSVKxsbZv317+PjU1FZGRkRg/fjwmTpwot+fk5MgzThEREQgODpYTqrKwt7fHqFGjsGLFCjz22GM4fPgwTpw4gR9//LFEr09KSsK1a9fQpUsXRXuXLl1w9OhR+Xj9+vX48MMPERkZiZSUFOTk5MDV1VU+f/r0aTz99NOKa4SGhmLnzp0ASvZ5nD59Gq1atYK9vb3iGiUxcuRIvPbaa/Kxu7t7iV5nqSQ/53sFkyq14gAlIiK6NwmCcgmeJAG6HMBg0MzvB6dPn0a9evWK7OPkVPAeU1JSAACff/45QkJCFP30ej0AwMHBoUJimzBhAtq0aYMrV65g5cqV6NmzJwICAirk2gCwZ88ejBw5EuHh4ejbty/c3Nywbt26Us0EleTzKA83NzfFLF9Z5Obm4r///kOHDh3KHU91wEIVqseZKiIiItKOP/74A8ePH8ewYcNK/Bpvb2/4+fnhwoULaNiwoeIrPzlr1aoVIiIiEBcXV+g1jEYjcnNzi71Xy5Yt0b59e3z++edYu3Ytxo0bV+I4XV1d4efnh927dyvad+/ejWbNmgEA/v33XwQEBOC1115D+/bt0ahRI0RHRyv6N23aFPv27VO07d27V/6+JJ9H06ZNcezYMcWSQfNrVLbVq1cjPj6+VD/n6owzVaqV9y9RAnMqIiIiUqnMzEzcuHEDubm5uHnzJrZu3Yp58+bhoYcewujRo0t1rfDwcDz77LNwc3NDv379kJmZiYMHDyI+Ph4zZ87E8OHD8c4772DIkCGYN28efH19ceTIEfj5+SE0NBSBgYGIiopCREQE6tSpAxcXl7uWcc8vWOHk5ISHH364VHG++OKLmDNnDho0aIA2bdpg5cqViIiIkCsYNmrUCJcuXcK6devQoUMH/PLLL/jhhx8U13juuecwZswYtG/fHl26dMGaNWtw8uRJRaGK4j6PESNG4LXXXsPEiRMxa9YsXLx4Ee+++26p3ktJpaWl4caNG8jJycGVK1fwww8/4P3338fkyZPRo0ePSrmn1nCmSq1YqIKIiIhUbuvWrfD19UVgYCD69euHnTt34sMPP8TmzZtLvUxtwoQJ+OKLL7By5Uq0bNkS3bp1w6pVq+SZGaPRiN9//x1eXl7o378/WrZsifnz58v3GTZsGPr164cePXrA09MT33zzzV3vNXz4cBgMBgwfPlyxJ6kknn32WcycORPPP/88WrZsia1bt+LHH3+UK/8NGjQIM2bMwNSpU9GmTRv8+++/eOONNxTXePzxx/HGG2/gpZdeQrt27RAdHW1VYKK4z8PZ2Rk//fQTjh8/juDgYLz22mtYsGBBqd5LSX3++efw9fVFgwYNMHToUJw6dQrr16+3KvF+LxMkiZUQ8iUlJcHNzQ2JiYmKzYQ2cXIT8F0Ysnw7wDDxd+h0zH9J3URRRExMDLy8vDheSfU4XklNMjIyEBUVhXr16hX6C36VFqq4R1y8eBENGjTAgQMH0LZtW1uHU61obbwW9eevNLkBl/+pHnNeIiIiooqQnZ2N27dv4/XXX0enTp2YUFGF4T/PqVV+Zs+JRCIiIqIKsXv3bvj6+uLAgQP45JNPbB0OVSOcqVIt7qkiIiIiqkjdu3cHd75QZeBMlVppYA0qERERERExqVI//msKERHRPYEzKERVr6L+3DGpUi3OVBEREd0L8kuCZ2Vl2TgSontP/p+70j4CwBL3VKkVn1NFRER0TzAYDHB0dERsbCzs7OysyvxrrUQ13du0NF5FUURsbCwcHR1hMJQvLWJSpVqs/kdERHQvEAQBvr6+iIqKQnR0tNV5SZIgiiJ0Op3qf0kl0tp41el0qFu3brljZVKlVhoYhERERFQxjEYjGjVqVOgSQFEUcfv2bdSsWZMPqybV09p4NRqNFRInkyrV40wVERHRvUCn08He3t6qXRRF2NnZwd7eXhO/pNK97V4dr/fOO9UcLv8jIiIiItICJlVqdWf5n8CZKiIiIiIiVdNMUhUYGAhBEKy+pkyZAiDvCdmW555++mkbR10e3FNFRERERKQFmtlTdeDAAeTm5srHJ06cQO/evfHoo4/KbRMnTsSbb74pHzs6OlZpjJWDM1VERERERGqmmaTK09NTcTx//nw0aNAA3bp1k9scHR3h4+NT1aFVjvzqf8ypiIiIiIhUTTNJlbmsrCx8/fXXmDlzpqKm/Jo1a/D111/Dx8cHAwcOxBtvvFHkbFVmZiYyMzPl46SkJAB5VUtEUay8N1ASknRnbaZk+1iISkAURfnZFERqx/FKWsLxSlpSncZrad6DJpOqTZs2ISEhAWPGjJHbRowYgYCAAPj5+eHYsWN4+eWXcfbsWWzcuPGu15k3bx7Cw8Ot2mNjY5GRkVEZoZeYMTERHgByc3IQFxNzT5WkJG0SRRGJiYmQJInjlVSP45W0hOOVtKQ6jdfk5OQS9xUkSXs1u/v27Quj0Yiffvrprn3++OMPPPDAAzh//jwaNGhQaJ/CZqr8/f0RHx8PV1fXCo+7VM7vgG7tI8iu2RTC5H80Pyip+hNFEbGxsfD09OR4JdXjeCUt4XglLalO4zUpKQk1atRAYmJisbmB5maqoqOjsX379iJnoAAgJCQEAIpMqkwmE0wmk1W7Tqez/SCQ7y+pIx6iEhAEgeOVNIPjlbSE45W0pLqM19LEr7l3unLlSnh5eWHAgAFF9ouIiAAA+Pr6VkFUlUDeK6a5iUQiIiIionuKpmaqRFHEypUrERYWBoOhIPTIyEisXbsW/fv3R82aNXHs2DHMmDEDXbt2RatWrWwYcXnkV/9jUkVEREREpGaaSqq2b9+OS5cuYdy4cYp2o9GI7du344MPPkBqair8/f0xbNgwvP766zaKtAIIfPgvEREREZEWaCqp6tOnDwqrq+Hv749du3bZICIiIiIiIrrXaW5P1b2Dy/+IiIiIiLSASZVasVAFEREREZEmMKlSLe6pIiIiIiLSAiZVKidwpoqIiIiISNWYVKmVwD1VRERERERawKRKtbinioiIiIhIC5hUqRWfU0VEREREpAlMqtSOy/+IiIiIiFSNSZVqcaaKiIiIiEgLmFSpFQtVEBERERFpApMq1WKhCiIiIiIiLWBSRUREREREVA5MqtRKKH6m6sy+37Fn1SvIzcmpmpiIiIiIiMiKwdYB0N0Uv6cqaMujAID9m73RcdiMqgiKiIiIiIgscKZKrUowU5VPjP2vcmMhIiIiIqK7YlKlWsqS6rduXML+De8hLSXRRvEQEREREVFhuPxPpSRIEABk54gwAUj/tC86Stew73oEQqZ9aevwiIiIiIjoDs5UqdSeC3EAgNtp2QAAf+kaAKDe7b9tFhMREREREVljUqVSl+PSAQCCxZ6qHIGTi0REREREasKkSqVEiz1VBe36Ko6EiIiIiIiKwqRK5ThTRURERESkbkyqVEq88/+W81W5TKqIiIiIiFSFSZVKSVJeOmU5UyUyqSIiIiIiUhUmVRrTKOc/xF67aOswiIiIiIjoDiZVKpU/P2U5UwUAt1YOr9pgiIiIiIjorphUqVRBUmWtafapqgyFiIiIiIiKwKRKpSQUvqeKiIiIiIjUhUmVSuUXqgCTKiIiIiIiVWNSpVJS4c/+JSIiIiIilWFSpXLMrYiIiIiI1I1JlUqJd3lOFRERERERqQuTKpUqqqQ6ERERERGpB5MqlZK48I+IiIiISBOYVKmUdGeGiqkVEREREZG6MalSKYl7qoiIiIiINIFJlUrx4b9ERERERNrApEqlmEoREREREWkDkyqVku5kVdxTRURERESkbkyqVKqg+h/nrIiIiIiI1IxJlUoVPKeKiIiIiIjUjEmVSrFQBRERERGRNjCpUinR1gEQEREREVGJMKlSK7lQBWeqiIiIiIjUTDNJ1dy5cyEIguIrKChIPp+RkYEpU6agZs2acHZ2xrBhw3Dz5k0bRlw+Bcv/iIiIiIhIzTSTVAFA8+bNcf36dfnrn3/+kc/NmDEDP/30E7777jvs2rUL165dw9ChQ20YbXlxTxURERERkRYYbB1AaRgMBvj4+Fi1JyYmYvny5Vi7di169uwJAFi5ciWaNm2KvXv3olOnToVeLzMzE5mZmfJxUlISAEAURYiibXc15ZrlUqIoWmW/5m0SJJvHSySKIiSJY5G0geOVtITjlbSkOo3X0rwHTSVV//33H/z8/GBvb4/Q0FDMmzcPdevWxaFDh5CdnY1evXrJfYOCglC3bl3s2bPnrknVvHnzEB4ebtUeGxuLjIyMSnsfJZGRkQ4gb6YqJiYGfhbnY2JikJ9e5mTnICYmpkrjI7IkiiISExMhSRJ0Ok1NgtM9iOOVtITjlbSkOo3X5OTkEvfVTFIVEhKCVatWoUmTJrh+/TrCw8Nx//3348SJE7hx4waMRiPc3d0Vr/H29saNGzfues1Zs2Zh5syZ8nFSUhL8/f3h6ekJV1fXynorJWI02QPIWwTo5eVldd68zWBnKLQPUVUSRRGCIMDT01Pz/xGl6o/jlbSE45W0pDqNV3t7+xL31UxS9eCDD8rft2rVCiEhIQgICMC3334LBweHMl3TZDLBZDJZtet0OtsPAiG/REXhWb55mwDB9vESARAEQR1/fohKgOOVtITjlbSkuozX0sSv2Xfq7u6Oxo0b4/z58/Dx8UFWVhYSEhIUfW7evFnoHiwtECXW/SMiIiIi0gLNJlUpKSmIjIyEr68v2rVrBzs7O+zYsUM+f/bsWVy6dAmhoaE2jLLs8utUsPofEREREZG6aWb53wsvvICBAwciICAA165dw5w5c6DX6zF8+HC4ublh/PjxmDlzJjw8PODq6opp06YhNDT0rkUq1M7HLW9JI+eriIiIiIjUTTNJ1ZUrVzB8+HDcvn0bnp6euO+++7B37154enoCAN5//33odDoMGzYMmZmZ6Nu3L5YuXWrjqMvuvka1gL2AIHCmioiIiIhIzTSTVK1bt67I8/b29vj444/x8ccfV1FElS1vZSaX/xERERERqZtm91RVewIX/hERERERaQGTKpXKz6mYWhERERERqRuTKtXKS6d0XP5HRERERKRqTKpUSuAcFRERERGRJjCpUivuqSIiIiIi0gQmVWplnlNJXAJIRERERKRWTKpUS5FV2SwKIiIiIiIqGpMqtTJf/seZKiIiIiIi1WJSpVrcU0VEREREpAVMqlRKWaeCM1VERERERGrFpEq1uPyPiIiIiEgLmFSplCCwUAURERERkRYwqVIpiTNVRERERESawKSKiIiIiIioHJhUqZSgM//RcKaKiIiIiEitmFSpFpf/ERERERFpAZMqlRLAQhVERERERFrApEqtBD78l4iIiIhIC5hUqZR5TpWbk227QIiIiIiIqEhMqjTgxnv32ToEIiIiIiK6CyZVKiUIBT8a/9wrNoyEiIiIiIiKwqRKpRQP/yUiIiIiItViUqVSxdWpkESxagIhIiIiIqIiMalSraKzKqmQZ1ddPH0Qkcf3VlZARERERERUCIOtA6C7KGaqyjKpysrMQOD6BwAA6fWvwMHJpdJCIyIiIiKiApypUq3S7amKj70qf5+ZnlrRwVQ4SRRx5fwJLmMkIiIiIs1jUqVSxe6pkpTJSGrCrYLX6vSVEVKF2rdmLup83QX7l020dShEREREROXCpEqtSrn8LztD/bNT5jpFLgYAhMRusHEkRERERETlw6RKpcyfU1WYwgpVFJzkkjoiIiIioqrCpEqtilv/V4QiEy4iIiIiIqpQTKpUSii2pLpyNkrQ6czOMakiIiIiIqoqTKo0qqjEyTLhIiIiIiKiysOkSqUEXbHl/4o4xZkqIiIiIqKqwqRKoywTJ/PnPTGpIiIiIiKqOkyqVKq4PVWWJBQkUtdXjuZDdYmIiIiIqgiTKo0qat9Uy8zDuHByfxVGY+3A5qWI2P6NTWMgIiIiIqoKTKpUqriK6sc2f6BssFjyl55ws2IDKoXr0WfR4cgstPnnaZvFQERERERUVZhUaVSn/94r8nx2WgIkUcTer2bj+F8/VFFUeVLiY6r0fkREREREtmSwdQBUuFI/+tdipkrMycaxPzegU+RiIBJA14crKjQiIiIiIjLDmarqwrLinyAgI/aCzWNhwQwiIiIiqu6YVKlVqaeq1Mm8vPv5o/8gMS7WhtEQEREREVU8JlXVhHlJ9YJGGz2vyqzKhijmAgBO7v4FDX8YAPHDtraJiYiIiIiokmgmqZo3bx46dOgAFxcXeHl5YciQITh79qyiT/fu3SEIguLr6ae1WYGu1M+pskqgbPijNYtFvLP8L/nYTwCAGkiySUhERERERJWlTL95h4WF4a+//qroWIq0a9cuTJkyBXv37sW2bduQnZ2NPn36IDU1VdFv4sSJuH79uvy1cOHCKo1TVYqry14F8p+nJRlMNo6EiIiIiKhylKn6X2JiInr16oWAgACMHTsWYWFhqF27dkXHprB161bF8apVq+Dl5YVDhw6ha9eucrujoyN8fHwqNRZVstVSv8KYJXNyoQq9sdSXSbh1A4m3byCgSZsKCoyIiIiIqOKVKanatGkTYmNj8dVXX2H16tWYM2cOevXqhfHjx2Pw4MGws7Or6DitJCYmAgA8PDwU7WvWrMHXX38NHx8fDBw4EG+88QYcHR0LvUZmZiYyMzPl46SkvKVpoijKy9ZsJX+Gp0R9UdjyP1HRVpXvx/xeOTnZecc6O8V53V36m3Nf0gTuAC6N+At1GrasnGCpwohi3piz9Z8dopLgeCUt4XglLalO47U076HMz6ny9PTEzJkzMXPmTBw+fBgrV67EqFGj4OzsjCeffBLPPPMMGjVqVNbLF0kURUyfPh1dunRBixYt5PYRI0YgICAAfn5+OHbsGF5++WWcPXsWGzduLPQ68+bNQ3h4uFV7bGwsMjIyKiX2kopLy4ZXCftmZ2cjOVm5VyktLQOi2XuIiam6B/ImJxXEEhsbC4e0TGTmFpyPiYmB+VyieWzpqUlwcHIFALlP1IGtMLp6V2LEVBFEUURiYiIkSYJOp5ntmnSP4nglLeF4JS2pTuM1OTm5xH3L/fDf69evY9u2bdi2bRv0ej369++P48ePo1mzZli4cCFmzJhR3ltYmTJlCk6cOIF//vlH0T5p0iT5+5YtW8LX1xcPPPAAIiMj0aBBA6vrzJo1CzNnzpSPk5KS4O/vD09PT7i6ulZ43KWhT8ksvtMdrmnRMDg5KdocHe2RnW0vH3t5lTRFK7/EawWfnYeHB1zcPHDRoWC20DKW/ON9X0xH6LXVON5zNZrfN0g+7+BgX6XxU9mIoghBEODp6an5/4hS9cfxSlrC8UpaUp3Gq729ffGd7ihTUpWdnY0ff/wRK1euxO+//45WrVph+vTpGDFihJyM/PDDDxg3blyFJ1VTp07Fzz//jL/++gt16tQpsm9ISAgA4Pz584UmVSaTCSaTdQEFnU5n80FQmvu3Sd+Ho7utq/8JuoK9TVX5fnQWBTJ0Op1in5VlLPnHoddWAwBc/nwDuq5DCjoIgs1/HlQywp2fFX9epAUcr6QlHK+kJdVlvJYm/jIlVb6+vhBFEcOHD8f+/fvRpk0bqz49evSAu7t7WS5fKEmSMG3aNPzwww/4888/Ua9evWJfExERIcerNUIpK/e1Tt9v8Xqoo3hFGWIwSNmVEAgRERERUeUoU1L1/vvv49FHHy1ySszd3R1RUVFlDszSlClTsHbtWmzevBkuLi64ceMGAMDNzQ0ODg6IjIzE2rVr0b9/f9SsWRPHjh3DjBkz0LVrV7Rq1arC4qDSkcRcJCfGodPZkpe2N0g5Fi22Lw1PRERERHQ3ZZqT27lzJ7KzrWcTUlNTMW7cuHIHVZhly5YhMTER3bt3h6+vr/y1fv16AIDRaMT27dvRp08fBAUF4fnnn8ewYcPw008/VUo8la26pBGimIvTq58ttp9kVl3FAM5UEREREZF2lGmmavXq1Zg/fz5cXFwU7enp6fjyyy+xYsWKCgnOnHXJcCV/f3/s2rWrwu9LpWf+s5IkCTWSzijPi6JV0rh/SRhC7nxvZFJFRERERBpSqqQqKSkJkiRBkiQkJycrlv/l5ubi119/ZZW2ClLKLVWVcIGyk8SC+umSJFrtq5IkySqpCon7Uf5eL+WCiIiIiEgrSpVUubu7QxAECIKAxo0bW50XBKHQ5z5R6QkaXgAowWymqpCHphU362idchERERERqVepkqqdO3dCkiT07NkT33//PTw8PORzRqNRfvAulZ9gsdstVbKHk2DbBxKXmFkiJUmS1ayZKOZCX8TLVVCzkIiIiIioxEqVVHXr1g0AEBUVhbp165a67DeVnEGn/GxzLbOsYtjyZyNJBUmVKFov5StupoqIiIiISEtKnFQdO3YMLVq0gE6nQ2JiIo4fP37XvixhXn6WD9A1FwMPeCGuCqMpHfMlf5KYa7WczzzpIiIiIiLSuhInVW3atMGNGzfg5eWFNm3aQBCEQmccBEFAbi4LDZSX3mKmSpAkuc66oPIFcsrqf4WcL2SfVWF9OA9KRERERFpQ4qQqKioKnp6e8vdUufRFzFSpMana8/l01IjZh8AZ2yCZVe8rU6EKQYAoivK+Ky4zJSIiIiI1K3FSFRAQUOj3VDl0ljNVpXx9Ve9bCr26EgCw7+dlcPItqAwpFbqnqviZquKKWRARERERqUXpqh/csXr1avzyyy/y8UsvvQR3d3d07twZ0dHRFRYcFa5EM1U2KgYhJV1X3FqCZLWnSizB8r/CClwQEREREalRmZKqd955Bw4ODgCAPXv2YMmSJVi4cCFq1aqFGTNmVGiAZE1XhuV/JdnHVCGyUwHF8r+yVf+rsniJiIiIiMqpVCXV812+fBkNGzYEAGzatAmPPPIIJk2ahC5duqB79+4VGR/doZydKkFSYtFFFEXodWXKoa0c/+sHZO9fgYBRy1DTu471vRXV/0q/pwoQOFNFRERERJpRpt+ynZ2dcfv2bQDA77//jt69ewMA7O3tkZ6eXnHRUaFKsvxPzEpDrf++lY8rsox5yz/GoG3KX4j6+tnCozO/lyTBckdYSWahSrJEkIiIiIhIDco0U9W7d29MmDABwcHBOHfuHPr37w8AOHnyJAIDAysyPrrDPJEqSVJV++gH8JNi5OPKKFzhlHHjLmfMHv5bWDJXokIVTKqIiIiISBvKNFP18ccfIzQ0FLGxsfj+++9Rs2ZNAMChQ4cwfPjwCg2QrJWkEqB5QgVUVuGHwhM1STR7TlUJlv/tWf6CdZ/cnHLGRkRERERUNco0U+Xu7o4lS5ZYtYeHh5c7ICqJMhSquJPIXDl/Akmxl9Es9MEKi0bMzVVk5+bFKW5HHoKrZX+LBC/08ufKWMGZKiIiIiLSjjIlVQCQkJCA/fv3IyYmRvELsCAIGDVqVIUER4UTJKnUD67KnzGq83UXAECU23bUa9ahvJEgNycHl95pi3p36dHhyCwkwkkZSwmWIrJQBRERERFpRZmSqp9++gkjR45ESkoKXF1dIQgFv+Ezqap8ZSqpbrGP6fb5QxWQVAHxt66hnmj2bDJBpyipDgBuSLWIpSTVC80qCNromVtERERERCVRpj1Vzz//PMaNG4eUlBQkJCQgPj5e/oqLi6voGAmlL1RhSZIkZGakVWRIACRAtI6l2Op+JVjaZ34NQRIhiSL2rZuH/95qh73fvFPqSImIiIiIKkuZkqqrV6/i2WefhaOjY0XHQ3dRltkpc6Io4tiyMLOWipn9kQq5TnHl2wt7jfK88jlVkiTixD+bEXJmPhrlnkenswuQkZ5axBWIiIiIiKpOmZKqvn374uDBgxUdCxXBfHZKh9IXcTi9/Ut0SPy9IkMCYL00TxIE6ycPF/OaQvtYPEA4Pfai4nxSXF51w9wcVgkkIiIiItsq056qAQMG4MUXX8SpU6fQsmVL2NnZKc4PGjSoQoIjc+bL/0qv4/E5FReKmcIKShQ3UxW5/Qt4FXE+b6bK/AHCIizz/9SEGNwQc+G4/H6c8h6MTpM/KUXUlS/mahQit3+BoP5TUcPT19bhEBEREVElKlNSNXHiRADAm2++aXVOEATk5rJyW0UTFN+Xf+lehRV/KOw6xeyZCo2yLsdvLhd6SKLZDJQkwjKVFEUJ0Zv/hxCkodPNbwCoK6lKWz4QoeJlHFu+DzVe2W7rcIiIiIioEpVp+Z8oinf9YkJVOZSJVMVVw/sv4m8cWvQwrkWduWuf3Jwc5GRnFXrOelZKV+74cmCwmqkyrzCZ16TucRYoXgYAtMo4YONIiIiIiKiylSmpMpeRkVERcVAxhHIu/7Pkenw1zuz7HY02PYR2yX8g7esRhfaTRBGX3mmLuP81QXZWpuJc0+xTSIm7WehrykMU9IqkKeTMfOQkXFXeQxLvzGAREREREdlWmZKq3NxcvPXWW6hduzacnZ1x4cIFAMAbb7yB5cuXV2iAlKeil/81yTmDoC2Pysd+OVcK7SdJEuqJ0fBCHK5dOGl1vtbmkVZtxrObyxVbLvTIzlQm66GXPlXGVc7ErTKoMSYiIiIiqnxlSqr+97//YdWqVVi4cCGMRqPc3qJFC3zxxRcVFhwV0Anm1f8q/mG4jkImju78Dgc2LkbEgr44/NtXkEQRubnme5us71sDSYrjete3oHX6vnLH0+D7vkWet+XyPzE3F/s/GI593y6U26LPRiD+zQDs/fruBUFuXYvG0T/WyclXxI51OLB5aaXHS0RERESVq0xJ1ZdffonPPvsMI0eOhF6vl9tbt26NM2fuvjeHKoZ5glWRWu+agA7HZqNN+l603TMVR9/tr6juF3N2b7HX8EFsuePwl64V26e4Z11VpmM7v0XHhF8Rcup/clvc5lfhgSR0Ov/BXV+n++w+tP7rKRz6OW/Wrc3fT6HDkVm4dvFsZYdMRERERJWozA//bdiwoVW7KIrIzs4ud1CkDm3S9iiWtHWIeLVK7psuGYvvZMOldtkpcVZtor7wmEWpYOGmx51ZPf2ZnyCaFXRJibtRwRESERERUVUqU1LVrFkz/P3331btGzZsQHBwcLmDIvVQLP+rIplC8UlVcc/Cqmq5BscS9zXkpiE7O7P4jkRERESkCWV6TtXs2bMRFhaGq1evQhRFbNy4EWfPnsWXX36Jn3/+uaJjJBtKXtQOTmbHe9e8iU6VfM+SFOJQX1GIwmsy5r+T2zevoOad7w1iFrKzMmHKf6VQEfUciYiIiMhWyjRTNXjwYPz000/Yvn07nJycMHv2bJw+fRo//fQTevfuXdExkg354JbiuNN/iyr9niVJMSrs4cVlorz3rRuX0TG+6H9MSP20T8GrBR1yzMvTM6kiIiIi0rQyzVQBwP33349t27ZVZCxUTaVJJjgKFbvcTZLU8fBfSRQR+d3rqHW383dSxLriVbM2KJIqtT/ImIiIiIiKVqaZqvr16+P27dtW7QkJCahfv365g6LqRaqQxxVbqOLlf9GnD+Hc4T+t2rOzs9Du1o93fZ1BEJGVafmAbAHZ2QVtYnZWBUVJRERERLZQppmqixcvIjfX+l/XMzMzcfXq1UJeQfey0j+suPj+6XFXEXJ7k1X7ns+mQZ92Cx2eXQNBV6Z/MyhUwPqeAIDLLn8plh7mZGfCAB2Auyd5Z9/rh5aKFgE5ZolUbk5Bxcwjv62Gk2cAGrftXjGBExEREVGlK1VS9eOPBf8i/9tvv8HNzU0+zs3NxY4dOxAYGFhhwVH1oC8i4SirDkdmKY73rnoVOudaCL32JQAg+uwRBDRtV6ZrR585jJsnd6H9kGehM3sOGwBcP7YT0BW0nfv4MTQtZiauZeYRxbEkCMg1q/4n5mTeiTkCwXuezWtsm5jXVxQrNDkkIiIioopXqqRqyJAhAPKqlYWFhSnO2dnZITAwEIsWVX4hA9IWXSmTKp0klaxahZlOFz9WHCfFXgLuJFWZGWkw2Ze85HnAuh4IAHBA0KHD0OeQlHAbrooeBTNVbdL3WsUqiWKR4UsQFHuqcnOycOX8CQR8060g/oTbiL9+ES7rh+Bc40noNOKNEsdPRERERFWrVP8ELooiRFFE3bp1ERMTIx+LoojMzEycPXsWDz30UGXFShpV2qRKj/IXbgjcMRkAsGfFizDN98WZA9tLfQ3pygFIogjXD8z2Cep0QDHP7iru2V45egfFTFWbv5/CtV/nK/qkpyQgedNMeCAJnc69W+rYq4L6ytoTERER2UaZ1hVFRUWhVq271TsjUtILpdtTVRHLBV2EdERsW4vQS58BAHS/FSwXFC32A0adOoDL549bXaPl7d9w/ug/Fq0CpNyiC0vkmO2RKkyu3gG5OcprdIz7SdknOxt6sejr2NK+795Fwpt18V+E8iHgTLSIiIjoXlTmkuo7duzAjh075BkrcytWrCh3YHTvKu3M1t202T1Z/r5xzjkcXdAbrdP355WVkAQcavsOGt//KOp92wsAkPHSVdg7OsuvcRCyYPfTFMU1BUGAmFt0snNk7WyEFtVBEJCTnlLkNXKLuUdlE3NzFfvJbt24hMgNc+DZ/WnUbxGCkJNvAQDifnoWaJO3Z2z/sokIjN2JuKd3oaZXbRz64FGIehM6PrfWJu+BiIiIqKqUaaYqPDwcffr0wY4dO3Dr1i3Ex8crvojKwyBUzmxH6/T98vc6QUKHI7Pg9mFDuc1+YW1cizqjeE2geElxLGalo8m5T4u8T+jlL4o8b8xKRKtd44vsY8sy67duXEL8W/Wwd+kkuS1q3UsIubUR9Tf0UfTVSwVLHTvFboAPbuO/nxbh5pVItE/ajo7xvyA1OaGqQiciIiKyiTLNVH3yySdYtWoVRo0aVdHxENmU3+qQIs83OvUhaiC5XPdolXGg2D55+7IKlk2e/PdX1GvVBUc3zINjQDu07vFouWIoyn8/votQJKJmzHoAnyEzIw0t4ncUWjwkULyEuJirOL/uZXS80yZkJiIzreAzSktOgJOLOwDg4I+fwKN+MOq3KPpzJiIiItKSMiVVWVlZ6Ny5c0XHQqR6HkiqkvvEnvoLIdmn5OPmvw/Hsb86IDTjAHAR2HfzPEKemIXjuzYi7dgmtBr3MRycXEp07ZzsLKQmJ8LNwxNA3j6og4uHI9e+BkKeWgpBLJh92vv1XEhptxEq3H3mLOmTfuhoPqMn6JGeHCcfRm56By5j3sOxzyehY/wvwGEALRJx6VwEkjc8C6nrC2hx36CSfTBEREREKlSm5X8TJkzA2rXq3Sfx8ccfIzAwEPb29ggJCcH+/fuLfxGRioScetuqzXyGK+TMfBzeshItd45FyO3NkBY2wJXzJ7D/hw+x57NncfDnz3D75hXExVzF4d++wol/fsStG3mJz7mFPeD2YUPs/XgC0lOT8d87IeiQuBWdbn6DCyf2Ku7Z6fz78rO/7sZyiaRkMCEz+VbBNWLW48Sy0XkJ1R0Z6anI+HYimmcdRYvt6pjxzsrMkL+/fP449n23SPGQ5svnj+PswT/k42tRZ3D75pUqjZGIiIjUqUwzVRkZGfjss8+wfft2tGrVCnZ2dorz7733XoUEVxbr16/HzJkz8cknnyAkJAQffPAB+vbti7Nnz8LLy8tmcVH1lSaZ4ChkFt+xCNmSHnZC6UrJt903Xf7eUciE49ddUCe/4RqAgy8CADzy2+5UlW9257BT7Hc48eF/aJFzTr5O4rVz6HRjTZH3PbDpY3Qo4ryQlQrvv15TtLVP3qE4zkhNRv3s8/KSwr1r3oRLYDs03zYCGZIdrj++BfWadUDk8b2Iv3gU7Qc+VWRMxcm+81wwO6MJyYlxOLt8EoQm/dCs++Mw2Tti//p56HTu/7Cv+WyEPPo8PL7qBX8hA1GnV8Nj6g5cOvEPWv4xBgBw3u5XuNbyg9/qEGRJelwN243a9Zsi8fZNnFn3KpxaD0aL+wYhKzMDp3f/iKZdBsFosi9X/ERERKRugiRJpat3DaBHjx5Fnt+5c2eZAyqvkJAQdOjQAUuWLAGQ92wtf39/TJs2Da+88kqRr01KSoKbmxsSExPh6upaZN8qMdfN1hFQCeRIunIX18iSDDAKRT/fqjrZ5zEIIXE/FtknSheAemJ0qa6bIjnAWUgvuE/TVxFy+h35+HjPVQjaMV5OYNMlI47X7KsoaX9tzH74reooHx91CEHr9H3y8R6/0dBlJiHk9ia5bW+Tl9Dp7EL5OP3FK7j23v1okBsFADjxwJfQ2ZnQbOvjSIAzYgatRa06DXHu98+gjz0NU5vHENC6G25ePImkK6fh6BkIl1p+yMnKQGZ6CgQIcHD1gJ3JAenJCUhLjIFLLX/4Bgbh1vVoXDnyO5x9G6Fpxz5IT0vG0e/y3nPDvpNhcnTByR8/gCHuP/gPexs+/g1xYPNS+EYsxhWvHmgT9i4untqHtD8/QKZLXXQY9z5ysrNwdMU0uCaehdD3LdRv2QUn/vwOmVePwbvjI6jfIgSJcbE499d6OPk0RJP2vZCdlYGk+FikJ8ejbuM2AIC01CTkZGfLS03F3FxkZabDaHKATq+HdOc5hzpdwaIJSZIgCAIEs7ac7Czo9Qa5LSMtBQY7Iwx2xrzXiCKS4mPhVtM773x6KlLib8Hk5AIXNw9Iooj0tGQY7ExygnvzygUkJafCP7AB7B3yHg6empwARydXxb2J1EAURcTExMDLy0vx54VIjarTeC1NblCmpEqtsrKy4OjoiA0bNmDIkCFye1hYGBISErB582ZF/8zMTGRmFswwJCUlwd/fH/Hx8apIqnRv1rB1CEREqiZKAnR3noVX2IxvDDxQS4qX+1wSasNeSocXCvb9xaIGXKUUmIS8RxmkSA6wRybSBAeIhVVoISKiSndz0Fo0anO/TWNISkpCjRo1SpRUlWr539ChQ4vtIwgCvv/++9JctsLcunULubm58Pb2VrR7e3vjzJkzVv3nzZuH8PBwq/bY2FhkZGRYtVc1H1sHQEWqiBkqIiofndnDxQtbQuuFOEXlyrrSVas+nohX9Mmf7XRFasUFSkREpXIuPg4xMTE2jSE5ueQVn0uVVLm5Va/laLNmzcLMmTPl4/yZKk9PT1XMVJG6pQn2cEWarcOoNFcEH9SRbpTrGpmSnfyv/7a0t+bD6HT7B/n4vL4B6uVcgN7sF/IDwfPQ4cgs+figywOKvWB76k1FaNQSxXX31RiIkPiCpYMXHt2G+t/1lo+PdFkKr3/DUVu6mXeNuk/DzrMB2h/K2+922q4ZEmr3gN+lzQgQr+CsoQnia7SCKfUaXDJvIEPvgjQHH0Cnh0PaNQBAmmMdiM4+MMb/B6/Uc4hxagKh1SPIvHIMwdErEKvzxK0ucyCJOWj77xQ59sAeY5D05ZNoknMGJ40t4TVmLS5seB0hcZtxXt8ApuGrcePk32h+eC4chUzsb/UWPINCkfDzbASlHkREw8lo1Hsizm98Cy4Jp5Hs2hD1hryB62cPwLj3Q6Q41YXbfRNh5+CMm/+uhS49DsZmD8LepSZSbkZCEPTQO7jAYHJCdmo8IOhgdHRDdkYyxOxMCHo7mFw9kZVyG3qTI3LSU2AwOSE3JxMuXoHIyUpDevwNQNDBuVYdiDnZyEpPgZSbAze/BjAY7BBz4RhyUuNgcPJAnWahiLsWiYSLEbCv6Q+vBm0g5mTj9qUzEMUc1KgThLSMbOQmXUdOZioc3L3g4dsAibGXkXL7KkxO7rB3qQFBKHgINpGtSJKIhMQkuLu5QhC0vZyKqr+KGq8t/BvC3tG5AiMrPXv7ku+JvqeX/1ninqqKdR2e8EWsrcOoNLfgjlpIsHUYFSJy2G9o8H3fIvvs8RtdZCXAQ87d0S7lT0XbZcEP/tI1+fjG+EPwWd5OPj7Y4V20P/BCwT0Cnkbj/tOQ+mkf1BWv4vzDv6Bh6/tw+fxxiLm5cKvpA/dad5/DlURRsR8m8vheuHh4w6t2PaSlJOL4qunQ1+2I9oMm49a1aOR+1gPeuI3jPb9Ey66DkTjXD25IxTH7Dmjx4m848v5Q+T1dfvIfZKQkoNGmhwDk7b1ydq+FC5+OQJv0vdjf+i10fPhZRJ85jJitCxHw6Dx41a4HoGAvka3/cqAC1WnNP1V/HK+kJdVpvN6ze6qAvEIVHTt2xEcffQQg7wdbt25dTJ06lYUqqtg1wQt+km2nbSvTNcEbfndmICpKsuQAF7NCC5bSJBN0EGFvNvtjXljhJmrigu8ACLkZMKbeQLaDJ5zbPoKa/o0RvektNL69A+dbvYgG9z0Cj6XN5GuIb8Qh+01veVbprCEITXIslszOTVSMyX2ejyAkdoN8vMdnJETftuhy5Hm57ZBLD7RLLihcI82Oh2C+V3BuIhLjb+HUj+9D0OkR/OgrMNk7lvDTqnhXL5xE7IVjaNNruNx2+fxx5GSmoV7zvAcWH/rlC7jVCULD1vfZKkyqANXpL32q/jheSUuq03gtTW5QppLqajZz5kyEhYWhffv26NixIz744AOkpqZi7Nixtg7tHlR9NniftmuGpmYP4wWALMEIVPA/SZyu0QMdE36Vj490/hjBd5ZwAUAudLjU/2sEbXkUALCv2esICWyC1Oej4eDoAm+9Ht5WV83jM201AMjl0KXZ8Ti4+AnkutRBJ70eEbX6I+R23myu37QtOPrJE4qqd5bqDXkd+LwgqYLeCL19wUzMwbYL4NmoA7C+IKkSdDrsbzEHHU+EY2/D6egEwK1GLYSG/a8En07lq12/OWrXb65o82/YUnHcbsCEqgyJiIiINKDaJVWPP/44YmNjMXv2bNy4cQNt2rTB1q1brYpXUOWrTlWzhN5vAr8+omjLFUr3x+e8vgEa5kYq2i7oAlFfvFhwn8D7gIiCpMrRw0/R/4qxPpqG9AFCEgEAIXfanVzcSxULkJfgdJjxrXwcNHIRjnwRC6nV42jr5oHWL/8uz0wlwgnm86ZRugAE+gYoL2h0gsHkJB/WbNgOAU3bIeOlqzjy1ctwbzMITQF0fGQmYjsPRYhP3VLHTERERKRG2p6Tu4upU6ciOjoamZmZ2LdvH0JCQop/EVUC2yRVCSj/vpU9dZUPm7VzcLHqk6lX3ueksVWR18wV7KzabtburTj2b9tHcZyTlYF9TQuKJ9QYtbrIe5SHm4cngl/agrb9xshtV0fvxX73/kh4/CdF3zSDW97epbmJOGlsiSQ4omHvp6DTFySavvXylhfaOzoj9KmP0TSkYM+Wp18gnwVERERE1QZ/q6FKI1VBUrWv5hCrtgwoK7Xs8Quz6pMrFcS2t/6zONH7a8V5weigODYYldfcV3MIsvXKPmkOylmlA8HzFMeioMcN1Co479YP0Ctnu4z2jkiWCq7r27A1Qh5/5c5+pkT41G1k9V4qU+36TdFx+jcIaJpXXOKgay8AgNT1RblPkxf/gOGFM6jpUwc+DVrhoEtP7KkzDvYOToVek4iIiKi6qXbL/0g9JEGo8D1HlvQBnYDbmxRtgsVN24UtxIUFu6BHLhLuex2tez4BPYCM9FREn9yHjsHdoNPrcThlCdrumYpoXR3onb0U17Az2iMJjnIJddGxFsR0ZRGOesPfBT7ZKh+36jsGMCvRLQp6xPX7GD5bHwcASDoDoFPOXpkcnJBtVsLZw6t2qT6Pyhb87HrExlxBC79Auc1gZ4TBzghRFKHT6dF2xvea35hKREREVBpMqqjSSBUwEVpcNTyU4PkHRpM96r1+BIJOB/NdQPYOTmjSvqd8HNx7JM551oVfw1ao7eCE7CNvyA8T1RkMOOU9GJ1ufgMA0KfcgClH+UC4Wj7+ijLrBoNRcV4SdLAzmwGTdAYYbisr7Dk4uiBdxX8s9QYDPM0SKiIiIiLi8j+qRBWx/O9U0+cUx3t9RiqOBZ31gzkv1B0mf3/x8R13+hU/1AWdDo3bdoOzaw0Y7IxIm35OPqfT6QEpVz7WZ6egWdZx62uYzZLpDcrkSBQM0BsKZqYknR0MzQcr+uj0ekQ2nwYAOOCm3F9FREREROrEpIoqTXmTqtN2zWBw8VS0CR71lMeFJFUdRv0Px3usRMrMiwhs2r7M93dxrYFbcEc8XK2X4TUbVOrrSYIeOrOkCiZXBPd5Uj68BXcAQMdhM3Hx8R0InrqmLGETERERURVjUkUVYp+HdZJR/pkqwSpp0lkUkIDOeqmcwc6Ilt2Gwtm1htW50tDp9XCddRaOr5yFwc4ImO11attvLKJ1daxfU8QmMlHQK2aq4FQTALAn4GlEOIbC/bX/AOTNmAU2bZ93TyIiIiJSPSZVVCH0gV2s2rJ1piJf85++YZHnJUFntWxPZ6eswicIysRtr9djRV6ztIwme5jsHfPi0RckRIJOh8T7w636O0p33/8lCXroDQWfieFOUhU6dgHavLSVSRQRERGRRjGpojKJ1NdXNuitl+HFe7Qu8hrGRz4r8rwEQTE7BFgnVTlpiYrjDpOWFXnNcrFzVBzWqGNd3twkZN/15aLeHnq7gsTMztmj4mIjIiIiIpthUqVhN1Gzyu6Vv98nX3oP5SyNYFGFb6/38OIr8xWyH8qcJOggWDzHSWennP0SszNwpv8GAMC+oFesikNUpGZDXkS0zh976owDAPg3ao1E5D2LyfLzKYzUoKdiNsrkwqSKiIiIqDpQb+1mKlZVPFz3bgwWM0aF5+fK+CzLowslCN8yWdNblinPyURQx95Ax0SEFH+5cnGrUQtus08oyrIbXzyLfb98gsDOQxV9syU97ACcfvBbNN3yGI44dkb7gU8jMa7g2Vb2zu6VHDERERERVQUmVSq21+txdIpZX0SP4rOSHEkHgyAq2qJ1dRAgXilfcBZ7nQSdRSyFzFLF6WvCxey+lkUoREmATigo9CBBZ9XH6OSmvGhuZmmirnAOTi4IeexFq/Ys2MEOQNOQvkBIIoLvtJu/H5OjS9UESURERESVisv/VKz9xI+L7bOv6awizx8ImGjVlmD0LXUsgmVVO4tpJsuCEZKgh2SxHypLp6zcJ1gkhVkWOX5eoQplm3MNH8Wxwd2i1LlKZAuF/3uFo7Or/L2Ht39VhUNERERElYgzVSqmK6T4gzkJKHbfkmByqriAzOXmFn1ekP+n4CUWw81yFipLsIM9Cgo9SBCg01tU/9Prcc7QGI1z8h7MG9xvXOniriI5d/mjZWc0IXbSUQCAp71joX2IiIiISFs4U6V5xS0BLH6JYOTQLYrja2P2I/qJnYq26yblQ3dFSbmkULIcSoLOKuETLWadLGe3rBIRQQfBYrbLYDRBREFbZRamKI9Yu7vPoHn6BcLTL7DqgiEiIiKiSsWkSsMkQSi+2kMJqkHUb9EJZ+ya4ZRdCyQ+Fwm/wCYICGqLPbXHAAD2+E+Ed9hq5b0tZqosEyRAsCoyIVokSJb7sESL4Zg3U6V8jZ3J0eo6anKyzzeIcAyF28iVtg6FiIiIiKqIOv+Zn0pIQEXMVAk6HZrM2i1/n6/T+Pdx9eIkdApsavUQXknMUV7DIoESBB0kq6TKcqaq6Jw+b0+VMoEymeytrqsmzTv3Bzr3t3UYRERERFSF1PvbKZVJhGOosqEkdcuRl0xZJk6CTofa9ZvL7fnPZwIASSx6T5VUyPI/y8IVlrFZl4i3nu0ymhxUnVQRERER0b2Hv51qmATrZXcZtTsX+zrzV+xr9lqJ72eo1bDg3qJyT5VV8lbI0kTLmSqdxSyUZVIlCTroLB/+q9cj2bNtiWMmIiIiIqpsTKo0TEIhe6osEhXkZqMoIY+9VOL7tX3oKeypOwknen0FSbJY/lfIc6osi0xIxRSqkCBYlIgXkJ2ZZhVH8Ii3sDdwCi488nuJYyciIiIiqixMqjTP4nlRlrM/xSzTKw29wYDQcf+HFvcNgpRrMVMFHa4IZs+QEoS8QhpmcgzK8u5W+7QgILDLo4prZCbdkg9vwR0AYO/ojE5j3kH9FiFlfi9ERERERBWFSZWmFbJfynLfUm6WVRenAW9DlATs8Qsr852D7hts1XbrvnCzyHTW1f9MbpbBKo4kCIolgZKgQ/0O/eTj84EjyxwvEREREVFlYfU/jbNcQidY7EGCRZU+AGjQshOym9xEqNFU5vvaO1g8VFgQIJjn6BkJgFMtRRfvrmOB776Rj3WWM1WCoJi9kqCDW41aZseWs2NERERERLbHmSoNk2C9xK6ke6rsypFQFUYQdIr9XY4J56yq/9VrHoJLutrK15iRLKv9Wb43Saq4gImIiIiIKgiTKs2zmKmyfMBuITNVFeW/wT+Z3VdQJD32OYlWSRUAJNl5Kl9jJi+pKmizKp3OpIqIiIiIVIhJVTVjWagCkrJQRZQusMLu1Si4q/y93uQImC3PM4oZhSZV5qxitdxTpTNanGdSRURERETqw6RKwyRBKH5PlcXsjsuknys0hj11n8JB115o2rGP4lZ2UmaxSVVhD/81T7QkvUVSxZkqIiIiIlIhFqrQvKJLqkNSFneoUcu3Qu8eOm5hoe2Jdl5WJdMtFVuoQmenOO9Yr2MZoyQiIiIiqjycqdIwqbCS6pYP2LVIqvSGSsyjzWaSXB79uPjlf4XMVJknWpI+L6m6NGIXDnX8AK26P1KBwRIRERERVQwmVZomWC2h01ntU7LNkjnvuk0g5WQW2cdqpsoiqcKd5X91G7dBu/5ji535IiIiIiKyBf6WqnHWe6osK+ZV4bOdzGaqdDodPCM3FtndsqR6ht5F0SbYWz4smIiIiIhIfZhUaVheCmO5p8rOqtcx+3YAgL2NX6zceMwSOL3eAJfcBKs+5ssRDXbKQhSp9j6K2Sidk0fFB0lEREREVMFYqKKaEXTW1f8aP/cTzp0+gI6t76/COHSIqtkVXrc3Kdp1ZiXeDQZlAhgw/APF8kWd0aFSYyQiIiIiqgicqdK0QvZUWZRUFyDB3sEJjdt2h05vud+qYkkWJc+9Hphq1cd8pspyj1QtvwDFnipBYM5PREREROrHpErDpEKSKqtiDlW5p8qCXSEzTTrkFtLT7LzZTJWgK6S6IRERERGRyjCp0jrLmSqLJXVV+cBcAcoEzjyWY91X5LVJRSdV5oU3rJYyEhERERGpEJMqTbOeydHplUmV5XOqKpPl8j/zZ2L5Ns4rlqEvLqkyX/5nVR6eiIiIiEh9mFRpmARAQNF7qqr0OVVWSVVBgpefLBW3/M8ckyoiIiIi0gImVVpnsfzPfHYIqOqZKuWxYn/UnedPFbf8zxyTKiIiIiLSAiZVGiYJAix/hJbL/6pypsqhho/i2PxBvvlLA41SpqJPEhzvej3uqSIiIiIiLeBvrdWMLQtVNA3piz1nnobROwjtAEV59PzkzgHpitfkFjEEWf2PiIiIiLSASZXGWaz+g85idse1x7NVF4tOh9CxC+Rjk6Oz/L2DkysAwElKV9TXyC5iCHrVa1nxQRIRERERVTAmVVpn9fBf5XLAxm27V2EwSvYOTjjTfwMkSURTF3cAgF5Qzpyl6ZwBMU7RdvnJf5CeFIfGtetVVahERERERGXGpKqaUVtxh6COvYs8Lz2yApc2hCG23Uy0u9Pm35AzVERERESkHZooVHHx4kWMHz8e9erVg4ODAxo0aIA5c+YgKytL0UcQBKuvvXv32jDyyiVIkuJhuYCy4p4W1GvWAXVnn0K7ARNsHQoRERERUZloYqbqzJkzEEURn376KRo2bIgTJ05g4sSJSE1Nxbvvvqvou337djRv3lw+rlmzZlWHW6Ukq+p/2kqqiIiIiIi0ThNJVb9+/dCvXz/5uH79+jh79iyWLVtmlVTVrFkTPj4+lpcoVGZmJjIzC0p8JyUlAQBEUYQoVt3zne5GFMUipxIlyyoVsC6grob3Yc78/agtNiofURQhSRJ/rqQJHK+kJRyvpCXVabyW5j1oIqkqTGJiIjw8PKzaBw0ahIyMDDRu3BgvvfQSBg0adNdrzJs3D+Hh4VbtsbGxyMjIqNB4y0IURfgV1UGSkJaapmiKj4vHOfdB6JLwIwAgJiam8gIsA/N0V22xUfmIoojExERIkmRRTp9IfTheSUs4XklLqtN4TU5OLnFfTSZV58+fx0cffaSYpXJ2dsaiRYvQpUsX6HQ6fP/99xgyZAg2bdp018Rq1qxZmDlzpnyclJQEf39/eHp6wtXVtdLfR3GKy44FAI7OToq2Wp6eiLMzycdeXl6VEVqFUHNsVHqiKEIQBHh6emr+P6JU/XG8kpZwvJKWVKfxam9vX+K+Nk2qXnnlFSxYsKDIPqdPn0ZQUJB8fPXqVfTr1w+PPvooJk6cKLfXqlVLkSB16NAB165dw//93//dNakymUwwmUxW7TqdTjODQCco49Tr9IBZm5rfh5pjo7IRBEFTf37o3sbxSlrC8UpaUl3Ga2nit2lS9fzzz2PMmDFF9qlfv778/bVr19CjRw907twZn332WbHXDwkJwbZt28obprpZPf1XmVQREREREVHlsmlS5enpCU9PzxL1vXr1Knr06IF27dph5cqVJcocIyIi4OvrW94wNUUQBDgEPQDc/MbWoRARERER3RM0safq6tWr6N69OwICAvDuu+8iNjZWPpdf6W/16tUwGo0IDg4GAGzcuBErVqzAF198YZOYq4zFTJWdnRGtug3Dcb0R3g1aQW27lvY2nIFO59/HvqavIsTWwRARERERVQBNJFXbtm3D+fPncf78edSpU0dxTpIKioi/9dZbiI6OhsFgQFBQENavX49HHnmkqsOtUuY5VTxcUcPJBQDQsutgG0VUtE5PzkXi7ckIqelt61CIiIiIiCqEJpKqMWPGFLv3KiwsDGFhYVUTkKoULIM8U3sYQm0YSUm5MaEiIiIiomqEFQ00zOrRv4U8DJiIiIiIiCoXkyqtYyJFRERERGRTTKo0TjCbrzLFn7dhJERERERE9yYmVVpnNlPlknndhoEQEREREd2bmFRpnVn1w2ydvQ0DISIiIiK6NzGp0rjc7Az5+xwmVUREREREVY5JlcblZqYWfK832TASIiIiIqJ7E5MqTZOQk3TT7Ig/TiIiIiKiqsbfwjXOOaCNrUMgIiIiIrqnManSuOadH7J1CERERERE9zQmVRon6PgjJCIiIiKyJf5GTkREREREVA5MqoiIiIiIiMqBSRUREREREVE5MKkiIiIiIiIqByZVGiZAsnUIRERERET3PCZVRERERERE5cCkSsMkCLYOgYiIiIjonsekSsO4/I+IiIiIyPaYVBEREREREZUDkyqNOWFqY+sQiIiIiIjIDJMqjfF/+nv5e+s9VVwOSERERERU1ZhUaUiuJMCtRi35WBT44yMiIiIisjX+Vq4hWbBTHEv88RERERER2Rx/K9eQLEGZVImC3kaREBERERFRPiZVGpJtMVMlgkkVEREREZGtManSkCzBqDjmTBURERERke0xqdKQa8EzFccSC1UQEREREdkcfyvXkPaDJiuOOVNFRERERGR7TKo0TLJKqiyfW0VERERERJWNSZWG5S//21NvCm7BHd7D5ts4IiIiIiKie4/B1gFQ2eXPVIWGvQNJfBuCjjkyEREREVFV42/hGpbp4C1/z4SKiIiIiMg2+Ju4hon2NWwdAhERERHRPY9JlZYJLExBRERERGRrTKqIiIiIiIjKgUmVyolSEbNRfPgvEREREZHN8bdyldMJUhFnufyPiIiIiMjWmFRpGfdUERERERHZHJMqlSty+R9nqoiIiIiIbI5JlZZxpoqIiIiIyOaYVBEREREREZWDZpKqwMBACIKg+Jo/f76iz7Fjx3D//ffD3t4e/v7+WLhwoY2irSKcqSIiIiIisjmDrQMojTfffBMTJ06Uj11cXOTvk5KS0KdPH/Tq1QuffPIJjh8/jnHjxsHd3R2TJk2yRbiVTtBOTkxEREREVG1pKqlycXGBj49PoefWrFmDrKwsrFixAkajEc2bN0dERATee++9aptUFVnDgoiIiIiIqoSmkqr58+fjrbfeQt26dTFixAjMmDEDBkPeW9izZw+6du0Ko9Eo9+/bty8WLFiA+Ph41KhRw+p6mZmZyMzMlI+TkpIAAKIoQhTFSn43xRNFUTEXlR9TQZugijiJgLzxKUkSxyRpAscraQnHK2lJdRqvpXkPmkmqnn32WbRt2xYeHh74999/MWvWLFy/fh3vvfceAODGjRuoV6+e4jXe3t7yucKSqnnz5iE8PNyqPTY2FhkZGZXwLkpHFEWYz8vFxMQAgNyWmZUttxHZmiiKSExMhCRJ0Om4NJXUjeOVtITjlbSkOo3X5OTkEve1aVL1yiuvYMGCBUX2OX36NIKCgjBz5ky5rVWrVjAajXjqqacwb948mEymMt1/1qxZiusmJSXB398fnp6ecHV1LdM1K5Jlduzl5aU4NplMVm1EtiKKIgRBgKenp+b/I0rVH8craQnHK2lJdRqv9vb2Je5r06Tq+eefx5gxY4rsU79+/ULbQ0JCkJOTg4sXL6JJkybw8fHBzZs3FX3yj++2D8tkMhWakOl0OlUOAsuYBEFQZZx078ofkxyXpAUcr6QlHK+kJdVlvJYmfpsmVZ6envD09CzTayMiIqDT6eSZmtDQULz22mvIzs6GnZ0dAGDbtm1o0qRJoUv/qgWWVCciIiIisjlNpI979uzBBx98gKNHj+LChQtYs2YNZsyYgSeffFJOmEaMGAGj0Yjx48fj5MmTWL9+PRYvXqxY3lf9MKkiIiIiIrI1TRSqMJlMWLduHebOnYvMzEzUq1cPM2bMUCRMbm5u+P333zFlyhS0a9cOtWrVwuzZszVfTl0q6qSgiZyYiIiIiKha00RS1bZtW+zdu7fYfq1atcLff/9dBRFVnSLnorj8j4iIiIjI5jjVQUREREREVA5MqlSuyOV/3FNFRERERGRzTKq0jHuqiIiIiIhsjr+Va5jAPVVERERERDbHpErlikqbjB7+VRYHEREREREVThPV/0jpaNdPkXbxEDr1GmHrUIiIiIiI7nlMqlSusEIVrXs+AeCJqg6FiIiIiIgKweV/KsddU0RERERE6sakSuWyOZlIRERERKRqTKpULkVwtHUIRERERERUBCZVKpcmONg6BCIiIiIiKgKTKpXLFky2DoGIiIiIiIrApErlJJaqICIiIiJSNSZVKsekioiIiIhI3ZhUqRyTKiIiIiIidWNSpXJMqoiIiIiI1I1JlcpJAn9ERERERERqxt/YiYiIiIiIyoFJlcpJ/BEREREREakaf2NXOcnWARARERERUZGYVKkc91QREREREakbf2NXOVb/IyIiIiJSNyZVqsekioiIiIhIzZhUqZzI5X9ERERERKrG39hVjzNVRERERERqxqRK5binioiIiIhI3ZhUqR6TKiIiIiIiNWNSpXJ8ThURERERkboxqVI5PqeKiIiIiEjd+Bu7ynFPFRERERGRujGpUjvOVBERERERqRp/Y1e51KaPAwBO2zWzcSRERERERFQYg60DoKI17DQQ0c06okFAE1uHQkREREREhWBSpQH+DVtCp+OkIhERERGRGvE3dSIiIiIionJgUkVERERERFQOTKqIiIiIiIjKgUkVERERERFROTCpIiIiIiIiKgcmVUREREREROXApIqIiIiIiKgcmFQRERERERGVgyaSqj///BOCIBT6deDAAQDAxYsXCz2/d+9eG0dPRERERETVmcHWAZRE586dcf36dUXbG2+8gR07dqB9+/aK9u3bt6N58+bycc2aNaskRiIiIiIiujdpIqkyGo3w8fGRj7Ozs7F582ZMmzYNgiAo+tasWVPRl4iIiIiIqDJpIqmy9OOPP+L27dsYO3as1blBgwYhIyMDjRs3xksvvYRBgwbd9TqZmZnIzMyUj5OSkgAAoihCFMWKD7yURFGEJEmqiIWoOByvpCUcr6QlHK+kJdVpvJbmPWgyqVq+fDn69u2LOnXqyG3Ozs5YtGgRunTpAp1Oh++//x5DhgzBpk2b7ppYzZs3D+Hh4VbtsbGxyMjIqLT4S0oURSQmJkKSJOh0mtj+RvcwjlfSEo5X0hKOV9KS6jRek5OTS9xXkCRJqsRYivTKK69gwYIFRfY5ffo0goKC5OMrV64gICAA3377LYYNG1bka0ePHo2oqCj8/fffhZ4vbKbK398f8fHxcHV1LcU7qRyiKCI2Nhaenp6aH5RU/XG8kpZwvJKWcLySllSn8ZqUlIQaNWogMTGx2NzApjNVzz//PMaMGVNkn/r16yuOV65ciZo1axa5rC9fSEgItm3bdtfzJpMJJpNJPs7PL1NSUlQxCERRREpKChwcHFQRD1FROF5JSzheSUs4XklLqtN4TUlJAVCQIxTFpkmVp6cnPD09S9xfkiSsXLkSo0ePhp2dXbH9IyIi4OvrW+Lr50/x+fv7l/g1RERERERUfSUnJ8PNza3IPpraU/XHH38gKioKEyZMsDq3evVqGI1GBAcHAwA2btyIFStW4Isvvijx9f38/HD58mW4uLhYVRW0hfzliJcvX1bFckSionC8kpZwvJKWcLySllSn8SpJEpKTk+Hn51dsX00lVcuXL0fnzp0Ve6zMvfXWW4iOjobBYEBQUBDWr1+PRx55pMTX1+l0iuIXauHq6qr5QUn3Do5X0hKOV9ISjlfSkuoyXoubocqnqaRq7dq1dz0XFhaGsLCwKoyGiIiIiIgI0PbuMSIiIiIiIhtjUqViJpMJc+bMUVQoJFIrjlfSEo5X0hKOV9KSe3W82vQ5VURERERERFrHmSoiIiIiIqJyYFJFRERERERUDkyqiIiIiIiIyoFJFRERERERUTkwqVKpjz/+GIGBgbC3t0dISAj2799v65DoHvTXX39h4MCB8PPzgyAI2LRpk+K8JEmYPXs2fH194eDggF69euG///5T9ImLi8PIkSPh6uoKd3d3jB8/HikpKVX4LuheMW/ePHTo0AEuLi7w8vLCkCFDcPbsWUWfjIwMTJkyBTVr1oSzszOGDRuGmzdvKvpcunQJAwYMgKOjI7y8vPDiiy8iJyenKt8K3QOWLVuGVq1ayQ9IDQ0NxZYtW+TzHKukVvPnz4cgCJg+fbrcxvHKpEqV1q9fj5kzZ2LOnDk4fPgwWrdujb59+yImJsbWodE9JjU1Fa1bt8bHH39c6PmFCxfiww8/xCeffIJ9+/bByckJffv2RUZGhtxn5MiROHnyJLZt24aff/4Zf/31FyZNmlRVb4HuIbt27cKUKVOwd+9ebNu2DdnZ2ejTpw9SU1PlPjNmzMBPP/2E7777Drt27cK1a9cwdOhQ+Xxubi4GDBiArKws/Pvvv1i9ejVWrVqF2bNn2+ItUTVWp04dzJ8/H4cOHcLBgwfRs2dPDB48GCdPngTAsUrqdODAAXz66ado1aqVop3jFYBEqtOxY0dpypQp8nFubq7k5+cnzZs3z4ZR0b0OgPTDDz/Ix6IoSj4+PtL//d//yW0JCQmSyWSSvvnmG0mSJOnUqVMSAOnAgQNyny1btkiCIEhXr16tstjp3hQTEyMBkHbt2iVJUt74tLOzk7777ju5z+nTpyUA0p49eyRJkqRff/1V0ul00o0bN+Q+y5Ytk1xdXaXMzMyqfQN0z6lRo4b0xRdfcKySKiUnJ0uNGjWStm3bJnXr1k167rnnJEnif1vzcaZKZbKysnDo0CH06tVLbtPpdOjVqxf27Nljw8iIlKKionDjxg3FWHVzc0NISIg8Vvfs2QN3d3e0b99e7tOrVy/odDrs27evymOme0tiYiIAwMPDAwBw6NAhZGdnK8ZsUFAQ6tatqxizLVu2hLe3t9ynb9++SEpKkmcQiCpabm4u1q1bh9TUVISGhnKskipNmTIFAwYMUIxLgP9tzWewdQCkdOvWLeTm5ioGHQB4e3vjzJkzNoqKyNqNGzcAoNCxmn/uxo0b8PLyUpw3GAzw8PCQ+xBVBlEUMX36dHTp0gUtWrQAkDcejUYj3N3dFX0tx2xhYzr/HFFFOn78OEJDQ5GRkQFnZ2f88MMPaNasGSIiIjhWSVXWrVuHw4cP48CBA1bn+N/WPEyqiIio2pkyZQpOnDiBf/75x9ahEN1VkyZNEBERgcTERGzYsAFhYWHYtWuXrcMiUrh8+TKee+45bNu2Dfb29rYOR7W4/E9latWqBb1eb1Ux5ebNm/Dx8bFRVETW8sdjUWPVx8fHqsBKTk4O4uLiOJ6p0kydOhU///wzdu7ciTp16sjtPj4+yMrKQkJCgqK/5ZgtbEznnyOqSEajEQ0bNkS7du0wb948tG7dGosXL+ZYJVU5dOgQYmJi0LZtWxgMBhgMBuzatQsffvghDAYDvL29OV7BpEp1jEYj2rVrhx07dshtoihix44dCA0NtWFkREr16tWDj4+PYqwmJSVh37598lgNDQ1FQkICDh06JPf5448/IIoiQkJCqjxmqt4kScLUqVPxww8/4I8//kC9evUU59u1awc7OzvFmD179iwuXbqkGLPHjx9X/GPAtm3b4OrqimbNmlXNG6F7liiKyMzM5FglVXnggQdw/PhxREREyF/t27fHyJEj5e85XsHqf2q0bt06yWQySatWrZJOnTolTZo0SXJ3d1dUTCGqCsnJydKRI0ekI0eOSACk9957Tzpy5IgUHR0tSZIkzZ8/X3J3d5c2b94sHTt2TBo8eLBUr149KT09Xb5Gv379pODgYGnfvn3SP//8IzVq1EgaPny4rd4SVWOTJ0+W3NzcpD///FO6fv26/JWWlib3efrpp6W6detKf/zxh3Tw4EEpNDRUCg0Nlc/n5ORILVq0kPr06SNFRERIW7dulTw9PaVZs2bZ4i1RNfbKK69Iu3btkqKioqRjx45Jr7zyiiQIgvT7779LksSxSupmXv1PkjheJUmSmFSp1EcffSTVrVtXMhqNUseOHaW9e/faOiS6B+3cuVMCYPUVFhYmSVJeWfU33nhD8vb2lkwmk/TAAw9IZ8+eVVzj9u3b0vDhwyVnZ2fJ1dVVGjt2rJScnGyDd0PVXWFjFYC0cuVKuU96err0zDPPSDVq1JAcHR2lhx9+WLp+/briOhcvXpQefPBBycHBQapVq5b0/PPPS9nZ2VX8bqi6GzdunBQQECAZjUbJ09NTeuCBB+SESpI4VkndLJMqjldJEiRJkmwzR0ZERERERKR93FNFRERERERUDkyqiIiIiIiIyoFJFRERERERUTkwqSIiIiIiIioHJlVERERERETlwKSKiIiIiIioHJhUERERERERlQOTKiIiIiIionJgUkVERJoyZswYDBkyxGb3HzVqFN55551Ku/6pU6dQp04dpKamVto9iIioYgmSJEm2DoKIiAgABEEo8vycOXMwY8YMSJIEd3f3qgnKzNGjR9GzZ09ER0fD2dm50u7zyCOPoHXr1njjjTcq7R5ERFRxmFQREZFq3LhxQ/5+/fr1mD17Ns6ePSu3OTs7V2oyU5wJEybAYDDgk08+qdT7/PLLL5g4cSIuXboEg8FQqfciIqLy4/I/IiJSDR8fH/nLzc0NgiAo2pydna2W/3Xv3h3Tpk3D9OnTUaNGDXh7e+Pzzz9Hamoqxo4dCxcXFzRs2BBbtmxR3OvEiRN48MEH4ezsDG9vb4waNQq3bt26a2y5ubnYsGEDBg4cqGgPDAzE22+/jdGjR8PZ2RkBAQH48ccfERsbi8GDB8PZ2RmtWrXCwYMH5ddER0dj4MCBqFGjBpycnNC8eXP8+uuv8vnevXsjLi4Ou3btKucnSkREVYFJFRERad7q1atRq1Yt7N+/H9OmTcPkyZPx6KOPonPnzjh8+DD69OmDUaNGIS0tDQCQkJCAnj17Ijg4GAcPHsTWrVtx8+ZNPPbYY3e9x7Fjx5CYmIj27dtbnXv//ffRpUsXHDlyBAMGDMCoUaMwevRoPPnkkzh8+DAaNGiA0aNHI39xyJQpU5CZmYm//voLx48fx4IFCxQzcEajEW3atMHff/9dwZ8UERFVBiZVRESkea1bt8brr7+ORo0aYdasWbC3t0etWrUwceJENGrUCLNnz8bt27dx7NgxAMCSJUsQHByMd955B0FBQQgODsaKFSuwc+dOnDt3rtB7REdHQ6/Xw8vLy+pc//798dRTT8n3SkpKQocOHfDoo4+icePGePnll3H69GncvHkTAHDp0iV06dIFLVu2RP369fHQQw+ha9euimv6+fkhOjq6gj8pIiKqDEyqiIhI81q1aiV/r9frUbNmTbRs2VJu8/b2BgDExMQAyCs4sXPnTnmPlrOzM4KCggAAkZGRhd4jPT0dJpOp0GIa5vfPv1dR93/22Wfx9ttvo0uXLpgzZ46c7JlzcHCQZ9aIiEjdmFQREZHm2dnZKY4FQVC05SdCoigCAFJSUjBw4EBEREQovv777z+rGaN8tWrVQlpaGrKysoq8f/69irr/hAkTcOHCBYwaNQrHjx9H+/bt8dFHHymuGRcXB09Pz5J9AEREZFNMqoiI6J7Ttm1bnDx5EoGBgWjYsKHiy8nJqdDXtGnTBkDec6Qqgr+/P55++mls3LgRzz//PD7//HPF+RMnTiA4OLhC7kVERJWLSRUREd1zpkyZgri4OAwfPhwHDhxAZGQkfvvtN4wdOxa5ubmFvsbT0xNt27bFP//8U+77T58+Hb/99huioqJw+PBh7Ny5E02bNpXPX7x4EVevXkWvXr3KfS8iIqp8TKqIiOie4+fnh927dyM3Nxd9+vRBy5YtMX36dLi7u0Onu/tfjRMmTMCaNWvKff/c3FxMmTIFTZs2Rb9+/dC4cWMsXbpUPv/NN9+gT58+CAgIKPe9iIio8vHhv0RERCWUnp6OJk2aYP369QgNDa2Ue2RlZaFRo0ZYu3YtunTpUin3ICKiisWZKiIiohJycHDAl19+WeRDgsvr0qVLePXVV5lQERFpCGeqiIiIiIiIyoEzVUREREREROXApIqIiIiIiKgcmFQRERERERGVA5MqIiIiIiKicmBSRUREREREVA5MqoiIiIiIiMqBSRUREREREVE5MKkiIiIiIiIqByZVRERERERE5fD/CWwUpUUGNLkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Access FID data from a loaded spectrum file - automatic conversion happens\n", + "auto_converted_fid = spe_data.fid\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(auto_converted_fid['time'], auto_converted_fid['real'], label='Auto-converted from SPE')\n", + "plt.plot(fid_data.fid['time'], fid_data.fid['real'], label='Directly loaded FID')\n", + "plt.xlabel('Time (ms)')\n", + "plt.ylabel('Intensity')\n", + "plt.title('Comparison of FID Data')\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3f6a6c29", + "metadata": { + "id": "ecc08d5d", + "language": "markdown" + }, + "source": [ + "## Exporting Data\n", + "\n", + "The `Simpy` class provides a built-in `write()` method to export data in various formats:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f11bb290", + "metadata": { + "id": "bee728a7", + "language": "python" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files exported successfully!\n" + ] + } + ], + "source": [ + "# Export as CSV\n", + "fid_data.write('../../examples/read/exported_fid.csv', format='csv')\n", + "\n", + "# Export as SIMPSON FID file\n", + "fid_data.write('../../examples/read/exported.fid', format='fid')\n", + "\n", + "# Export as SIMPSON SPE file\n", + "spe_data.write('../../examples/read/exported.spe', format='spe')\n", + "\n", + "print(\"Files exported successfully!\")" + ] + }, + { + "cell_type": "markdown", + "id": "dc9518dc", + "metadata": {}, + "source": [ + "## 3. Graphical User Interface (GUI)\n", + "\n", + "Simpyson includes a GUI for quick inspection and simple conversions. You can launch it from the command line:\n", + "\n", + "```bash\n", + "simpyson gui\n", + "```\n", + "\n", + "Or with a specific file to open immediately:\n", + "\n", + "```bash\n", + "simpyson gui path/to/file.spe\n", + "```\n", + "\n", + "The GUI allows you to:\n", + "- View FID and Spectra\n", + "- Apply basic processing (Line Broadening, Phase correction)\n", + "- Export data to different formats" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "simpyson", + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user_guide/02_simulation_calculator.ipynb b/docs/user_guide/02_simulation_calculator.ipynb new file mode 100644 index 0000000..0bf7b91 --- /dev/null +++ b/docs/user_guide/02_simulation_calculator.ipynb @@ -0,0 +1,353 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b13bd50a", + "metadata": {}, + "source": [ + "# Calculating NMR Spectra with SimpCalc\n", + "\n", + "This tutorial demonstrates how to use `SimpCalc` to design and run NMR simulations using SIMPSON. We will cover defining spin systems, setting up the calculator, using different pulse sequences, and handling simulation outputs." + ] + }, + { + "cell_type": "markdown", + "id": "6748e315", + "metadata": {}, + "source": [ + "## 1. Defining the Spin System\n", + "\n", + "The spin system defines the nuclei, their chemical shifts, and couplings. You can define this using a SIMPSON-formatted string or use `soprano` objects if you have them from DFT calculations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "32248449", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SIMPSON detected. Ready to run simulations.\n" + ] + } + ], + "source": [ + "from __future__ import annotations\n", + "\n", + "import shutil\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from simpyson.calculator import SimpCalc\n", + "\n", + "# Check if SIMPSON is installed\n", + "SIMPSON_INSTALLED = shutil.which('simpson') is not None\n", + "if not SIMPSON_INSTALLED:\n", + " print(\"WARNING: 'simpson' executable not found in PATH. You can generate input files but cannot run simulations directly.\")\n", + "else:\n", + " print(\"SIMPSON detected. Ready to run simulations.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8297d757", + "metadata": {}, + "outputs": [], + "source": [ + "# Define a simple 2-spin system\n", + "spinsys_str = \"\"\"\n", + "channels 1H\n", + "nuclei 1H 1H\n", + "shift 1 2.5p 0 0 0 0 0\n", + "shift 2 7.0p 0 0 0 0 0\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "id": "efc26572", + "metadata": {}, + "source": [ + "## 2. Setting up the Calculator\n", + "\n", + "`SimpCalc` is the main interface. You initialize it with your spin system and simulation parameters.\n", + "\n", + "**Note**: SimpCalc requires several parameters to be explicitly set, even if standard defaults are desired." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0f43eb84", + "metadata": {}, + "outputs": [], + "source": [ + "sim = SimpCalc(\n", + " spinsys=spinsys_str,\n", + " proton_frequency='400MHz',\n", + " sw=2000, # Spectral width in Hz\n", + " np=4096, # Number of points\n", + " variable_ref=0, # Center frequency\n", + " # Creating standard static simulation parameters\n", + " spin_rate='10e3', # MAS rate in Hz\n", + " start_operator=\"I1x\",\n", + " detect_operator=\"I1p\",\n", + " method=\"direct\",\n", + " crystal_file=\"rep100\", # Powder averaging\n", + " gamma_angles=10,\n", + " verbose=0\n", + ")\n", + "\n", + "# Save file\n", + "sim.save('../../examples/calculator/my_simulation.in')" + ] + }, + { + "cell_type": "markdown", + "id": "a037c6ed", + "metadata": {}, + "source": [ + "## 3. Pulse Sequences\n", + "\n", + "`SimpCalc` supports various pulse sequences. The default is `'no_pulse'` (just acquire). You can specify others like `'pulse90'` or `'cpmas'`." + ] + }, + { + "cell_type": "markdown", + "id": "475bb9b0", + "metadata": {}, + "source": [ + "### 3.1 Standard Pulse-Acquire (Pulse90)\n", + "This uses a simple 90-degree pulse before acquisition." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "672b9f71", + "metadata": {}, + "outputs": [], + "source": [ + "from simpyson.templates import Pulse90\n", + "\n", + "pulse90 = Pulse90()\n", + "\n", + "spinsys_13C = \"\"\"\n", + "channels 13C\n", + "nuclei 13C 13C\n", + "shift 1 50p 0 0 0 0 0\n", + "shift 2 20p 0 0 0 0 0\n", + "\"\"\"\n", + "\n", + "sim_90 = SimpCalc(\n", + " spinsys=spinsys_13C,\n", + " proton_frequency='400e6',\n", + " sw=20000,\n", + " np=4096,\n", + " # Standard Parameters\n", + " spin_rate='10e3', # MAS rate in Hz\n", + " start_operator=\"Inz\", # Start with z, then pulse90 flips it\n", + " detect_operator=\"Inp\",\n", + " method=\"direct\",\n", + " crystal_file=\"rep100\",\n", + " gamma_angles=10,\n", + " verbose=0,\n", + " pulse_sequence=pulse90,\n", + " lb=10, # Add line broadening\n", + " zerofill=4096 # Add zerofill\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5e66e622", + "metadata": {}, + "source": [ + "## 4. Running the Simulation\n", + "\n", + "If `simpson` is available, you can run the simulation explicitly. The `run` method returns a `Simpy` object containing the result." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "24dd64d5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "output = sim_90.run()\n", + "\n", + "fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(15,5), constrained_layout=True)\n", + "ax[0].plot(output.fid['time'], output.fid['real'])\n", + "ax[0].set_title('FID')\n", + "ax[0].set_xlabel('Time (ms)')\n", + "ax[1].plot(output.spe['ppm'], output.spe['real'])\n", + "ax[1].set_title('Spectrum in ppm')\n", + "ax[1].set_xlim(100, 0)\n", + "ax[1].set_xlabel('Chemical Shift (ppm)')\n", + "ax[2].plot(output.spe['hz'], output.spe['real'])\n", + "ax[2].set_xlim(7500, 0)\n", + "ax[2].set_title('Spectrum in Hz')\n", + "ax[2].set_xlabel('Frequency (Hz)')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "eee720cb", + "metadata": {}, + "source": [ + "## 5. Advanced: Cross Polarization (CPMAS)\n", + "\n", + "In a cross-polarization (CP) experiment, magnetization is typically transfered from an abundant nucleus (I) to a dilute via **through-space (dipolar) coupling**\n", + "\n", + "### Dipolar coupling and internuclear distance\n", + "\n", + "The dipolar coupling constant $b_{IS}$ between two spins $I$ and $S$ depends on their distance $r$:\n", + "\n", + "$$b_{IS} = -\\frac{\\mu_0 \\gamma_I \\gamma_S \\hbar}{4\\pi r^3}$$\n", + "\n", + "It falls off as $1/r^3$, so nearby atoms have a much stronger coupling than distant ones.\n", + "\n", + "In the spin system below, one 1H is coupled to two 13C nuclei with very different coupling strengths:\n", + "\n", + "| Pair | $b_{IS}$ (Hz) | Relative distance |\n", + "|------|--------------|-------------------|\n", + "| H–C2 | −20 000 | closer |\n", + "| H–C3 | −5 000 | further |\n", + "\n", + "### The role of contact time\n", + "\n", + "During the CP spin-lock magnetization flows from 1H to 13C at a rate governed by $b_{IS}$, and thus a **short contact time** only allows magnetization to reach the strongly coupled (nearby) carbon, while a **longer contact time** gives enough time for the magnetization to travel further, also polarizing the weakly coupled (distant) carbon." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ed3f1676", + "metadata": {}, + "outputs": [], + "source": [ + "from simpyson.templates import CPMAS\n", + "\n", + "# Spin system: one 1H coupled to two 13C at different distances.\n", + "# C2 has a strong dipolar coupling (-20000 Hz, closer to H).\n", + "# C3 has a weak dipolar coupling (-5000 Hz, further from H).\n", + "cp_spinsys = \"\"\"\n", + "channels 1H 13C\n", + "nuclei 1H 13C 13C\n", + "shift 1 2.0p 0 0 0 0 0\n", + "shift 2 10p 0 0 0 0 0\n", + "shift 3 15p 0 0 0 0 0\n", + "dipole 1 2 -10000 0 0 0\n", + "dipole 1 3 -5000 0 0 0\n", + "\"\"\"\n", + "\n", + "cp_calc = SimpCalc(\n", + " spinsys=cp_spinsys,\n", + " proton_frequency='400e6',\n", + " sw=20000,\n", + " spin_rate=10000,\n", + " start_operator=\"I1x\",\n", + " detect_operator=\"I2p+I3p\",\n", + " method=\"direct\",\n", + " crystal_file=\"rep100\",\n", + " gamma_angles=10,\n", + " verbose=0,\n", + " np=4096,\n", + " pulse_sequence='cp_mas',\n", + " lb=20,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Short contact time: 1000 μs — only the strongly coupled C2 (nearby) is polarized\n", + "cp_calc.pulse_sequence.update_parameters(pcp=1000)\n", + "sim_short = cp_calc.run()\n", + "\n", + "# Long contact time: 8000 μs — magnetization reaches the weakly coupled C3 (further away)\n", + "cp_calc.pulse_sequence.update_parameters(pcp=8000)\n", + "sim_long = cp_calc.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(6, 4), constrained_layout=True)\n", + "\n", + "ax.plot(sim_short.spe['ppm'], sim_short.spe['real'] /sim_short.spe['real'].max(), label='Short contact time (1000 μs)')\n", + "ax.plot(sim_long.spe['ppm'], sim_long.spe['real'] /sim_long.spe['real'].max() + 1, label='Long contact time (8000 μs)')\n", + "\n", + "ax.set_xlabel('Chemical Shift (ppm)')\n", + "ax.set_ylabel('Normalised Intensity')\n", + "ax.set_xlim(20, 5)\n", + "ax.set_yticks([])\n", + "ax.legend()\n", + "ax.set_title('Effect of CP contact time on $^{13}$C spectrum')\n", + "\n", + "# Annotate peaks\n", + "ax.axvline(10, color='gray', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "ax.axvline(15, color='gray', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "ax.text(8.6, 0.15, 'C$_2$\\n(10 ppm, close)', ha='center', fontsize=8, color='gray')\n", + "ax.text(14, 0.15, 'C$_3$\\n(15 ppm, distant)', ha='center', fontsize=8, color='gray')\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "simpyson", + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/user_guide/03_dft_to_simpson.ipynb b/docs/user_guide/03_dft_to_simpson.ipynb new file mode 100644 index 0000000..07440f8 --- /dev/null +++ b/docs/user_guide/03_dft_to_simpson.ipynb @@ -0,0 +1,480 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bcfde476", + "metadata": {}, + "source": [ + "# From DFT Calculations to SIMPSON Spectra" + ] + }, + { + "cell_type": "markdown", + "id": "04384e76", + "metadata": { + "id": "6a231768", + "language": "markdown" + }, + "source": [ + "A Simpson input file is typically divided into four main sections:\n", + "\n", + "1. **Spin System**: This section identifies the nuclei to be simulated and includes their NMR parameters, such as isotropic shift, anisotropy, asymmetry, and Euler angles.\n", + "2. **Parameters**: This defines the settings for the \"virtual spectrometer,\" such as the magnetic field strength (`proton_freq`), spinning rate (`spin_rate`), number of points (`np`), pulse lengths, pulse powers, etc.\n", + "3. **Pulse Sequence**: This part specifies the pulse program used in the simulation.\n", + "4. **Processing**: Defines the processing parameters, such as line broadening (`lb`) or Fourier transformation of the FID signal.\n", + "\n", + "Simpyson simplifies the preparation of these input files by interfacing data from DFT calculations with Simpson, using [ASE](https://wiki.fysik.dtu.dk/ase/index.html). The spin system for magres files from [CASTEP](https://www.castep.org/) NMR calculations can be easily generated with [Soprano](https://ccp-nc.github.io/soprano/intro.html), while Simpyson can handle the rest of the input file.\n", + "\n", + "For a more detailed description of each parameter, please refer to the following Simpson papers [Bak et al](https://doi.org/10.1016/j.jmr.2011.09.008), [Tošner et al.](https://doi.org/10.1016/j.jmr.2014.07.002), and [Juhl et al.](https://doi.org/10.1016/bs.arnmr.2019.12.001)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "931337c0", + "metadata": { + "id": "bdc6a453", + "language": "python" + }, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "import shutil\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from ase.io import read\n", + "from soprano.calculate.nmr.simpson import write_spinsys\n", + "\n", + "from simpyson.calculator import SimpCalc\n", + "from simpyson.converter import read_vasp\n", + "from simpyson.io import read_simp\n", + "from simpyson.utils import add_spectra" + ] + }, + { + "cell_type": "markdown", + "id": "0fb976f8", + "metadata": {}, + "source": [ + "## 1. Reading DFT Outputs\n" + ] + }, + { + "cell_type": "markdown", + "id": "4994cbc8", + "metadata": { + "id": "6d7f5442", + "language": "markdown" + }, + "source": [ + "In the following example, we start by reading the structure from an ethanol CASTEP calculation, selecting the H atoms, referencing the chemical shifts (`grad = {'H' : -1}` and `ref = {'H' : 31.7}`), and construct the input file for a spectrum acquired at 400 MHz (`proton_freq = 400e6`) with a spinning rate of 40 kHz (`spin_rate = 40e3`). To keep the simulation simple, we begin with the magnetization in the xy-plane (`start_op = 'Inx'`), i.e. the detection plane, thus removing the need to do pulses. For this, we can use the `no_pulse` sequence." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e1d8200d", + "metadata": { + "id": "df7ac60a", + "language": "python" + }, + "outputs": [], + "source": [ + "# Read magres file\n", + "ethanol = read('../../examples/write/ethanol.magres')\n", + "\n", + "# Select only the H atoms\n", + "h_idx = [atom.index for atom in ethanol if atom.symbol == 'H']\n", + "H_subset = ethanol[h_idx]\n", + "\n", + "# Build spin system from CASTEP NMR output via Soprano\n", + "spinsys = write_spinsys(H_subset,\n", + " use_ms=True,\n", + " grad={'H': -1},\n", + " ref={'H': 31.7})\n", + "\n", + "simp_in = SimpCalc(\n", + " spinsys=spinsys,\n", + " out_name='ethanol_sim',\n", + " out_format='spe',\n", + " spin_rate=40e3,\n", + " np=2048,\n", + " proton_frequency=400e6,\n", + " start_operator='Inx',\n", + " detect_operator='Inp',\n", + " crystal_file='rep256',\n", + " gamma_angles=6,\n", + " sw=10e3,\n", + " verbose=0,\n", + " lb=10,\n", + " zerofill=4096,\n", + " method='direct',\n", + " tsw=1e4,\n", + " pulse_sequence='no_pulse',\n", + ")\n", + "\n", + "simp_in.save('../../examples/write/ethanol_sim.in')" + ] + }, + { + "cell_type": "markdown", + "id": "8e99980b", + "metadata": { + "id": "dd7fe2ef", + "language": "markdown" + }, + "source": [ + "The results can be easily plotted. The difference between this spectrum and the one from the previous tutorial is due to the absence of J-coupling in this simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "de5577b7", + "metadata": { + "id": "0096cc89", + "language": "python" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ethanol_out = read_simp('../../examples/write/ethanol_sim.spe', format='spe', b0='400MHz', nucleus='1H')\n", + "\n", + "plt.plot(ethanol_out.ppm['ppm'], ethanol_out.ppm['real'])\n", + "plt.xlim(8, 0)\n", + "plt.xlabel('$^1$H (ppm)')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "265a2502", + "metadata": { + "id": "fa2ed27d", + "language": "markdown" + }, + "source": [ + "## 2. Read VASP NMR calculations\n", + "\n", + "Unlike CASTEP `magres` files, VASP's OUTCAR file contains the magnetic shielding and electric field gradient tensors in units that are not in Hz, as required by Soprano and Simpson. Additionally, ASE's read function doesn't automatically add the `ms` and `efg` arrays to the `Atoms` object, which are necessary for Soprano to prepare the spin system.\n", + "\n", + "Simpyson can parse VASP `OUTCAR` files to extract NMR parameters like chemical shielding tensors and Electric Field Gradients (EFG). Use `read_vasp` for this, that creates a ASE `Atoms` object containing the magnetic shielding and efg tensor under atoms.arrays['ms'] and atoms.arrays['efg'], similar to `Magres` files." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1229a8e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Example of magnetic shielding tensors\n", + "[[[513.46414237 10.495471 -1.140594 ]\n", + " [ 18.453975 526.66315637 -13.976764 ]\n", + " [ 1.644529 -6.971756 503.19928237]]\n", + "\n", + " [[513.46414037 10.495462 -1.140558 ]\n", + " [ 18.453986 526.66312437 -13.976699 ]\n", + " [ 1.644553 -6.971697 503.19930437]]\n", + "\n", + " [[522.30905637 1.754984 -4.475608 ]\n", + " [ -0.884285 522.69452937 -1.442856 ]\n", + " [ -4.056453 -6.352893 519.71053537]]\n", + "\n", + " [[522.30892937 1.75501 -4.475581 ]\n", + " [ -0.884298 522.69448537 -1.442817 ]\n", + " [ -4.056418 -6.3529 519.71048237]]]\n", + "\n", + "\n", + "Example of electric field gradient tensors\n", + "[[[ 0.01443807 -0.07187135 0.01989223]\n", + " [-0.07187135 -0.06324762 0.05085742]\n", + " [ 0.01989223 0.05085742 0.04881983]]\n", + "\n", + " [[ 0.01443807 -0.07187135 0.01989223]\n", + " [-0.07187135 -0.06324762 0.05085742]\n", + " [ 0.01989223 0.05085742 0.04880954]]\n", + "\n", + " [[-0.00222283 0.00824298 0.07168612]\n", + " [ 0.00824298 0.00685371 0.00359151]\n", + " [ 0.07168612 0.00359151 -0.00464118]]\n", + "\n", + " [[-0.00222283 0.00825327 0.07168612]\n", + " [ 0.00825327 0.00685371 0.00359151]\n", + " [ 0.07168612 0.00359151 -0.00464118]]]\n" + ] + } + ], + "source": [ + "from simpyson.converter import read_vasp\n", + "\n", + "# Path to example OUTCAR\n", + "vasp_file = '../../examples/write/AlPO-14.OUTCAR'\n", + "\n", + "atoms = read_vasp(vasp_file, format='vasp-out')\n", + "\n", + "# Print first four ms and efg tensors\n", + "print('Example of magnetic shielding tensors')\n", + "print(f\"{atoms.arrays['ms'][:4]}\")\n", + "print('\\n')\n", + "print('Example of electric field gradient tensors')\n", + "print(f\"{atoms.arrays['efg'][:4]}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ef670d84", + "metadata": {}, + "source": [ + "## 2.1 Compare VASP and CASTEP calculations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bb993fc0", + "metadata": { + "id": "6e13d860", + "language": "python" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[93m \u001b[1m WARNING: \u001b[0m Isotropic value(s) are not zero ([0.00000343]) but NQR order is requested.\n", + "If you're dealing with an EFG tensor, then check it carefully since these should be traceless.\n", + "Sorting by absolute values.\n", + " (/home/cbornes/micromamba/envs/simpyson/lib/python3.12/site-packages/soprano/nmr/utils.py, line: 89)\n", + "\u001b[93m \u001b[1m WARNING: \u001b[0m Isotropic value(s) are not zero ([-0.00000343]) but NQR order is requested.\n", + "If you're dealing with an EFG tensor, then check it carefully since these should be traceless.\n", + "Sorting by absolute values.\n", + " (/home/cbornes/micromamba/envs/simpyson/lib/python3.12/site-packages/soprano/nmr/utils.py, line: 89)\n" + ] + } + ], + "source": [ + "# CASTEP\n", + "castep = read('../../examples/write/AlPO-14.magres')\n", + "\n", + "p_idx = [atom.index for atom in castep if atom.symbol == 'P']\n", + "al_idx = [atom.index for atom in castep if atom.symbol == 'Al']\n", + "\n", + "p_spinsys = write_spinsys(castep[p_idx],\n", + " use_ms=True, grad={'P': -1}, ref={'P': 283.839})\n", + "\n", + "# Al is quadrupolar: include second-order quadrupolar broadening (q_order=2)\n", + "al_spinsys = write_spinsys(castep[al_idx],\n", + " use_ms=True, grad={'Al': -1}, ref={'Al': 538.78},\n", + " q_order=2)\n", + "\n", + "SimpCalc(\n", + " spinsys=p_spinsys, out_name='castep_sim_p', out_format='spe',\n", + " spin_rate=40e3, np=2048, proton_frequency=800e6,\n", + " start_operator='Inx', detect_operator='Inp',\n", + " crystal_file='rep168', gamma_angles=6, sw=30e3,\n", + " verbose=0, lb=200, zerofill=4096, method='direct',\n", + " tsw=3e4, pulse_sequence='no_pulse',\n", + ").save('../../examples/write/castep_sim_p.in')\n", + "\n", + "SimpCalc(\n", + " spinsys=al_spinsys, out_name='castep_sim_al', out_format='spe',\n", + " spin_rate=40e3, np=2048, proton_frequency=800e6,\n", + " start_operator='Inx', detect_operator='Inc',\n", + " crystal_file='rep168', gamma_angles=6, sw=20e3,\n", + " verbose=0, lb=200, zerofill=4096, method='direct',\n", + " tsw=2e4, pulse_sequence='no_pulse',\n", + ").save('../../examples/write/castep_sim_al.in')\n", + "\n", + "\n", + "# VASP\n", + "vasp = read_vasp('../../examples/write/AlPO-14.OUTCAR', format='vasp-out')\n", + "\n", + "p_idx = [atom.index for atom in vasp if atom.symbol == 'P']\n", + "al_idx = [atom.index for atom in vasp if atom.symbol == 'Al']\n", + "\n", + "p_spinsys = write_spinsys(vasp[p_idx],\n", + " use_ms=True, grad={'P': -1}, ref={'P': 294.50})\n", + "\n", + "al_spinsys = write_spinsys(vasp[al_idx],\n", + " use_ms=True, grad={'Al': -1}, ref={'Al': 542.96},\n", + " q_order=2)\n", + "\n", + "SimpCalc(\n", + " spinsys=p_spinsys, out_name='vasp_sim_p', out_format='spe',\n", + " spin_rate=40e3, np=2048, proton_frequency=800e6,\n", + " start_operator='Inx', detect_operator='Inp',\n", + " crystal_file='rep168', gamma_angles=6, sw=30e3,\n", + " verbose=0, lb=200, zerofill=4096, method='direct',\n", + " tsw=3e4, pulse_sequence='no_pulse',\n", + ").save('../../examples/write/vasp_sim_p.in')\n", + "\n", + "SimpCalc(\n", + " spinsys=al_spinsys, out_name='vasp_sim_al', out_format='spe',\n", + " spin_rate=40e3, np=2048, proton_frequency=800e6,\n", + " start_operator='Inx', detect_operator='Inc',\n", + " crystal_file='rep168', gamma_angles=6, sw=20e3,\n", + " verbose=0, lb=200, zerofill=4096, method='direct',\n", + " tsw=2e4, pulse_sequence='no_pulse',\n", + ").save('../../examples/write/vasp_sim_al.in')" + ] + }, + { + "cell_type": "markdown", + "id": "3f722828", + "metadata": { + "id": "19d39c4e", + "language": "markdown" + }, + "source": [ + "Unless you have a laptop/node with crazy amounts of memory, simulating the full Al spin system, containing 8 Al atoms each with second-order quadrupolar broadening `q_order = 2`, can be quite challenging. Since we're not considering coupling between the Al atoms, a more efficient approach is to prepare an input file for each individual Al atom and then merge all the spectra into a combined spectrum. This reduces the computational load and makes the simulation much more manageable." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0a177191", + "metadata": { + "id": "e82ec422", + "language": "python" + }, + "outputs": [], + "source": [ + "al_idx = [atom.index for atom in castep if atom.symbol == 'Al']\n", + "\n", + "# CASTEP — one input file per Al site\n", + "for i, atom in enumerate(al_idx):\n", + " al_spinsys = write_spinsys(castep[[atom]],\n", + " use_ms=True, grad={'Al': -1}, ref={'Al': 538.78},\n", + " q_order=2)\n", + " SimpCalc(\n", + " spinsys=al_spinsys, out_name=f'castep_sim_al_{i}', out_format='spe',\n", + " spin_rate=40e3, np=2048, proton_frequency=800e6,\n", + " start_operator='Inx', detect_operator='Inc',\n", + " crystal_file='rep168', gamma_angles=6, sw=20e3,\n", + " verbose=0, lb=200, zerofill=4096, method='direct',\n", + " tsw=2e4, pulse_sequence='no_pulse',\n", + " ).save(f'../../examples/write/split_simulation_al/castep_sim_al_{i}.in')\n", + "\n", + "al_idx = [atom.index for atom in vasp if atom.symbol == 'Al']\n", + "\n", + "# VASP — one input file per Al site\n", + "for i, atom in enumerate(al_idx):\n", + " al_spinsys = write_spinsys(vasp[[atom]],\n", + " use_ms=True, grad={'Al': -1}, ref={'Al': 542.96},\n", + " q_order=2)\n", + " SimpCalc(\n", + " spinsys=al_spinsys, out_name=f'vasp_sim_al_{i}', out_format='spe',\n", + " spin_rate=40e3, np=2048, proton_frequency=800e6,\n", + " start_operator='Inx', detect_operator='Inc',\n", + " crystal_file='rep168', gamma_angles=6, sw=20e3,\n", + " verbose=0, lb=200, zerofill=4096, method='direct',\n", + " tsw=2e4, pulse_sequence='no_pulse',\n", + " ).save(f'../../examples/write/split_simulation_al/vasp_sim_al_{i}.in')" + ] + }, + { + "cell_type": "markdown", + "id": "f2af7129", + "metadata": { + "id": "988b2ecd", + "language": "markdown" + }, + "source": [ + "Now let's combined all the 27Al spectra and plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9949284e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "al_idx = [atom.index for atom in vasp if atom.symbol == 'Al']\n", + "\n", + "# Read and combine all per-site 27Al spectra\n", + "castep_al_spectra = [\n", + " read_simp(f'../../examples/write/split_simulation_al/castep_sim_al_{i}.spe',\n", + " format='spe', b0='800MHz', nucleus='27Al')\n", + " for i in range(len(al_idx))\n", + "]\n", + "castep_al_out = add_spectra(castep_al_spectra)\n", + "\n", + "vasp_al_spectra = [\n", + " read_simp(f'../../examples/write/split_simulation_al/vasp_sim_al_{i}.spe',\n", + " format='spe', b0='800MHz', nucleus='27Al')\n", + " for i in range(len(al_idx))\n", + "]\n", + "vasp_al_out = add_spectra(vasp_al_spectra)\n", + "\n", + "# Read single-site 31P spectra\n", + "castep_p_out = read_simp('../../examples/write/castep_sim_p.spe', format='spe', b0='800MHz', nucleus='31P')\n", + "vasp_p_out = read_simp('../../examples/write/vasp_sim_p.spe', format='spe', b0='800MHz', nucleus='31P')\n", + "\n", + "# Plot\n", + "fig, ax = plt.subplots(1, 2, figsize=(10, 5), constrained_layout=True)\n", + "\n", + "ax[0].plot(castep_p_out.ppm['ppm'], castep_p_out.ppm['real'], label='CASTEP')\n", + "ax[0].plot(vasp_p_out.ppm['ppm'], vasp_p_out.ppm['real'], label='VASP')\n", + "ax[0].set_xlabel('$^{31}$P (ppm)')\n", + "ax[0].set_xlim(-10, -45)\n", + "ax[0].legend()\n", + "\n", + "ax[1].plot(castep_al_out.ppm['ppm'], castep_al_out.ppm['real'], label='CASTEP')\n", + "ax[1].plot(vasp_al_out.ppm['ppm'], vasp_al_out.ppm['real'], label='VASP')\n", + "ax[1].set_xlabel('$^{27}$Al (ppm)')\n", + "ax[1].set_xlim(45, 0)\n", + "ax[1].legend()\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "simpyson", + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user_guide/read_files.ipynb b/docs/user_guide/read_files.ipynb deleted file mode 100644 index 62f2aa6..0000000 --- a/docs/user_guide/read_files.ipynb +++ /dev/null @@ -1,282 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Read SIMPSON files with SimPYson" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from simpyson.io import SimpReader\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the `examples` folder, you can find the files `ethanol.in`, `ethanol.fid`, and `ethanol.spe`.\n", - "\n", - "- `ethanol.in` is a standard input file for a SIMPSON simulation of the ethanol molecule.\n", - "- `ethanol.fid` represents the simulated free induction decay (FID) of the ethanol molecule.\n", - "- `ethanol.spe` represents the NMR spectra of the ethanol molecule.\n", - "\n", - "SimPYson provides the `SimpReader` class, which reads a SIMPSON `fid`, `spe` and `xreim` files. When a `fid` file is read `SimpReader` creates a Python object with the following data:\n", - "\n", - "- `real` - The real part of the FID.\n", - "- `imag` - The imaginary part of the FID.\n", - "- `np` - The number of points.\n", - "- `sw` - The spectral width.\n", - "- `time` - The time in milliseconds." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real [95.9999136 63.5468932 20.9678205 ... 0. 0. 0. ]\n", - "imag [ 0. 52.0761046 48.2650021 ... 0. 0. 0. ]\n", - "np 4096.0\n", - "sw 10000.0\n", - "time [0.00000000e+00 1.00024420e+00 2.00048840e+00 ... 4.09399951e+03\n", - " 4.09499976e+03 4.09600000e+03]\n" - ] - } - ], - "source": [ - "fid = SimpReader('../../examples/read/ethanol.fid', format='fid')\n", - "\n", - "for key, values in fid.data.items():\n", - " print(key, values)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The data can be easily plotted using matplotlib" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(fid.data['time'], fid.data['real'])\n", - "plt.xlabel('Time (ms)')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When reading `spe` files the following data is extracted:\n", - "\n", - "- `real` - The real part of the spectrum.\n", - "- `imag` - The imaginary part of the spectrum.\n", - "- `np` - The number of points.\n", - "- `sw` - The spectral width.\n", - "- `hz` - The frequency in Hz." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "real [0.18006085 0.19032725 0.1798519 ... 0.19060431 0.18027098 0.19046516]\n", - "imag [-20.1918974 -20.1791859 -20.0945303 ... -20.3742075 -20.2894344\n", - " -20.2766117]\n", - "np 4096.0\n", - "sw 10000.0\n", - "hz [-5000. -4997.55799756 -4995.11599512 ... 4995.11599512\n", - " 4997.55799756 5000. ]\n" - ] - } - ], - "source": [ - "spe = SimpReader('../../examples/read/ethanol.spe', format='spe')\n", - "\n", - "for key, value in spe.data.items():\n", - " print(key, value)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The 1H NMR spectra of ethanol show 3 1H NMR peaks:\n", - "- Triplet from the CH3 group\n", - "- Quartet from the CH2 group\n", - "- Single from the OH group\n", - "\n", - "You can edit `jcoupling` in the file `examples/ethanol.in` to see the effect of J-coupling on the spliting of the 1H peaks" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(spe.data['hz'], spe.data['real'])\n", - "plt.xlabel('Frequency (Hz)')\n", - "plt.xlim(3000, 0)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The data can be converted from frequency (Hz) to ppm by providing the external magnetic field (B0) in either Tesla or MHz, and specify the nucleus being observed" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "spe_ppm = SimpReader('../../examples/read/ethanol.spe', format='spe', b0='400MHz', nucleus='1H')\n", - "plt.plot(spe_ppm.data['ppm'], spe_ppm.data['real'])\n", - "plt.xlabel('$^1$H (ppm)')\n", - "plt.xlim(8, 0)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Lastly, you can convert any `fid` file into a `spe` easily by using `.to_spe()`" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "conv_spe = fid.to_spe()\n", - "\n", - "plt.plot(conv_spe.data['hz'], conv_spe.data['real'], label = 'Converted')\n", - "plt.plot(spe.data['hz'], spe.data['real'], label = 'Original')\n", - "plt.xlim(3000, 0)\n", - "plt.xlabel('Frequency (Hz)')\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The data can be easily exported to a `.csv` file" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "\n", - "df = pd.DataFrame(fid.data)\n", - "df.to_csv('../../examples/read/fid.csv', index=False)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/user_guide/write_simpson.ipynb b/docs/user_guide/write_simpson.ipynb deleted file mode 100644 index f353e33..0000000 --- a/docs/user_guide/write_simpson.ipynb +++ /dev/null @@ -1,441 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Write Simpson simulation files" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A Simpson input file is typically divided into four main sections:\n", - "\n", - "1. **Spin System**: This section identifies the nuclei to be simulated and includes their NMR parameters, such as isotropic shift, asymmetry, and Euler angles.\n", - "2. **Parameters**: This defines the settings for the \"virtual spectrometer,\" such as the magnetic field strength (`proton_freq`), spinning rate (`spin_rate`), number of points (`np`), pulse lengths, pulse powers, etc.\n", - "3. **Pulse Sequence**: This part specifies the pulse program used in the simulation.\n", - "4. **Processing**: Defines the processing parameters, such as line broadening (`lb`) or Fourier transformation of the FID signal.\n", - "\n", - "Simpyson simplifies the preparation of these input files by interfacing data from DFT calculations with Simpson, using [ASE](https://wiki.fysik.dtu.dk/ase/index.html). The spin system for magres files from [CASTEP](https://www.castep.org/) and [Quantum Espresso](https://www.quantum-espresso.org/) NMR calculations can be easily generated with [Soprano](https://ccp-nc.github.io/soprano/intro.html), while Simpyson can handle the rest of the input file.\n", - "\n", - "For a more detailed description of each parameter, please refer to the following Simpson papers [Bak et al](https://doi.org/10.1016/j.jmr.2011.09.008), [Tošner et al.](https://doi.org/10.1016/j.jmr.2014.07.002), and [Juhl et al.](https://doi.org/10.1016/bs.arnmr.2019.12.001)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from soprano.calculate.nmr.simpson import write_spinsys\n", - "from ase.io import read\n", - "from simpyson.converter import read_vasp\n", - "from simpyson.templates import SimpSim, no_pulse\n", - "from simpyson.io import SimpReader\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the following example, we start by reading the structure from an ethanol CASTEP calculation, selecting the H atoms, referencing the chemical shifts (`grad = {'H' : -1}` and `ref = {'H' : 31.7}`), and construct the input file for a spectrum acquired at 400 MHz (`spin_rate = 40e3`) with a spinning rate of 40 kHz (`spin_rate = 40e3`). To keep the simulation simple, we begin with the magnetization in the xy-plane (`start_op = 'Inx'`), i.e. the detection plane, thus removing the need to due pulses. For this, we can use the `no_pulse` sequence." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Read magres file\n", - "ethanol = read('../../examples/write/ethanol.magres')\n", - "\n", - "# Select only the H atoms\n", - "h_idx = [atom.index for atom in ethanol if atom.symbol == 'H']\n", - "H_subset = ethanol[h_idx]\n", - "\n", - "# Get spin system\n", - "spinsys = write_spinsys(H_subset,\n", - " use_ms = True,\n", - " grad = {'H' : -1},\n", - " ref = {'H' : 31.7})\n", - "\n", - "# Prepare Simpson simulation\n", - "simp_in = SimpSim(\n", - " out_name = 'ethanol_sim',\n", - " out_format = 'spe',\n", - " spinsys = spinsys,\n", - " spin_rate = 40e3,\n", - " np = 2048,\n", - " proton_freq = 400e6,\n", - " start_op = 'Inx',\n", - " detect_op = 'Inp',\n", - " crystal_file = 'rep256',\n", - " gamma_angles = 6,\n", - " sw = 10e3,\n", - " verbose = '01',\n", - " lb = 10,\n", - " zerofill = 4096,\n", - " method = \"direct\",\n", - " tsw = 1e4,\n", - " pulse_sequence = no_pulse,\n", - ")\n", - "\n", - "# Write input file\n", - "simp_in.save('../../examples/write/ethanol_sim.in')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The results can be easily plotted. The difference between this spectrum and the one from the previous tutorial is due to the absence of J-coupling in this simulation." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ethanol_out = SimpReader('../../examples/write/ethanol_sim.spe', b0='400MHz', nucleus='1H', format='spe')\n", - "\n", - "plt.plot(ethanol_out.data['ppm'], ethanol_out.data['real'])\n", - "plt.xlim(8, 0)\n", - "plt.xlabel('$^1$H (ppm)')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Read VASP NMR calculations" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Unlike CASTEP and Quantum Espresso `magres` files, VASP's OUTCAR file contains the magnetic shielding and electric field gradient tensors in units that are not in Hz, as required by Soprano and Simpson. Additionally, ASE’s read function doesn’t automatically add the `ms` and `efg` arrays to the `Atoms` object, which are necessary for Soprano to prepare the spin system. The `read_vasp` function handles these conversions and adds the required information. Here is one example how to use it, and how the results compare with a similar CASTEP calculation." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Castep calculation\n", - "castep = read('../../examples/write/AlPO-14.magres')\n", - "\n", - "p_idx = [atom.index for atom in castep if atom.symbol == 'P']\n", - "p_subset = castep[p_idx]\n", - "al_idx = [atom.index for atom in castep if atom.symbol == 'Al']\n", - "al_subset = castep[al_idx]\n", - "\n", - "p_spinsys = write_spinsys(p_subset,\n", - " use_ms = True,\n", - " grad = {'P' : -1},\n", - " ref = {'P' : 283.839})\n", - "\n", - "\n", - "# Al is a quadrupolar so it is important to consider the quadrupolar interaction\n", - "# Simpson allows simulation of quadrupolar broadening up to 2nd order\n", - "al_spinsys = write_spinsys(al_subset,\n", - " use_ms = True,\n", - " grad = {'Al' : -1},\n", - " ref = {'Al' : 538.78},\n", - " q_order=2)\n", - "\n", - "p_inp = SimpSim(\n", - " out_name = 'castep_sim_p',\n", - " out_format = 'spe',\n", - " spinsys = p_spinsys,\n", - " spin_rate = 40e3,\n", - " np = 2048,\n", - " proton_freq = 800e6,\n", - " start_op = 'Inx',\n", - " detect_op = 'Inp',\n", - " crystal_file = 'rep168',\n", - " gamma_angles = 6,\n", - " sw = 30e3,\n", - " verbose = '01',\n", - " lb = 200,\n", - " zerofill = 4096,\n", - " method = \"direct\",\n", - " tsw = 3e4,\n", - " pulse_sequence = no_pulse,\n", - ")\n", - "\n", - "al_inp = SimpSim(\n", - " out_name = 'castep_sim_al',\n", - " out_format = 'spe',\n", - " spinsys = al_spinsys,\n", - " spin_rate = 40e3,\n", - " np = 2048,\n", - " proton_freq = 800e6,\n", - " start_op = 'Inx',\n", - " detect_op = 'Inc',\n", - " crystal_file = 'rep168',\n", - " gamma_angles = 6,\n", - " sw = 20e3,\n", - " verbose = '01',\n", - " lb = 200,\n", - " zerofill = 4096,\n", - " method = \"direct\",\n", - " tsw = 2e4,\n", - " pulse_sequence = no_pulse,\n", - ")\n", - "\n", - "p_inp.save('../../examples/write/castep_sim_p.in')\n", - "al_inp.save('../../examples/write/castep_sim_al.in')\n", - "\n", - "\n", - "# VASP calculation\n", - "vasp = read_vasp('../../examples/write/AlPO-14.OUTCAR', format='vasp-out')\n", - "\n", - "p_idx = [atom.index for atom in vasp if atom.symbol == 'P']\n", - "p_subset = vasp[p_idx]\n", - "al_idx = [atom.index for atom in vasp if atom.symbol == 'Al']\n", - "al_subset = vasp[al_idx]\n", - "\n", - "p_spinsys = write_spinsys(p_subset,\n", - " use_ms = True,\n", - " grad = {'P' : -1},\n", - " ref = {'P' : 294.50})\n", - "\n", - "al_spinsys = write_spinsys(al_subset,\n", - " use_ms = True,\n", - " grad = {'Al' : -1},\n", - " ref = {'Al' : 542.96},\n", - " q_order=2)\n", - "\n", - "p_inp = SimpSim(\n", - " out_name = 'vasp_sim_p',\n", - " out_format = 'spe',\n", - " spinsys = p_spinsys,\n", - " spin_rate = 40e3,\n", - " np = 2048,\n", - " proton_freq = 800e6,\n", - " start_op = 'Inx',\n", - " detect_op = 'Inp',\n", - " crystal_file = 'rep168',\n", - " gamma_angles = 6,\n", - " sw = 30e3,\n", - " verbose = '01',\n", - " lb = 200,\n", - " zerofill = 4096,\n", - " method = \"direct\",\n", - " tsw = 3e4,\n", - " pulse_sequence = no_pulse,\n", - ")\n", - "\n", - "al_inp = SimpSim(\n", - " out_name = 'vasp_sim_al',\n", - " out_format = 'spe',\n", - " spinsys = al_spinsys,\n", - " spin_rate = 40e3,\n", - " np = 2048,\n", - " proton_freq = 800e6,\n", - " start_op = 'Inx',\n", - " detect_op = 'Inc',\n", - " crystal_file = 'rep168',\n", - " gamma_angles = 6,\n", - " sw = 20e3,\n", - " verbose = '01',\n", - " lb = 200,\n", - " zerofill = 4096,\n", - " method = \"direct\",\n", - " tsw = 2e4,\n", - " pulse_sequence = no_pulse,\n", - ")\n", - "\n", - "p_inp.save('../../examples/write/vasp_sim_p.in')\n", - "al_inp.save('../../examples/write/vasp_sim_al.in')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Unless you have a laptop/node with crazy amounts of memory, simulating the full Al spin system, containing 8 Al atoms each with second-order quadrupolar broadening `q_order = 2`, can be quite challenging. Since we're not considering coupling between the Al atoms, a more efficient approach is to prepare an input file for each individual Al atom and then merge all the spectra into a combined spectrum. This reduces the computational load and makes the simulation much more manageable." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Prepare Simpson for each Al atom of CASTEP\n", - "al_idx = [atom.index for atom in castep if atom.symbol == 'Al']\n", - "\n", - "for i, atom in enumerate(al_idx):\n", - " al_subset = castep[[atom]]\n", - " al_spinsys = write_spinsys(al_subset,\n", - " use_ms = True,\n", - " grad = {'Al' : -1},\n", - " ref = {'Al' : 538.78},\n", - " q_order=2)\n", - " \n", - " al_inp = SimpSim(\n", - " out_name = f'castep_sim_al_{i}',\n", - " out_format = 'spe',\n", - " spinsys = al_spinsys,\n", - " spin_rate = 40e3,\n", - " np = 2048,\n", - " proton_freq = 800e6,\n", - " start_op = 'Inx',\n", - " detect_op = 'Inc',\n", - " crystal_file = 'rep168',\n", - " gamma_angles = 6,\n", - " sw = 20e3,\n", - " verbose = '01',\n", - " lb = 200,\n", - " zerofill = 4096,\n", - " method = \"direct\",\n", - " tsw = 2e4,\n", - " pulse_sequence = no_pulse,\n", - " )\n", - "\n", - " al_inp.save(f'../../examples/write/split_simulation_al/castep_sim_al_{i}.in')\n", - "\n", - "# Prepare Simpson for each Al atom of VASP\n", - "al_idx = [atom.index for atom in vasp if atom.symbol == 'Al']\n", - "\n", - "for i, atom in enumerate(al_idx):\n", - " al_subset = vasp[[atom]]\n", - " al_spinsys = write_spinsys(al_subset,\n", - " use_ms = True,\n", - " grad = {'Al' : -1},\n", - " ref = {'Al' : 542.96},\n", - " q_order=2)\n", - " \n", - " al_inp = SimpSim(\n", - " out_name = f'vasp_sim_al_{i}',\n", - " out_format = 'spe',\n", - " spinsys = al_spinsys,\n", - " spin_rate = 40e3,\n", - " np = 2048,\n", - " proton_freq = 800e6,\n", - " start_op = 'Inx',\n", - " detect_op = 'Inc',\n", - " crystal_file = 'rep168',\n", - " gamma_angles = 6,\n", - " sw = 20e3,\n", - " verbose = '01',\n", - " lb = 200,\n", - " zerofill = 4096,\n", - " method = \"direct\",\n", - " tsw = 2e4,\n", - " pulse_sequence = no_pulse,\n", - " )\n", - "\n", - " al_inp.save(f'../../examples/write/split_simulation_al/vasp_sim_al_{i}.in')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's combined all the 27Al spectra and plot the results." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Read CASTEP Al simulations\n", - "real = []\n", - "imag = []\n", - "for i in range(0, len(al_idx)):\n", - " castep_al_out = SimpReader(f'../../examples/write/split_simulation_al/castep_sim_al_{i}.spe', b0='800MHz', nucleus='27Al', format='spe')\n", - " real.append(castep_al_out.data['real'])\n", - " imag.append(castep_al_out.data['imag'])\n", - "\n", - "# Read one example and update the data\n", - "castep_al_out = SimpReader('../../examples/write/split_simulation_al/castep_sim_al_0.spe', b0='800MHz', nucleus='27Al', format='spe')\n", - "castep_al_out.data['real'] = sum(real)\n", - "castep_al_out.data['imag'] = sum(imag)\n", - "\n", - "# Do the same of VASP\n", - "real = []\n", - "imag = []\n", - "for i in range(0, len(al_idx)):\n", - " vasp_al_out = SimpReader(f'../../examples/write/split_simulation_al/vasp_sim_al_{i}.spe', b0='800MHz', nucleus='27Al', format='spe')\n", - " real.append(vasp_al_out.data['real'])\n", - " imag.append(vasp_al_out.data['imag'])\n", - "\n", - "vasp_al_out = SimpReader('../../examples/write/split_simulation_al/vasp_sim_al_0.spe', b0='800MHz', nucleus='27Al', format='spe')\n", - "vasp_al_out.data['real'] = sum(real)\n", - "vasp_al_out.data['imag'] = sum(imag)\n", - "\n", - "castep_p_out = SimpReader('../../examples/write/castep_sim_p.spe', b0='800MHz', nucleus='31P', format='spe')\n", - "vasp_p_out = SimpReader('../../examples/write/vasp_sim_p.spe', b0='800MHz', nucleus='31P', format='spe')\n", - "\n", - "fig, ax = plt.subplots(1, 2, figsize=(10, 5))\n", - "ax[0].plot(castep_p_out.data['ppm'], castep_p_out.data['real'])\n", - "ax[0].plot(vasp_p_out.data['ppm'], vasp_p_out.data['real'])\n", - "ax[0].set_xlabel('$^{31}$P (ppm)')\n", - "ax[0].set_xlim(-10, -45)\n", - "ax[0].legend(['CASTEP', 'VASP'])\n", - "\n", - "ax[1].plot(castep_al_out.data['ppm'], castep_al_out.data['real'])\n", - "ax[1].plot(vasp_al_out.data['ppm'], vasp_al_out.data['real'])\n", - "ax[1].set_xlabel('$^{27}$Al (ppm)')\n", - "ax[1].set_xlim(45, 0)\n", - "ax[1].legend(['CASTEP', 'VASP'])\n", - "plt.show()\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/calculator/cpmas_example.in b/examples/calculator/cpmas_example.in new file mode 100644 index 0000000..895c62a --- /dev/null +++ b/examples/calculator/cpmas_example.in @@ -0,0 +1,58 @@ +spinsys { + +channels 13C 1H +nuclei 13C 13C 1H + +shift 1 10p 0.0p 0.0 0.0 0.0 0.0 +shift 2 20p 0.0p 0.0 0.0 0.0 0.0 +shift 3 0p 0.0p 0.0 0.0 0.0 0.0 + + +dipole 1 2 -1768.1578205035382 90.0 0.0 0.0 +dipole 1 3 -146575.26642034232 90.0 180.0 0.0 +dipole 2 3 -2774.407578122826 90.0 180.0 0.0 + +} + +par { + crystal_file rep168 + detect_operator I1p+I2p + gamma_angles 16 + method direct + np 4096 + proton_frequency 400000000.0 + spin_rate 20000 + start_operator I3x + sw spin_rate*gamma_angles + verbose 01 + variable dw 1e6/spin_rate/gamma_angles + variable p1H 4.5 + variable pcp 50000 + variable ph1H 90 + variable phCcp 0 + variable phHcp 0 + variable pl1H 55000 + variable plCcp 60000 + variable plHcp 80000 +} + + +proc pulseq {} { + global par + reset + pulse $par(pcp) $par(plHcp) $par(phHcp) $par(plCcp) $par(phCcp) + turnoff dipole_1_2 dipole_1_3 dipole_2_3 + acq_block { + delay $par(dw) + } +} + + +proc main {} { + global par + set f [fsimpson] + faddlb $f 10 0 + fzerofill $f 4096 + fft $f + fsave $f $par(name).spe +} diff --git a/examples/calculator/cpmas_example.spe b/examples/calculator/cpmas_example.spe new file mode 100644 index 0000000..a680373 --- /dev/null +++ b/examples/calculator/cpmas_example.spe @@ -0,0 +1,4102 @@ +SIMP +NP=4096 +SW=320000 +TYPE=SPE +DATA +-0.117578928 0.12370603 +-0.117675036 0.123815673 +-0.117771142 0.123925315 +-0.117867247 0.124034955 +-0.117963352 0.124144594 +-0.118059454 0.124254231 +-0.118155556 0.124363868 +-0.118251657 0.124473503 +-0.118347757 0.124583137 +-0.118443857 0.12469277 +-0.118539956 0.124802403 +-0.118636054 0.124912036 +-0.118732153 0.125021668 +-0.118828251 0.125131299 +-0.118924348 0.125240931 +-0.119020446 0.125350562 +-0.119116544 0.125460194 +-0.119212643 0.125569826 +-0.119308741 0.125679458 +-0.11940484 0.125789091 +-0.11950094 0.125898724 +-0.11959704 0.126008358 +-0.119693141 0.126117993 +-0.119789243 0.126227629 +-0.119885346 0.126337267 +-0.11998145 0.126446905 +-0.120077556 0.126556545 +-0.120173662 0.126666187 +-0.12026977 0.12677583 +-0.12036588 0.126885475 +-0.120461992 0.126995122 +-0.120558105 0.12710477 +-0.12065422 0.127214422 +-0.120750338 0.127324075 +-0.120846457 0.127433731 +-0.120942579 0.127543389 +-0.121038703 0.12765305 +-0.12113483 0.127762714 +-0.121230959 0.127872381 +-0.121327091 0.127982051 +-0.121423225 0.128091725 +-0.121519363 0.128201401 +-0.121615504 0.128311081 +-0.121711648 0.128420765 +-0.121807795 0.128530452 +-0.121903946 0.128640144 +-0.1220001 0.128749839 +-0.122096257 0.128859538 +-0.122192419 0.128969242 +-0.122288584 0.12907895 +-0.122384754 0.129188662 +-0.122480927 0.12929838 +-0.122577105 0.129408102 +-0.122673287 0.129517828 +-0.122769473 0.12962756 +-0.122865664 0.129737297 +-0.122961859 0.12984704 +-0.123058059 0.129956787 +-0.123154265 0.130066541 +-0.123250475 0.1301763 +-0.12334669 0.130286064 +-0.12344291 0.130395835 +-0.123539136 0.130505612 +-0.123635367 0.130615395 +-0.123731604 0.130725184 +-0.123827847 0.13083498 +-0.123924095 0.130944782 +-0.124020349 0.131054591 +-0.124116609 0.131164407 +-0.124212875 0.13127423 +-0.124309148 0.13138406 +-0.124405427 0.131493897 +-0.124501712 0.131603741 +-0.124598004 0.131713593 +-0.124694302 0.131823453 +-0.124790608 0.131933321 +-0.12488692 0.132043196 +-0.124983239 0.132153079 +-0.125079566 0.132262971 +-0.1251759 0.13237287 +-0.125272241 0.132482778 +-0.12536859 0.132592695 +-0.125464946 0.13270262 +-0.12556131 0.132812555 +-0.125657682 0.132922498 +-0.125754061 0.13303245 +-0.125850449 0.133142411 +-0.125946845 0.133252382 +-0.126043249 0.133362362 +-0.126139662 0.133472351 +-0.126236083 0.133582351 +-0.126332513 0.13369236 +-0.126428952 0.133802379 +-0.126525399 0.133912408 +-0.126621856 0.134022448 +-0.126718321 0.134132498 +-0.126814796 0.134242558 +-0.12691128 0.134352629 +-0.127007774 0.134462711 +-0.127104277 0.134572803 +-0.12720079 0.134682907 +-0.127297312 0.134793022 +-0.127393845 0.134903148 +-0.127490387 0.135013285 +-0.12758694 0.135123434 +-0.127683503 0.135233595 +-0.127780076 0.135343768 +-0.127876659 0.135453952 +-0.127973254 0.135564148 +-0.128069859 0.135674357 +-0.128166474 0.135784578 +-0.128263101 0.135894812 +-0.128359739 0.136005058 +-0.128456388 0.136115317 +-0.128553048 0.136225588 +-0.12864972 0.136335873 +-0.128746403 0.136446171 +-0.128843098 0.136556482 +-0.128939804 0.136666806 +-0.129036523 0.136777144 +-0.129133253 0.136887496 +-0.129229996 0.136997861 +-0.12932675 0.137108241 +-0.129423518 0.137218634 +-0.129520297 0.137329042 +-0.129617089 0.137439464 +-0.129713894 0.1375499 +-0.129810711 0.137660351 +-0.129907542 0.137770817 +-0.130004385 0.137881297 +-0.130101242 0.137991792 +-0.130198112 0.138102303 +-0.130294995 0.138212829 +-0.130391892 0.13832337 +-0.130488802 0.138433927 +-0.130585726 0.138544499 +-0.130682664 0.138655087 +-0.130779616 0.138765691 +-0.130876582 0.138876311 +-0.130973562 0.138986948 +-0.131070556 0.1390976 +-0.131167565 0.139208269 +-0.131264589 0.139318955 +-0.131361627 0.139429657 +-0.13145868 0.139540377 +-0.131555748 0.139651113 +-0.13165283 0.139761866 +-0.131749928 0.139872637 +-0.131847042 0.139983425 +-0.13194417 0.14009423 +-0.132041314 0.140205053 +-0.132138474 0.140315894 +-0.132235649 0.140426753 +-0.132332841 0.14053763 +-0.132430048 0.140648525 +-0.132527271 0.140759438 +-0.13262451 0.14087037 +-0.132721766 0.140981321 +-0.132819039 0.14109229 +-0.132916327 0.141203278 +-0.133013633 0.141314285 +-0.133110955 0.141425311 +-0.133208294 0.141536357 +-0.13330565 0.141647422 +-0.133403024 0.141758506 +-0.133500414 0.14186961 +-0.133597822 0.141980734 +-0.133695248 0.142091878 +-0.133792691 0.142203042 +-0.133890152 0.142314227 +-0.133987631 0.142425431 +-0.134085127 0.142536656 +-0.134182642 0.142647902 +-0.134280175 0.142759169 +-0.134377727 0.142870456 +-0.134475297 0.142981765 +-0.134572885 0.143093094 +-0.134670492 0.143204446 +-0.134768118 0.143315818 +-0.134865763 0.143427212 +-0.134963427 0.143538628 +-0.13506111 0.143650066 +-0.135158813 0.143761525 +-0.135256535 0.143873007 +-0.135354276 0.143984511 +-0.135452037 0.144096038 +-0.135549818 0.144207587 +-0.135647619 0.144319159 +-0.13574544 0.144430754 +-0.135843281 0.144542371 +-0.135941142 0.144654012 +-0.136039024 0.144765676 +-0.136136926 0.144877363 +-0.136234849 0.144989074 +-0.136332793 0.145100809 +-0.136430757 0.145212567 +-0.136528743 0.14532435 +-0.136626749 0.145436156 +-0.136724777 0.145547987 +-0.136822826 0.145659842 +-0.136920897 0.145771721 +-0.13701899 0.145883626 +-0.137117104 0.145995555 +-0.13721524 0.146107509 +-0.137313398 0.146219488 +-0.137411578 0.146331492 +-0.13750978 0.146443521 +-0.137608005 0.146555576 +-0.137706252 0.146667657 +-0.137804521 0.146779763 +-0.137902814 0.146891896 +-0.138001129 0.147004054 +-0.138099467 0.147116239 +-0.138197829 0.14722845 +-0.138296213 0.147340687 +-0.138394621 0.147452951 +-0.138493053 0.147565242 +-0.138591508 0.147677559 +-0.138689986 0.147789904 +-0.138788489 0.147902276 +-0.138887015 0.148014675 +-0.138985566 0.148127102 +-0.139084141 0.148239556 +-0.13918274 0.148352038 +-0.139281363 0.148464548 +-0.139380012 0.148577086 +-0.139478685 0.148689652 +-0.139577382 0.148802246 +-0.139676105 0.148914869 +-0.139774853 0.149027521 +-0.139873626 0.149140201 +-0.139972424 0.14925291 +-0.140071248 0.149365649 +-0.140170098 0.149478416 +-0.140268973 0.149591213 +-0.140367874 0.149704039 +-0.140466801 0.149816895 +-0.140565754 0.14992978 +-0.140664733 0.150042696 +-0.140763739 0.150155641 +-0.140862771 0.150268617 +-0.14096183 0.150381623 +-0.141060915 0.15049466 +-0.141160028 0.150607727 +-0.141259167 0.150720825 +-0.141358333 0.150833954 +-0.141457527 0.150947114 +-0.141556748 0.151060305 +-0.141655997 0.151173527 +-0.141755273 0.151286781 +-0.141854577 0.151400067 +-0.141953909 0.151513385 +-0.142053269 0.151626734 +-0.142152657 0.151740116 +-0.142252073 0.151853529 +-0.142351518 0.151966976 +-0.142450991 0.152080454 +-0.142550493 0.152193966 +-0.142650024 0.15230751 +-0.142749583 0.152421087 +-0.142849172 0.152534697 +-0.14294879 0.152648341 +-0.143048437 0.152762018 +-0.143148114 0.152875729 +-0.14324782 0.152989473 +-0.143347556 0.153103251 +-0.143447322 0.153217063 +-0.143547117 0.15333091 +-0.143646943 0.153444791 +-0.143746799 0.153558706 +-0.143846685 0.153672655 +-0.143946602 0.15378664 +-0.14404655 0.153900659 +-0.144146528 0.154014714 +-0.144246537 0.154128804 +-0.144346577 0.154242929 +-0.144446648 0.15435709 +-0.144546751 0.154471286 +-0.144646885 0.154585518 +-0.144747051 0.154699786 +-0.144847248 0.15481409 +-0.144947477 0.154928431 +-0.145047738 0.155042808 +-0.145148031 0.155157221 +-0.145248356 0.155271671 +-0.145348714 0.155386159 +-0.145449104 0.155500683 +-0.145549526 0.155615244 +-0.145649982 0.155729843 +-0.14575047 0.155844479 +-0.145850991 0.155959153 +-0.145951546 0.156073864 +-0.146052134 0.156188614 +-0.146152755 0.156303402 +-0.14625341 0.156418228 +-0.146354098 0.156533092 +-0.14645482 0.156647995 +-0.146555577 0.156762937 +-0.146656367 0.156877917 +-0.146757191 0.156992937 +-0.14685805 0.157107996 +-0.146958944 0.157223094 +-0.147059872 0.157338232 +-0.147160835 0.157453409 +-0.147261833 0.157568626 +-0.147362865 0.157683883 +-0.147463933 0.15779918 +-0.147565037 0.157914518 +-0.147666176 0.158029896 +-0.14776735 0.158145314 +-0.14786856 0.158260774 +-0.147969806 0.158376274 +-0.148071088 0.158491815 +-0.148172406 0.158607398 +-0.148273761 0.158723022 +-0.148375152 0.158838687 +-0.148476579 0.158954394 +-0.148578043 0.159070143 +-0.148679545 0.159185934 +-0.148781083 0.159301768 +-0.148882658 0.159417643 +-0.14898427 0.159533561 +-0.14908592 0.159649522 +-0.149187607 0.159765526 +-0.149289333 0.159881572 +-0.149391095 0.159997662 +-0.149492896 0.160113795 +-0.149594735 0.160229971 +-0.149696613 0.160346192 +-0.149798528 0.160462455 +-0.149900483 0.160578763 +-0.150002475 0.160695115 +-0.150104507 0.160811511 +-0.150206578 0.160927952 +-0.150308688 0.161044437 +-0.150410837 0.161160967 +-0.150513025 0.161277542 +-0.150615253 0.161394162 +-0.150717521 0.161510827 +-0.150819828 0.161627538 +-0.150922176 0.161744294 +-0.151024563 0.161861096 +-0.151126991 0.161977944 +-0.151229459 0.162094838 +-0.151331968 0.162211778 +-0.151434517 0.162328765 +-0.151537107 0.162445798 +-0.151639739 0.162562878 +-0.151742411 0.162680005 +-0.151845125 0.162797178 +-0.15194788 0.1629144 +-0.152050676 0.163031668 +-0.152153515 0.163148984 +-0.152256395 0.163266348 +-0.152359317 0.163383759 +-0.152462281 0.163501219 +-0.152565288 0.163618727 +-0.152668337 0.163736283 +-0.152771428 0.163853888 +-0.152874563 0.163971542 +-0.15297774 0.164089245 +-0.15308096 0.164206996 +-0.153184224 0.164324797 +-0.153287531 0.164442647 +-0.153390881 0.164560547 +-0.153494275 0.164678497 +-0.153597712 0.164796496 +-0.153701194 0.164914546 +-0.15380472 0.165032646 +-0.15390829 0.165150796 +-0.154011904 0.165268997 +-0.154115563 0.165387249 +-0.154219266 0.165505552 +-0.154323014 0.165623906 +-0.154426808 0.165742311 +-0.154530646 0.165860767 +-0.15463453 0.165979276 +-0.154738459 0.166097836 +-0.154842434 0.166216448 +-0.154946454 0.166335112 +-0.155050521 0.166453828 +-0.155154633 0.166572597 +-0.155258792 0.166691419 +-0.155362997 0.166810294 +-0.155467248 0.166929221 +-0.155571546 0.167048202 +-0.155675891 0.167167236 +-0.155780283 0.167286324 +-0.155884722 0.167405466 +-0.155989208 0.167524661 +-0.156093742 0.167643911 +-0.156198323 0.167763215 +-0.156302952 0.167882573 +-0.156407629 0.168001986 +-0.156512354 0.168121453 +-0.156617128 0.168240976 +-0.156721949 0.168360554 +-0.156826819 0.168480187 +-0.156931738 0.168599876 +-0.157036706 0.16871962 +-0.157141723 0.16883942 +-0.157246788 0.168959277 +-0.157351904 0.169079189 +-0.157457068 0.169199158 +-0.157562282 0.169319184 +-0.157667546 0.169439266 +-0.15777286 0.169559406 +-0.157878225 0.169679602 +-0.157983639 0.169799856 +-0.158089104 0.169920167 +-0.158194619 0.170040536 +-0.158300185 0.170160963 +-0.158405802 0.170281448 +-0.15851147 0.170401991 +-0.15861719 0.170522593 +-0.15872296 0.170643253 +-0.158828783 0.170763972 +-0.158934657 0.17088475 +-0.159040583 0.171005588 +-0.159146561 0.171126484 +-0.159252591 0.17124744 +-0.159358673 0.171368456 +-0.159464808 0.171489532 +-0.159570996 0.171610668 +-0.159677237 0.171731864 +-0.15978353 0.17185312 +-0.159889877 0.171974438 +-0.159996277 0.172095816 +-0.160102731 0.172217255 +-0.160209239 0.172338755 +-0.1603158 0.172460317 +-0.160422415 0.172581941 +-0.160529085 0.172703626 +-0.160635808 0.172825373 +-0.160742587 0.172947183 +-0.16084942 0.173069054 +-0.160956308 0.173190989 +-0.161063251 0.173312986 +-0.161170249 0.173435046 +-0.161277302 0.173557169 +-0.161384411 0.173679356 +-0.161491576 0.173801606 +-0.161598797 0.173923919 +-0.161706074 0.174046297 +-0.161813406 0.174168739 +-0.161920796 0.174291245 +-0.162028241 0.174413816 +-0.162135744 0.174536451 +-0.162243303 0.174659151 +-0.16235092 0.174781916 +-0.162458594 0.174904747 +-0.162566325 0.175027643 +-0.162674113 0.175150604 +-0.16278196 0.175273632 +-0.162889864 0.175396726 +-0.162997827 0.175519885 +-0.163105848 0.175643112 +-0.163213927 0.175766405 +-0.163322065 0.175889765 +-0.163430262 0.176013192 +-0.163538517 0.176136686 +-0.163646832 0.176260248 +-0.163755206 0.176383877 +-0.16386364 0.176507574 +-0.163972133 0.176631339 +-0.164080686 0.176755173 +-0.1641893 0.176879075 +-0.164297973 0.177003046 +-0.164406707 0.177127085 +-0.164515502 0.177251194 +-0.164624357 0.177375372 +-0.164733273 0.177499619 +-0.16484225 0.177623936 +-0.164951289 0.177748323 +-0.165060389 0.177872781 +-0.16516955 0.177997308 +-0.165278774 0.178121906 +-0.165388059 0.178246575 +-0.165497407 0.178371314 +-0.165606817 0.178496125 +-0.16571629 0.178621007 +-0.165825825 0.178745961 +-0.165935423 0.178870986 +-0.166045085 0.178996084 +-0.166154809 0.179121253 +-0.166264597 0.179246495 +-0.166374449 0.17937181 +-0.166484365 0.179497197 +-0.166594344 0.179622657 +-0.166704388 0.179748191 +-0.166814497 0.179873798 +-0.16692467 0.179999479 +-0.167034907 0.180125233 +-0.16714521 0.180251062 +-0.167255578 0.180376965 +-0.167366011 0.180502943 +-0.167476509 0.180628995 +-0.167587074 0.180755122 +-0.167697704 0.180881324 +-0.1678084 0.181007602 +-0.167919163 0.181133955 +-0.168029992 0.181260385 +-0.168140888 0.18138689 +-0.16825185 0.181513471 +-0.16836288 0.181640129 +-0.168473977 0.181766863 +-0.168585141 0.181893675 +-0.168696373 0.182020563 +-0.168807673 0.182147529 +-0.16891904 0.182274573 +-0.169030476 0.182401694 +-0.16914198 0.182528893 +-0.169253553 0.18265617 +-0.169365195 0.182783526 +-0.169476906 0.182910961 +-0.169588685 0.183038474 +-0.169700535 0.183166067 +-0.169812453 0.183293738 +-0.169924442 0.18342149 +-0.1700365 0.183549321 +-0.170148629 0.183677232 +-0.170260828 0.183805224 +-0.170373097 0.183933296 +-0.170485438 0.184061448 +-0.170597849 0.184189682 +-0.170710331 0.184317996 +-0.170822885 0.184446392 +-0.17093551 0.18457487 +-0.171048207 0.184703429 +-0.171160976 0.184832071 +-0.171273817 0.184960795 +-0.171386731 0.185089601 +-0.171499717 0.18521849 +-0.171612775 0.185347462 +-0.171725907 0.185476517 +-0.171839112 0.185605656 +-0.17195239 0.185734878 +-0.172065742 0.185864185 +-0.172179168 0.185993575 +-0.172292667 0.18612305 +-0.172406241 0.186252609 +-0.172519889 0.186382254 +-0.172633612 0.186511983 +-0.17274741 0.186641798 +-0.172861282 0.186771698 +-0.17297523 0.186901684 +-0.173089254 0.187031756 +-0.173203353 0.187161915 +-0.173317527 0.187292159 +-0.173431778 0.187422491 +-0.173546105 0.18755291 +-0.173660509 0.187683416 +-0.173774989 0.187814009 +-0.173889547 0.18794469 +-0.174004181 0.188075459 +-0.174118893 0.188206316 +-0.174233682 0.188337262 +-0.174348549 0.188468296 +-0.174463494 0.18859942 +-0.174578518 0.188730632 +-0.174693619 0.188861934 +-0.174808799 0.188993326 +-0.174924059 0.189124807 +-0.175039397 0.189256379 +-0.175154814 0.189388041 +-0.175270311 0.189519794 +-0.175385888 0.189651638 +-0.175501544 0.189783572 +-0.175617281 0.189915599 +-0.175733098 0.190047716 +-0.175848996 0.190179926 +-0.175964974 0.190312228 +-0.176081034 0.190444623 +-0.176197175 0.19057711 +-0.176313397 0.19070969 +-0.176429701 0.190842363 +-0.176546087 0.19097513 +-0.176662555 0.19110799 +-0.176779105 0.191240944 +-0.176895738 0.191373992 +-0.177012454 0.191507135 +-0.177129253 0.191640373 +-0.177246135 0.191773705 +-0.177363101 0.191907133 +-0.17748015 0.192040657 +-0.177597283 0.192174276 +-0.177714501 0.192307991 +-0.177831803 0.192441802 +-0.177949189 0.19257571 +-0.178066661 0.192709714 +-0.178184217 0.192843816 +-0.178301859 0.192978015 +-0.178419586 0.193112312 +-0.1785374 0.193246706 +-0.178655299 0.193381199 +-0.178773284 0.19351579 +-0.178891356 0.193650479 +-0.179009515 0.193785268 +-0.179127761 0.193920155 +-0.179246093 0.194055142 +-0.179364514 0.194190229 +-0.179483022 0.194325416 +-0.179601618 0.194460703 +-0.179720302 0.194596091 +-0.179839074 0.194731579 +-0.179957935 0.194867169 +-0.180076885 0.19500286 +-0.180195924 0.195138652 +-0.180315052 0.195274546 +-0.18043427 0.195410543 +-0.180553578 0.195546642 +-0.180672976 0.195682844 +-0.180792464 0.195819148 +-0.180912042 0.195955556 +-0.181031712 0.196092068 +-0.181151472 0.196228683 +-0.181271324 0.196365402 +-0.181391267 0.196502226 +-0.181511302 0.196639155 +-0.181631429 0.196776188 +-0.181751649 0.196913327 +-0.181871961 0.197050571 +-0.181992365 0.197187921 +-0.182112863 0.197325377 +-0.182233454 0.19746294 +-0.182354138 0.197600609 +-0.182474917 0.197738385 +-0.182595789 0.197876268 +-0.182716755 0.198014259 +-0.182837816 0.198152358 +-0.182958972 0.198290564 +-0.183080223 0.198428879 +-0.183201569 0.198567303 +-0.183323011 0.198705836 +-0.183444548 0.198844478 +-0.183566182 0.198983229 +-0.183687912 0.199122091 +-0.183809738 0.199261062 +-0.183931661 0.199400144 +-0.184053682 0.199539337 +-0.184175799 0.199678641 +-0.184298015 0.199818056 +-0.184420328 0.199957582 +-0.184542739 0.200097221 +-0.184665249 0.200236972 +-0.184787857 0.200376835 +-0.184910564 0.200516811 +-0.185033371 0.2006569 +-0.185156277 0.200797103 +-0.185279282 0.200937419 +-0.185402388 0.20107785 +-0.185525593 0.201218395 +-0.1856489 0.201359054 +-0.185772307 0.201499828 +-0.185895815 0.201640718 +-0.186019424 0.201781723 +-0.186143136 0.201922844 +-0.186266948 0.202064081 +-0.186390864 0.202205435 +-0.186514881 0.202346905 +-0.186639001 0.202488493 +-0.186763224 0.202630198 +-0.186887551 0.20277202 +-0.18701198 0.202913961 +-0.187136514 0.20305602 +-0.187261152 0.203198198 +-0.187385894 0.203340495 +-0.18751074 0.203482911 +-0.187635692 0.203625447 +-0.187760748 0.203768102 +-0.187885911 0.203910878 +-0.188011178 0.204053775 +-0.188136552 0.204196792 +-0.188262032 0.204339931 +-0.188387619 0.204483191 +-0.188513313 0.204626573 +-0.188639114 0.204770077 +-0.188765022 0.204913704 +-0.188891038 0.205057454 +-0.189017161 0.205201327 +-0.189143394 0.205345323 +-0.189269734 0.205489443 +-0.189396184 0.205633688 +-0.189522743 0.205778056 +-0.189649411 0.20592255 +-0.189776189 0.206067169 +-0.189903077 0.206211913 +-0.190030075 0.206356783 +-0.190157184 0.20650178 +-0.190284404 0.206646902 +-0.190411735 0.206792152 +-0.190539178 0.206937529 +-0.190666732 0.207083033 +-0.190794399 0.207228665 +-0.190922178 0.207374426 +-0.191050069 0.207520315 +-0.191178074 0.207666332 +-0.191306192 0.207812479 +-0.191434423 0.207958756 +-0.191562768 0.208105162 +-0.191691228 0.208251699 +-0.191819802 0.208398366 +-0.191948491 0.208545164 +-0.192077295 0.208692094 +-0.192206214 0.208839155 +-0.192335249 0.208986348 +-0.192464401 0.209133674 +-0.192593668 0.209281132 +-0.192723052 0.209428723 +-0.192852553 0.209576448 +-0.192982172 0.209724306 +-0.193111908 0.209872299 +-0.193241762 0.210020426 +-0.193371734 0.210168687 +-0.193501825 0.210317084 +-0.193632034 0.210465617 +-0.193762363 0.210614285 +-0.193892811 0.21076309 +-0.194023379 0.210912031 +-0.194154067 0.21106111 +-0.194284875 0.211210325 +-0.194415805 0.211359679 +-0.194546855 0.21150917 +-0.194678027 0.2116588 +-0.19480932 0.211808569 +-0.194940736 0.211958477 +-0.195072274 0.212108524 +-0.195203934 0.212258712 +-0.195335718 0.21240904 +-0.195467625 0.212559508 +-0.195599655 0.212710118 +-0.19573181 0.212860869 +-0.195864089 0.213011761 +-0.195996493 0.213162796 +-0.196129022 0.213313974 +-0.196261676 0.213465294 +-0.196394455 0.213616758 +-0.196527361 0.213768366 +-0.196660393 0.213920118 +-0.196793552 0.214072014 +-0.196926838 0.214224055 +-0.197060251 0.214376241 +-0.197193792 0.214528573 +-0.19732746 0.214681051 +-0.197461258 0.214833675 +-0.197595184 0.214986446 +-0.197729239 0.215139365 +-0.197863423 0.215292431 +-0.197997737 0.215445645 +-0.198132182 0.215599007 +-0.198266756 0.215752518 +-0.198401462 0.215906179 +-0.198536299 0.216059988 +-0.198671267 0.216213948 +-0.198806367 0.216368059 +-0.198941599 0.21652232 +-0.199076964 0.216676732 +-0.199212462 0.216831296 +-0.199348093 0.216986011 +-0.199483858 0.21714088 +-0.199619756 0.217295901 +-0.199755789 0.217451075 +-0.199891957 0.217606403 +-0.20002826 0.217761885 +-0.200164698 0.217917521 +-0.200301272 0.218073312 +-0.200437982 0.218229259 +-0.200574829 0.218385361 +-0.200711812 0.218541619 +-0.200848933 0.218698034 +-0.200986191 0.218854606 +-0.201123588 0.219011335 +-0.201261122 0.219168222 +-0.201398796 0.219325267 +-0.201536608 0.219482471 +-0.20167456 0.219639834 +-0.201812652 0.219797356 +-0.201950884 0.219955038 +-0.202089257 0.220112881 +-0.20222777 0.220270885 +-0.202366425 0.220429049 +-0.202505222 0.220587376 +-0.202644161 0.220745864 +-0.202783242 0.220904515 +-0.202922467 0.221063329 +-0.203061834 0.221222306 +-0.203201345 0.221381447 +-0.203341 0.221540752 +-0.2034808 0.221700222 +-0.203620744 0.221859858 +-0.203760834 0.222019658 +-0.203901069 0.222179625 +-0.20404145 0.222339759 +-0.204181978 0.222500059 +-0.204322652 0.222660527 +-0.204463474 0.222821162 +-0.204604443 0.222981966 +-0.20474556 0.223142939 +-0.204886825 0.223304081 +-0.20502824 0.223465392 +-0.205169803 0.223626874 +-0.205311516 0.223788526 +-0.205453379 0.22395035 +-0.205595392 0.224112344 +-0.205737556 0.224274511 +-0.205879871 0.22443685 +-0.206022338 0.224599362 +-0.206164957 0.224762048 +-0.206307728 0.224924907 +-0.206450653 0.225087941 +-0.20659373 0.225251149 +-0.206736961 0.225414533 +-0.206880346 0.225578092 +-0.207023886 0.225741828 +-0.207167581 0.22590574 +-0.20731143 0.22606983 +-0.207455436 0.226234097 +-0.207599598 0.226398542 +-0.207743916 0.226563166 +-0.207888392 0.226727969 +-0.208033025 0.226892952 +-0.208177816 0.227058114 +-0.208322765 0.227223458 +-0.208467873 0.227388982 +-0.20861314 0.227554688 +-0.208758567 0.227720575 +-0.208904154 0.227886646 +-0.209049901 0.228052899 +-0.209195809 0.228219336 +-0.209341879 0.228385957 +-0.20948811 0.228552763 +-0.209634504 0.228719753 +-0.20978106 0.228886929 +-0.209927779 0.229054292 +-0.210074662 0.22922184 +-0.210221709 0.229389576 +-0.210368921 0.229557499 +-0.210516297 0.229725611 +-0.210663839 0.229893911 +-0.210811547 0.2300624 +-0.21095942 0.230231079 +-0.211107461 0.230399948 +-0.211255669 0.230569007 +-0.211404044 0.230738258 +-0.211552588 0.230907701 +-0.2117013 0.231077336 +-0.211850181 0.231247163 +-0.211999232 0.231417184 +-0.212148452 0.231587399 +-0.212297843 0.231757808 +-0.212447405 0.231928412 +-0.212597138 0.232099212 +-0.212747044 0.232270207 +-0.212897121 0.232441399 +-0.213047371 0.232612788 +-0.213197795 0.232784375 +-0.213348392 0.232956159 +-0.213499163 0.233128143 +-0.213650109 0.233300326 +-0.213801231 0.233472708 +-0.213952528 0.233645291 +-0.214104001 0.233818075 +-0.21425565 0.23399106 +-0.214407477 0.234164247 +-0.214559482 0.234337637 +-0.214711664 0.234511229 +-0.214864025 0.234685026 +-0.215016566 0.234859027 +-0.215169285 0.235033232 +-0.215322185 0.235207643 +-0.215475266 0.23538226 +-0.215628527 0.235557083 +-0.21578197 0.235732114 +-0.215935595 0.235907352 +-0.216089403 0.236082799 +-0.216243394 0.236258454 +-0.216397568 0.236434318 +-0.216551927 0.236610393 +-0.21670647 0.236786678 +-0.216861199 0.236963174 +-0.217016113 0.237139882 +-0.217171213 0.237316803 +-0.2173265 0.237493936 +-0.217481974 0.237671283 +-0.217637635 0.237848844 +-0.217793485 0.23802662 +-0.217949524 0.23820461 +-0.218105752 0.238382817 +-0.21826217 0.238561241 +-0.218418779 0.238739881 +-0.218575578 0.238918739 +-0.218732569 0.239097816 +-0.218889751 0.239277111 +-0.219047127 0.239456626 +-0.219204695 0.239636361 +-0.219362457 0.239816317 +-0.219520413 0.239996495 +-0.219678563 0.240176894 +-0.219836909 0.240357516 +-0.219995451 0.240538362 +-0.220154188 0.240719431 +-0.220313123 0.240900725 +-0.220472256 0.241082243 +-0.220631586 0.241263988 +-0.220791114 0.241445959 +-0.220950842 0.241628158 +-0.22111077 0.241810583 +-0.221270898 0.241993238 +-0.221431226 0.242176121 +-0.221591756 0.242359234 +-0.221752488 0.242542577 +-0.221913422 0.242726151 +-0.222074559 0.242909957 +-0.2222359 0.243093995 +-0.222397446 0.243278266 +-0.222559196 0.243462771 +-0.222721151 0.243647509 +-0.222883313 0.243832483 +-0.22304568 0.244017692 +-0.223208255 0.244203138 +-0.223371038 0.24438882 +-0.223534029 0.24457474 +-0.223697229 0.244760898 +-0.223860639 0.244947295 +-0.224024258 0.245133932 +-0.224188089 0.245320809 +-0.22435213 0.245507927 +-0.224516384 0.245695286 +-0.22468085 0.245882888 +-0.224845529 0.246070733 +-0.225010421 0.246258822 +-0.225175528 0.246447155 +-0.22534085 0.246635734 +-0.225506388 0.246824558 +-0.225672142 0.247013628 +-0.225838112 0.247202946 +-0.2260043 0.247392512 +-0.226170706 0.247582327 +-0.226337331 0.247772391 +-0.226504175 0.247962705 +-0.226671239 0.248153269 +-0.226838523 0.248344086 +-0.227006028 0.248535154 +-0.227173756 0.248726476 +-0.227341706 0.248918051 +-0.227509879 0.249109881 +-0.227678275 0.249301966 +-0.227846896 0.249494307 +-0.228015742 0.249686904 +-0.228184814 0.249879759 +-0.228354112 0.250072872 +-0.228523637 0.250266244 +-0.22869339 0.250459875 +-0.228863371 0.250653767 +-0.229033581 0.25084792 +-0.229204021 0.251042335 +-0.229374691 0.251237013 +-0.229545592 0.251431954 +-0.229716724 0.251627159 +-0.229888089 0.251822629 +-0.230059687 0.252018365 +-0.230231518 0.252214367 +-0.230403584 0.252410636 +-0.230575885 0.252607174 +-0.230748422 0.25280398 +-0.230921195 0.253001056 +-0.231094205 0.253198403 +-0.231267453 0.25339602 +-0.231440939 0.25359391 +-0.231614664 0.253792072 +-0.23178863 0.253990508 +-0.231962836 0.254189218 +-0.232137283 0.254388204 +-0.232311972 0.254587465 +-0.232486904 0.254787003 +-0.232662079 0.254986819 +-0.232837499 0.255186913 +-0.233013163 0.255387287 +-0.233189073 0.25558794 +-0.233365229 0.255788875 +-0.233541632 0.255990091 +-0.233718283 0.25619159 +-0.233895182 0.256393372 +-0.23407233 0.256595438 +-0.234249729 0.256797789 +-0.234427378 0.257000426 +-0.234605279 0.25720335 +-0.234783431 0.257406561 +-0.234961837 0.257610061 +-0.235140496 0.257813851 +-0.23531941 0.25801793 +-0.235498579 0.2582223 +-0.235678003 0.258426962 +-0.235857685 0.258631917 +-0.236037624 0.258837166 +-0.236217821 0.259042709 +-0.236398277 0.259248547 +-0.236578992 0.259454682 +-0.236759969 0.259661114 +-0.236941206 0.259867843 +-0.237122706 0.260074872 +-0.237304469 0.2602822 +-0.237486495 0.260489829 +-0.237668785 0.26069776 +-0.237851341 0.260905993 +-0.238034163 0.26111453 +-0.238217252 0.261323371 +-0.238400608 0.261532517 +-0.238584233 0.261741969 +-0.238768127 0.261951728 +-0.238952291 0.262161795 +-0.239136726 0.262372172 +-0.239321433 0.262582858 +-0.239506412 0.262793854 +-0.239691664 0.263005163 +-0.23987719 0.263216784 +-0.240062992 0.263428718 +-0.240249069 0.263640968 +-0.240435423 0.263853532 +-0.240622054 0.264066413 +-0.240808964 0.264279612 +-0.240996153 0.264493129 +-0.241183621 0.264706965 +-0.241371371 0.264921121 +-0.241559402 0.265135599 +-0.241747716 0.265350399 +-0.241936313 0.265565522 +-0.242125195 0.26578097 +-0.242314362 0.265996742 +-0.242503814 0.266212841 +-0.242693554 0.266429267 +-0.242883581 0.266646021 +-0.243073897 0.266863104 +-0.243264503 0.267080518 +-0.243455399 0.267298263 +-0.243646586 0.26751634 +-0.243838065 0.26773475 +-0.244029838 0.267953494 +-0.244221904 0.268172574 +-0.244414265 0.26839199 +-0.244606923 0.268611743 +-0.244799876 0.268831835 +-0.244993128 0.269052266 +-0.245186678 0.269273037 +-0.245380527 0.26949415 +-0.245574677 0.269715606 +-0.245769128 0.269937405 +-0.245963881 0.270159549 +-0.246158938 0.270382039 +-0.246354299 0.270604876 +-0.246549964 0.27082806 +-0.246745936 0.271051594 +-0.246942215 0.271275477 +-0.247138801 0.271499712 +-0.247335697 0.271724299 +-0.247532902 0.271949239 +-0.247730418 0.272174534 +-0.247928245 0.272400184 +-0.248126386 0.272626191 +-0.24832484 0.272852555 +-0.248523609 0.273079279 +-0.248722693 0.273306362 +-0.248922095 0.273533807 +-0.249121813 0.273761614 +-0.249321851 0.273989784 +-0.249522208 0.274218319 +-0.249722886 0.274447219 +-0.249923885 0.274676486 +-0.250125207 0.274906122 +-0.250326853 0.275136126 +-0.250528823 0.275366501 +-0.250731119 0.275597247 +-0.250933742 0.275828366 +-0.251136692 0.276059858 +-0.251339972 0.276291726 +-0.251543581 0.27652397 +-0.251747521 0.276756591 +-0.251951793 0.27698959 +-0.252156398 0.27722297 +-0.252361338 0.27745673 +-0.252566612 0.277690873 +-0.252772222 0.277925399 +-0.25297817 0.278160309 +-0.253184456 0.278395606 +-0.253391081 0.278631289 +-0.253598047 0.278867361 +-0.253805354 0.279103822 +-0.254013004 0.279340674 +-0.254220998 0.279577918 +-0.254429337 0.279815556 +-0.254638021 0.280053588 +-0.254847053 0.280292015 +-0.255056433 0.28053084 +-0.255266162 0.280770063 +-0.255476241 0.281009686 +-0.255686672 0.281249709 +-0.255897456 0.281490135 +-0.256108593 0.281730965 +-0.256320086 0.281972199 +-0.256531934 0.282213839 +-0.25674414 0.282455887 +-0.256956704 0.282698343 +-0.257169628 0.28294121 +-0.257382912 0.283184487 +-0.257596559 0.283428178 +-0.257810568 0.283672282 +-0.258024942 0.283916802 +-0.258239681 0.284161739 +-0.258454786 0.284407094 +-0.25867026 0.284652868 +-0.258886102 0.284899063 +-0.259102315 0.285145681 +-0.259318899 0.285392722 +-0.259535856 0.285640187 +-0.259753186 0.28588808 +-0.259970892 0.2861364 +-0.260188974 0.286385149 +-0.260407434 0.286634328 +-0.260626272 0.28688394 +-0.26084549 0.287133985 +-0.26106509 0.287384465 +-0.261285072 0.287635381 +-0.261505437 0.287886735 +-0.261726188 0.288138527 +-0.261947326 0.288390761 +-0.26216885 0.288643436 +-0.262390764 0.288896555 +-0.262613068 0.289150119 +-0.262835763 0.289404129 +-0.263058851 0.289658588 +-0.263282333 0.289913495 +-0.263506211 0.290168854 +-0.263730485 0.290424665 +-0.263955157 0.290680929 +-0.264180228 0.29093765 +-0.2644057 0.291194827 +-0.264631575 0.291452462 +-0.264857852 0.291710558 +-0.265084534 0.291969115 +-0.265311622 0.292228135 +-0.265539118 0.292487619 +-0.265767022 0.29274757 +-0.265995336 0.293007989 +-0.266224062 0.293268877 +-0.266453201 0.293530235 +-0.266682754 0.293792067 +-0.266912723 0.294054372 +-0.267143109 0.294317153 +-0.267373913 0.294580411 +-0.267605137 0.294844148 +-0.267836783 0.295108365 +-0.268068851 0.295373065 +-0.268301344 0.295638248 +-0.268534262 0.295903917 +-0.268767607 0.296170073 +-0.26900138 0.296436717 +-0.269235584 0.296703852 +-0.269470219 0.296971479 +-0.269705287 0.297239599 +-0.269940789 0.297508215 +-0.270176728 0.297777328 +-0.270413103 0.29804694 +-0.270649918 0.298317052 +-0.270887172 0.298587666 +-0.271124869 0.298858784 +-0.271363009 0.299130408 +-0.271601594 0.29940254 +-0.271840625 0.29967518 +-0.272080104 0.299948331 +-0.272320033 0.300221995 +-0.272560413 0.300496173 +-0.272801245 0.300770868 +-0.273042532 0.30104608 +-0.273284274 0.301321812 +-0.273526474 0.301598066 +-0.273769133 0.301874843 +-0.274012252 0.302152145 +-0.274255833 0.302429975 +-0.274499878 0.302708333 +-0.274744388 0.302987221 +-0.274989365 0.303266642 +-0.275234811 0.303546598 +-0.275480727 0.30382709 +-0.275727115 0.30410812 +-0.275973976 0.304389689 +-0.276221312 0.304671801 +-0.276469126 0.304954457 +-0.276717417 0.305237658 +-0.276966189 0.305521407 +-0.277215443 0.305805705 +-0.27746518 0.306090555 +-0.277715403 0.306375958 +-0.277966113 0.306661916 +-0.278217311 0.306948432 +-0.278468999 0.307235507 +-0.27872118 0.307523143 +-0.278973855 0.307811343 +-0.279227025 0.308100108 +-0.279480693 0.30838944 +-0.27973486 0.308679341 +-0.279989528 0.308969814 +-0.280244699 0.30926086 +-0.280500374 0.309552481 +-0.280756555 0.309844679 +-0.281013245 0.310137458 +-0.281270444 0.310430817 +-0.281528155 0.310724761 +-0.28178638 0.31101929 +-0.282045121 0.311314406 +-0.282304378 0.311610113 +-0.282564155 0.311906412 +-0.282824453 0.312203305 +-0.283085273 0.312500794 +-0.283346619 0.312798882 +-0.283608491 0.31309757 +-0.283870892 0.313396861 +-0.284133823 0.313696757 +-0.284397286 0.313997261 +-0.284661284 0.314298373 +-0.284925818 0.314600097 +-0.285190891 0.314902435 +-0.285456503 0.315205389 +-0.285722658 0.315508962 +-0.285989357 0.315813154 +-0.286256602 0.31611797 +-0.286524395 0.31642341 +-0.286792738 0.316729478 +-0.287061634 0.317036176 +-0.287331083 0.317343506 +-0.287601089 0.317651469 +-0.287871652 0.31796007 +-0.288142777 0.318269309 +-0.288414463 0.31857919 +-0.288686714 0.318889714 +-0.288959531 0.319200884 +-0.289232917 0.319512703 +-0.289506874 0.319825172 +-0.289781403 0.320138295 +-0.290056507 0.320452073 +-0.290332189 0.32076651 +-0.290608449 0.321081606 +-0.290885291 0.321397366 +-0.291162717 0.321713792 +-0.291440728 0.322030885 +-0.291719327 0.322348648 +-0.291998516 0.322667085 +-0.292278297 0.322986197 +-0.292558673 0.323305986 +-0.292839645 0.323626457 +-0.293121217 0.32394761 +-0.293403389 0.324269449 +-0.293686165 0.324591976 +-0.293969547 0.324915194 +-0.294253537 0.325239105 +-0.294538137 0.325563713 +-0.29482335 0.325889019 +-0.295109178 0.326215026 +-0.295395623 0.326541737 +-0.295682687 0.326869154 +-0.295970374 0.327197281 +-0.296258685 0.32752612 +-0.296547622 0.327855674 +-0.296837189 0.328185945 +-0.297127387 0.328516936 +-0.297418219 0.32884865 +-0.297709687 0.329181089 +-0.298001794 0.329514257 +-0.298294542 0.329848156 +-0.298587934 0.33018279 +-0.298881972 0.33051816 +-0.299176659 0.330854269 +-0.299471997 0.331191121 +-0.299767988 0.331528719 +-0.300064635 0.331867065 +-0.300361942 0.332206162 +-0.300659909 0.332546012 +-0.30095854 0.33288662 +-0.301257837 0.333227988 +-0.301557804 0.333570119 +-0.301858442 0.333913015 +-0.302159754 0.33425668 +-0.302461743 0.334601117 +-0.302764411 0.334946329 +-0.303067761 0.335292318 +-0.303371796 0.335639089 +-0.303676519 0.335986643 +-0.303981931 0.336334984 +-0.304288037 0.336684116 +-0.304594838 0.33703404 +-0.304902337 0.337384761 +-0.305210537 0.337736281 +-0.305519441 0.338088604 +-0.305829051 0.338441732 +-0.306139371 0.33879567 +-0.306450403 0.339150419 +-0.30676215 0.339505984 +-0.307074615 0.339862367 +-0.307387801 0.340219573 +-0.30770171 0.340577603 +-0.308016345 0.340936462 +-0.30833171 0.341296152 +-0.308647807 0.341656678 +-0.308964639 0.342018041 +-0.309282209 0.342380247 +-0.309600521 0.342743297 +-0.309919576 0.343107196 +-0.310239378 0.343471947 +-0.310559931 0.343837553 +-0.310881236 0.344204018 +-0.311203297 0.344571345 +-0.311526118 0.344939538 +-0.311849701 0.345308599 +-0.312174049 0.345678534 +-0.312499165 0.346049345 +-0.312825053 0.346421035 +-0.313151716 0.346793609 +-0.313479156 0.34716707 +-0.313807377 0.347541421 +-0.314136383 0.347916667 +-0.314466175 0.34829281 +-0.314796758 0.348669855 +-0.315128136 0.349047805 +-0.31546031 0.349426664 +-0.315793284 0.349806436 +-0.316127062 0.350187124 +-0.316461647 0.350568732 +-0.316797042 0.350951264 +-0.317133251 0.351334724 +-0.317470277 0.351719115 +-0.317808122 0.352104442 +-0.318146792 0.352490709 +-0.318486289 0.352877918 +-0.318826616 0.353266075 +-0.319167778 0.353655182 +-0.319509777 0.354045245 +-0.319852617 0.354436267 +-0.320196301 0.354828251 +-0.320540833 0.355221203 +-0.320886217 0.355615126 +-0.321232457 0.356010024 +-0.321579554 0.356405901 +-0.321927515 0.356802762 +-0.322276341 0.35720061 +-0.322626037 0.35759945 +-0.322976606 0.357999285 +-0.323328052 0.358400121 +-0.323680379 0.358801961 +-0.32403359 0.359204809 +-0.324387689 0.359608671 +-0.32474268 0.360013549 +-0.325098567 0.360419449 +-0.325455354 0.360826374 +-0.325813044 0.36123433 +-0.326171641 0.361643321 +-0.326531149 0.36205335 +-0.326891573 0.362464423 +-0.327252915 0.362876543 +-0.32761518 0.363289716 +-0.327978372 0.363703946 +-0.328342495 0.364119238 +-0.328707553 0.364535595 +-0.32907355 0.364953023 +-0.32944049 0.365371527 +-0.329808376 0.36579111 +-0.330177214 0.366211778 +-0.330547007 0.366633536 +-0.33091776 0.367056387 +-0.331289476 0.367480337 +-0.33166216 0.367905391 +-0.332035816 0.368331553 +-0.332410448 0.368758829 +-0.332786061 0.369187223 +-0.333162659 0.36961674 +-0.333540246 0.370047384 +-0.333918826 0.370479162 +-0.334298405 0.370912078 +-0.334678985 0.371346136 +-0.335060573 0.371781343 +-0.335443171 0.372217702 +-0.335826786 0.37265522 +-0.33621142 0.373093901 +-0.336597079 0.373533751 +-0.336983767 0.373974774 +-0.33737149 0.374416976 +-0.33776025 0.374860362 +-0.338150054 0.375304938 +-0.338540905 0.375750709 +-0.338932809 0.376197679 +-0.33932577 0.376645855 +-0.339719793 0.377095242 +-0.340114883 0.377545845 +-0.340511044 0.37799767 +-0.340908281 0.378450723 +-0.341306599 0.378905008 +-0.341706004 0.379360531 +-0.3421065 0.379817299 +-0.342508091 0.380275316 +-0.342910784 0.380734589 +-0.343314582 0.381195123 +-0.343719491 0.381656924 +-0.344125516 0.382119997 +-0.344532663 0.382584349 +-0.344940936 0.383049985 +-0.34535034 0.383516911 +-0.345760881 0.383985133 +-0.346172563 0.384454657 +-0.346585393 0.38492549 +-0.346999375 0.385397636 +-0.347414515 0.385871103 +-0.347830818 0.386345895 +-0.348248289 0.38682202 +-0.348666934 0.387299484 +-0.349086758 0.387778292 +-0.349507768 0.388258452 +-0.349929967 0.388739969 +-0.350353363 0.389222849 +-0.35077796 0.389707099 +-0.351203764 0.390192726 +-0.351630781 0.390679736 +-0.352059016 0.391168135 +-0.352488476 0.39165793 +-0.352919165 0.392149128 +-0.35335109 0.392641734 +-0.353784257 0.393135757 +-0.354218671 0.393631201 +-0.354654338 0.394128075 +-0.355091265 0.394626385 +-0.355529457 0.395126138 +-0.355968921 0.39562734 +-0.356409662 0.396129999 +-0.356851686 0.396634122 +-0.357295 0.397139715 +-0.35773961 0.397646785 +-0.358185521 0.39815534 +-0.358632741 0.398665387 +-0.359081276 0.399176933 +-0.359531131 0.399689985 +-0.359982314 0.400204551 +-0.36043483 0.400720637 +-0.360888686 0.401238251 +-0.361343889 0.401757401 +-0.361800446 0.402278094 +-0.362258362 0.402800337 +-0.362717644 0.403324138 +-0.363178299 0.403849505 +-0.363640335 0.404376446 +-0.364103756 0.404904967 +-0.364568571 0.405435077 +-0.365034786 0.405966784 +-0.365502409 0.406500095 +-0.365971445 0.407035018 +-0.366441902 0.407571561 +-0.366913787 0.408109733 +-0.367387107 0.408649541 +-0.36786187 0.409190994 +-0.368338081 0.409734099 +-0.368815749 0.410278865 +-0.369294881 0.4108253 +-0.369775484 0.411373412 +-0.370257566 0.41192321 +-0.370741133 0.412474703 +-0.371226194 0.413027898 +-0.371712755 0.413582805 +-0.372200825 0.414139431 +-0.372690411 0.414697786 +-0.37318152 0.415257878 +-0.373674161 0.415819717 +-0.374168341 0.41638331 +-0.374664067 0.416948667 +-0.375161349 0.417515797 +-0.375660193 0.418084709 +-0.376160608 0.418655412 +-0.376662601 0.419227914 +-0.377166181 0.419802226 +-0.377671356 0.420378356 +-0.378178134 0.420956315 +-0.378686523 0.42153611 +-0.379196532 0.422117752 +-0.379708169 0.422701251 +-0.380221442 0.423286615 +-0.38073636 0.423873855 +-0.381252931 0.42446298 +-0.381771164 0.425053999 +-0.382291068 0.425646924 +-0.382812651 0.426241764 +-0.383335922 0.426838528 +-0.38386089 0.427437227 +-0.384387563 0.428037871 +-0.384915952 0.42864047 +-0.385446064 0.429245035 +-0.385977909 0.429851575 +-0.386511496 0.430460102 +-0.387046834 0.431070625 +-0.387583932 0.431683156 +-0.3881228 0.432297704 +-0.388663447 0.432914281 +-0.389205883 0.433532898 +-0.389750117 0.434153564 +-0.390296159 0.434776292 +-0.390844018 0.435401092 +-0.391393705 0.436027976 +-0.391945228 0.436656954 +-0.392498598 0.437288038 +-0.393053825 0.437921239 +-0.393610919 0.438556568 +-0.394169889 0.439194038 +-0.394730747 0.439833659 +-0.395293502 0.440475443 +-0.395858164 0.441119403 +-0.396424745 0.441765549 +-0.396993254 0.442413894 +-0.397563701 0.44306445 +-0.398136099 0.443717229 +-0.398710457 0.444372243 +-0.399286785 0.445029505 +-0.399865096 0.445689026 +-0.400445399 0.446350819 +-0.401027707 0.447014897 +-0.401612029 0.447681273 +-0.402198377 0.448349958 +-0.402786762 0.449020967 +-0.403377197 0.449694311 +-0.403969691 0.450370004 +-0.404564257 0.451048059 +-0.405160906 0.45172849 +-0.405759649 0.452411309 +-0.4063605 0.453096529 +-0.406963469 0.453784166 +-0.407568568 0.454474231 +-0.408175809 0.455166739 +-0.408785205 0.455861703 +-0.409396768 0.456559138 +-0.41001051 0.457259058 +-0.410626443 0.457961476 +-0.41124458 0.458666407 +-0.411864934 0.459373865 +-0.412487517 0.460083864 +-0.413112342 0.46079642 +-0.413739421 0.461511547 +-0.414368768 0.46222926 +-0.415000397 0.462949573 +-0.415634319 0.463672501 +-0.416270548 0.464398061 +-0.416909098 0.465126266 +-0.417549983 0.465857132 +-0.418193215 0.466590676 +-0.418838808 0.467326912 +-0.419486777 0.468065855 +-0.420137135 0.468807523 +-0.420789895 0.469551931 +-0.421445073 0.470299095 +-0.422102683 0.471049031 +-0.422762738 0.471801755 +-0.423425254 0.472557285 +-0.424090244 0.473315636 +-0.424757724 0.474076826 +-0.425427708 0.474840871 +-0.426100211 0.475607788 +-0.426775249 0.476377595 +-0.427452836 0.477150308 +-0.428132987 0.477925946 +-0.428815719 0.478704525 +-0.429501046 0.479486063 +-0.430188984 0.480270579 +-0.430879549 0.481058089 +-0.431572758 0.481848613 +-0.432268625 0.482642169 +-0.432967167 0.483438774 +-0.4336684 0.484238448 +-0.434372341 0.485041209 +-0.435079007 0.485847076 +-0.435788413 0.486656068 +-0.436500577 0.487468204 +-0.437215516 0.488283504 +-0.437933247 0.489101987 +-0.438653787 0.489923673 +-0.439377153 0.490748581 +-0.440103363 0.491576732 +-0.440832435 0.492408145 +-0.441564386 0.493242841 +-0.442299235 0.494080841 +-0.443036999 0.494922165 +-0.443777697 0.495766833 +-0.444521347 0.496614867 +-0.445267968 0.497466289 +-0.446017578 0.498321118 +-0.446770197 0.499179378 +-0.447525843 0.500041089 +-0.448284536 0.500906274 +-0.449046295 0.501774954 +-0.449811139 0.502647152 +-0.450579088 0.50352289 +-0.451350162 0.504402191 +-0.452124382 0.505285078 +-0.452901766 0.506171573 +-0.453682336 0.5070617 +-0.454466113 0.507955483 +-0.455253116 0.508852945 +-0.456043367 0.509754109 +-0.456836887 0.510659 +-0.457633697 0.511567643 +-0.458433819 0.512480061 +-0.459237274 0.513396279 +-0.460044083 0.514316322 +-0.46085427 0.515240215 +-0.461667857 0.516167984 +-0.462484865 0.517099654 +-0.463305317 0.518035251 +-0.464129236 0.5189748 +-0.464956646 0.519918329 +-0.465787568 0.520865862 +-0.466622028 0.521817428 +-0.467460047 0.522773053 +-0.468301651 0.523732764 +-0.469146863 0.524696589 +-0.469995707 0.525664555 +-0.470848209 0.52663669 +-0.471704392 0.527613023 +-0.472564281 0.528593581 +-0.473427902 0.529578393 +-0.47429528 0.530567489 +-0.475166441 0.531560897 +-0.47604141 0.532558647 +-0.476920214 0.533560769 +-0.477802879 0.534567292 +-0.47868943 0.535578247 +-0.479579897 0.536593664 +-0.480474304 0.537613575 +-0.48137268 0.53863801 +-0.482275051 0.539667001 +-0.483181447 0.540700578 +-0.484091894 0.541738776 +-0.485006422 0.542781625 +-0.485925058 0.543829158 +-0.486847832 0.544881408 +-0.487774773 0.545938408 +-0.48870591 0.547000192 +-0.489641272 0.548066793 +-0.49058089 0.549138247 +-0.491524794 0.550214586 +-0.492473015 0.551295846 +-0.493425583 0.552382062 +-0.494382529 0.55347327 +-0.495343884 0.554569504 +-0.496309682 0.555670803 +-0.497279952 0.5567772 +-0.498254728 0.557888735 +-0.499234043 0.559005443 +-0.500217929 0.560127363 +-0.501206419 0.561254532 +-0.502199548 0.562386988 +-0.503197348 0.563524771 +-0.504199855 0.564667918 +-0.505207102 0.56581647 +-0.506219125 0.566970467 +-0.507235959 0.568129948 +-0.508257639 0.569294954 +-0.509284202 0.570465526 +-0.510315684 0.571641706 +-0.511352121 0.572823534 +-0.51239355 0.574011054 +-0.51344001 0.575204308 +-0.514491537 0.57640334 +-0.51554817 0.577608191 +-0.516609947 0.578818907 +-0.517676907 0.580035532 +-0.51874909 0.581258111 +-0.519826535 0.582486689 +-0.520909282 0.583721311 +-0.521997372 0.584962024 +-0.523090847 0.586208874 +-0.524189746 0.587461909 +-0.525294112 0.588721177 +-0.526403987 0.589986724 +-0.527519415 0.591258601 +-0.528640437 0.592536855 +-0.529767097 0.593821537 +-0.53089944 0.595112697 +-0.53203751 0.596410386 +-0.533181352 0.597714654 +-0.534331011 0.599025553 +-0.535486533 0.600343136 +-0.536647964 0.601667456 +-0.537815351 0.602998565 +-0.538988742 0.604336518 +-0.540168184 0.605681369 +-0.541353726 0.607033174 +-0.542545416 0.608391987 +-0.543743304 0.609757866 +-0.544947441 0.611130867 +-0.546157875 0.612511048 +-0.547374658 0.613898466 +-0.548597842 0.615293181 +-0.549827479 0.616695251 +-0.551063622 0.618104738 +-0.552306323 0.619521701 +-0.553555637 0.620946201 +-0.554811618 0.622378302 +-0.556074321 0.623818065 +-0.557343801 0.625265554 +-0.558620115 0.626720833 +-0.55990332 0.628183967 +-0.561193473 0.629655021 +-0.562490632 0.631134062 +-0.563794856 0.632621156 +-0.565106204 0.634116372 +-0.566424738 0.635619777 +-0.567750516 0.637131441 +-0.569083601 0.638651434 +-0.570424055 0.640179827 +-0.571771941 0.641716692 +-0.573127323 0.643262101 +-0.574490264 0.644816127 +-0.57586083 0.646378844 +-0.577239086 0.647950327 +-0.5786251 0.649530653 +-0.580018937 0.651119898 +-0.581420668 0.65271814 +-0.58283036 0.654325456 +-0.584248083 0.655941927 +-0.585673907 0.657567633 +-0.587107905 0.659202655 +-0.588550147 0.660847075 +-0.590000708 0.662500977 +-0.591459661 0.664164445 +-0.592927081 0.665837564 +-0.594403044 0.667520421 +-0.595887625 0.669213102 +-0.597380904 0.670915696 +-0.598882957 0.672628292 +-0.600393864 0.674350981 +-0.601913707 0.676083854 +-0.603442565 0.677827004 +-0.604980522 0.679580525 +-0.60652766 0.681344511 +-0.608084064 0.683119059 +-0.60964982 0.684904266 +-0.611225013 0.68670023 +-0.612809731 0.688507051 +-0.614404063 0.69032483 +-0.616008098 0.69215367 +-0.617621927 0.693993673 +-0.619245643 0.695844944 +-0.620879337 0.697707589 +-0.622523105 0.699581717 +-0.624177041 0.701467434 +-0.625841243 0.703364853 +-0.627515808 0.705274083 +-0.629200835 0.707195238 +-0.630896425 0.709128433 +-0.632602679 0.711073782 +-0.634319701 0.713031405 +-0.636047594 0.715001418 +-0.637786464 0.716983944 +-0.639536419 0.718979103 +-0.641297566 0.720987019 +-0.643070016 0.723007818 +-0.644853879 0.725041626 +-0.646649269 0.727088571 +-0.6484563 0.729148785 +-0.650275087 0.731222398 +-0.652105748 0.733309544 +-0.653948401 0.735410359 +-0.655803167 0.73752498 +-0.657670169 0.739653546 +-0.659549529 0.741796198 +-0.661441374 0.743953079 +-0.663345829 0.746124333 +-0.665263025 0.748310108 +-0.667193091 0.750510552 +-0.66913616 0.752725816 +-0.671092366 0.754956053 +-0.673061846 0.757201418 +-0.675044736 0.759462068 +-0.677041178 0.761738162 +-0.679051311 0.764029862 +-0.681075282 0.766337331 +-0.683113234 0.768660737 +-0.685165317 0.771000246 +-0.687231679 0.773356031 +-0.689312474 0.775728264 +-0.691407854 0.778117121 +-0.693517978 0.78052278 +-0.695643002 0.782945422 +-0.697783089 0.785385231 +-0.699938401 0.787842391 +-0.702109105 0.790317094 +-0.704295368 0.792809528 +-0.70649736 0.79531989 +-0.708715256 0.797848376 +-0.710949229 0.800395186 +-0.71319946 0.802960523 +-0.715466127 0.805544593 +-0.717749415 0.808147605 +-0.720049511 0.810769772 +-0.722366602 0.813411308 +-0.724700881 0.816072433 +-0.727052543 0.818753367 +-0.729421785 0.821454337 +-0.731808809 0.824175572 +-0.734213817 0.826917302 +-0.736637017 0.829679765 +-0.739078619 0.832463199 +-0.741538836 0.835267848 +-0.744017886 0.838093958 +-0.746515987 0.84094178 +-0.749033364 0.843811569 +-0.751570243 0.846703583 +-0.754126855 0.849618085 +-0.756703435 0.852555342 +-0.75930022 0.855515625 +-0.761917451 0.858499209 +-0.764555376 0.861506374 +-0.767214242 0.864537405 +-0.769894304 0.86759259 +-0.77259582 0.870672223 +-0.77531905 0.873776603 +-0.778064263 0.876906032 +-0.780831727 0.880060818 +-0.783621718 0.883241276 +-0.786434516 0.886447723 +-0.789270405 0.889680484 +-0.792129673 0.892939887 +-0.795012615 0.896226267 +-0.797919529 0.899539964 +-0.800850719 0.902881325 +-0.803806493 0.906250701 +-0.806787167 0.909648451 +-0.80979306 0.913074938 +-0.812824496 0.916530532 +-0.815881806 0.920015611 +-0.818965328 0.923530557 +-0.822075402 0.927075761 +-0.825212377 0.930651619 +-0.828376608 0.934258535 +-0.831568455 0.937896919 +-0.834788286 0.94156719 +-0.838036473 0.945269774 +-0.841313397 0.949005102 +-0.844619445 0.952773617 +-0.847955011 0.956575766 +-0.851320496 0.960412008 +-0.854716309 0.964282807 +-0.858142865 0.968188636 +-0.861600589 0.97212998 +-0.865089911 0.976107328 +-0.868611271 0.980121182 +-0.872165116 0.984172051 +-0.875751903 0.988260455 +-0.879372096 0.992386922 +-0.883026168 0.996551993 +-0.886714601 1.00075622 +-0.890437888 1.00500015 +-0.894196528 1.00928437 +-0.897991033 1.01360945 +-0.901821923 1.01797599 +-0.905689729 1.02238459 +-0.909594991 1.02683587 +-0.91353826 1.03133045 +-0.917520101 1.03586898 +-0.921541085 1.04045211 +-0.925601798 1.0450805 +-0.929702837 1.04975484 +-0.93384481 1.05447582 +-0.938028339 1.05924415 +-0.942254057 1.06406054 +-0.94652261 1.06892574 +-0.95083466 1.07384049 +-0.955190878 1.07880557 +-0.959591954 1.08382176 +-0.964038588 1.08888985 +-0.968531498 1.09401066 +-0.973071414 1.09918503 +-0.977659085 1.1044138 +-0.982295273 1.10969785 +-0.986980758 1.11503807 +-0.991716336 1.12043535 +-0.996502821 1.12589063 +-1.00134104 1.13140485 +-1.00623185 1.13697899 +-1.01117612 1.14261402 +-1.01617473 1.14831097 +-1.02122859 1.15407086 +-1.02633862 1.15989474 +-1.03150579 1.16578371 +-1.03673105 1.17173886 +-1.04201539 1.17776133 +-1.04735984 1.18385227 +-1.05276543 1.19001285 +-1.05823322 1.1962443 +-1.06376429 1.20254784 +-1.06935977 1.20892475 +-1.07502079 1.21537633 +-1.08074852 1.22190389 +-1.08654414 1.22850879 +-1.09240888 1.23519244 +-1.098344 1.24195625 +-1.10435076 1.24880168 +-1.1104305 1.25573024 +-1.11658454 1.26274344 +-1.12281428 1.26984287 +-1.12912111 1.27703012 +-1.13550651 1.28430685 +-1.14197193 1.29167476 +-1.14851892 1.29913557 +-1.15514903 1.30669106 +-1.16186386 1.31434305 +-1.16866505 1.32209343 +-1.1755543 1.3299441 +-1.18253333 1.33789703 +-1.18960392 1.34595426 +-1.19676788 1.35411785 +-1.2040271 1.36238993 +-1.21138349 1.3707727 +-1.21883903 1.3792684 +-1.22639574 1.38787934 +-1.23405571 1.39660789 +-1.24182108 1.40545649 +-1.24969406 1.41442765 +-1.25767689 1.42352393 +-1.26577192 1.432748 +-1.27398153 1.44210258 +-1.28230818 1.45159046 +-1.2907544 1.46121454 +-1.29932281 1.47097777 +-1.30801608 1.48088321 +-1.31683697 1.490934 +-1.32578834 1.50113339 +-1.33487309 1.5114847 +-1.34409426 1.52199137 +-1.35345496 1.53265695 +-1.36295837 1.54348506 +-1.37260781 1.55447949 +-1.38240669 1.5656441 +-1.39235851 1.57698288 +-1.4024669 1.58849998 +-1.41273559 1.60019963 +-1.42316844 1.61208624 +-1.43376944 1.62416434 +-1.44454271 1.63643861 +-1.45549248 1.64891389 +-1.46662315 1.66159518 +-1.47793925 1.67448763 +-1.48944548 1.68759659 +-1.50114667 1.70092758 +-1.51304786 1.7144863 +-1.52515422 1.72827867 +-1.53747113 1.7423108 +-1.55000415 1.75658901 +-1.56275902 1.77111986 +-1.57574173 1.78591014 +-1.58895843 1.80096688 +-1.60241555 1.81629737 +-1.61611972 1.83190916 +-1.63007782 1.84781011 +-1.64429701 1.86400835 +-1.65878469 1.88051231 +-1.67354858 1.89733077 +-1.68859666 1.91447283 +-1.70393726 1.93194794 +-1.719579 1.94976594 +-1.73553087 1.96793706 +-1.75180222 1.98647193 +-1.76840275 2.00538161 +-1.7853426 2.02467762 +-1.80263231 2.04437197 +-1.82028285 2.06447715 +-1.83830567 2.08500618 +-1.8567127 2.10597267 +-1.87551641 2.12739077 +-1.89472979 2.14927529 +-1.9143664 2.17164167 +-1.93444042 2.19450604 +-1.95496668 2.21788529 +-1.97596067 2.24179703 +-1.9974386 2.26625973 +-2.01941745 2.29129271 +-2.04191498 2.3169162 +-2.06494984 2.34315139 +-2.08854154 2.37002053 +-2.11271057 2.39754693 +-2.13747846 2.42575507 +-2.16286778 2.45467067 +-2.18890228 2.48432076 +-2.21560694 2.51473376 +-2.24300802 2.54593958 +-2.2711332 2.5779697 +-2.30001164 2.61085733 +-2.32967408 2.64463746 +-2.36015296 2.67934702 +-2.39148255 2.715025 +-2.42369905 2.75171263 +-2.45684076 2.7894535 +-2.4909482 2.82829374 +-2.52606433 2.86828223 +-2.56223467 2.90947081 +-2.59950752 2.95191446 +-2.6379342 2.99567162 +-2.67756927 3.04080437 +-2.71847077 3.0873788 +-2.76070054 3.13546533 +-2.80432451 3.185139 +-2.84941306 3.23647996 +-2.89604138 3.28957381 +-2.94428993 3.34451216 +-2.99424485 3.40139312 +-3.04599855 3.46032189 +-3.0996502 3.52141142 +-3.15530644 3.58478315 +-3.21308205 3.6505678 +-3.27310077 3.7189063 +-3.33549617 3.78995079 +-3.40041266 3.86386577 +-3.46800662 3.94082938 +-3.53844766 4.02103485 +-3.61192003 4.10469211 +-3.6886243 4.1920297 +-3.76877915 4.28329681 +-3.85262346 4.3787657 +-3.94041877 4.47873447 +-4.03245197 4.58353015 +-4.12903848 4.69351236 +-4.23052588 4.80907744 +-4.33729814 4.93066329 +-4.44978053 5.05875495 +-4.56844528 5.1938912 +-4.69381832 5.33667216 +-4.82648714 5.48776833 +-4.96711005 5.64793124 +-5.11642724 5.8180061 +-5.27527392 5.99894692 +-5.44459616 6.19183462 +-5.62546986 6.39789892 +-5.81912394 6.61854494 +-6.02696858 6.85538574 +-6.25062997 7.11028228 +-6.49199347 7.38539318 +-6.7532574 7.68323683 +-7.03700106 8.00676984 +-7.3462711 8.35948692 +-7.68469265 8.74554958 +-8.05661382 9.16995352 +-8.46729581 9.63874932 +-8.92316636 10.1593372 +-9.43216292 10.7408669 +-10.0042045 11.3947882 +-10.6518524 12.1356245 +-11.3912556 12.9820819 +-12.2435317 13.9586746 +-13.2368423 15.098177 +-14.4096028 16.44543 +-15.8156258 18.063473 +-17.5327086 20.0438395 +-19.6776944 22.5247442 +-22.4345196 25.725249 +-26.1105037 30.0146063 +-31.2607457 36.0677846 +-39.000983 45.2647547 +-51.9540341 60.936509 +-78.0823507 93.692321 +-157.956029 204.902946 +1523.33464 -574.378009 +141.033634 -140.190896 +71.9900448 -75.3100725 +47.9099583 -50.9365354 +35.6054529 -38.0795528 +28.0713171 -30.0438232 +22.9110563 -24.4404109 +19.065499 -20.1787314 +15.9649867 -16.6450601 +13.2174779 -13.3758754 +10.4038834 -9.78980441 +6.64492263 -4.44564414 +-2.35390571 11.3710076 +77.6210274 -68.439366 +21.5161753 -25.6032607 +15.7723545 -18.7961413 +13.2894217 -15.7353414 +11.7721311 -13.8596931 +10.6902945 -12.5302371 +9.85210269 -11.5080831 +9.16935245 -10.6816295 +8.59474507 -9.99062965 +8.10003956 -9.39906636 +7.66698884 -8.8837164 +7.2830759 -8.42871327 +6.93930644 -8.02271385 +6.62897602 -7.65730999 +6.34693781 -7.32608372 +6.08914489 -7.02401675 +5.85235163 -6.74710581 +5.63391157 -6.49210308 +5.43163645 -6.25633552 +5.24369504 -6.03757591 +5.06853898 -5.83394846 +4.90484717 -5.64385857 +4.7514834 -5.46593938 +4.60746357 -5.29901063 +4.47192989 -5.14204644 +4.34413044 -4.99414984 +4.22340263 -4.85453233 +4.1091599 -4.72249736 +4.00088071 -4.59742686 +3.89809951 -4.47877014 +3.8003992 -4.36603464 +3.70740483 -4.25877829 +3.61877823 -4.15660298 +3.53421356 -4.05914912 +3.4534334 -3.96609098 +3.3761855 -3.8771327 +3.30223989 -3.79200488 +3.23138645 -3.71046162 +3.1634328 -3.63227797 +3.09820238 -3.55724771 +3.03553289 -3.4851814 +2.97527481 -3.41590468 +2.9172902 -3.34925678 +2.86145154 -3.28508922 +2.80764076 -3.22326461 +2.7557484 -3.16365563 +2.70567281 -3.10614414 +2.65731945 -3.05062031 +2.61060029 -2.99698195 +2.56543325 -2.9451338 +2.52174169 -2.89498698 +2.47945397 -2.84645842 +2.43850305 -2.79947045 +2.39882613 -2.75395031 +2.3603643 -2.70982979 +2.32306223 -2.66704487 +2.28686796 -2.6255354 +2.25173256 -2.58524482 +2.21761 -2.54611988 +2.18445685 -2.5081104 +2.15223218 -2.47116907 +2.12089732 -2.43525122 +2.09041573 -2.40031466 +2.06075285 -2.3663195 +2.03187599 -2.33322797 +2.00375416 -2.30100435 +1.97635799 -2.26961473 +1.94965964 -2.23902701 +1.92363265 -2.20921068 +1.89825191 -2.18013677 +1.87349354 -2.15177778 +1.84933483 -2.12410752 +1.82575416 -2.0971011 +1.80273095 -2.07073478 +1.78024558 -2.04498599 +1.75827934 -2.01983317 +1.7368144 -1.99525579 +1.71583371 -1.97123423 +1.69532101 -1.94774977 +1.67526076 -1.92478451 +1.65563808 -1.90232135 +1.63643877 -1.88034394 +1.61764921 -1.85883662 +1.59925638 -1.83778441 +1.5812478 -1.81717295 +1.5636115 -1.79698848 +1.54633602 -1.77721783 +1.52941035 -1.75784834 +1.51282394 -1.73886788 +1.49656665 -1.72026479 +1.48062875 -1.70202789 +1.46500087 -1.68414642 +1.44967403 -1.66661007 +1.43463958 -1.64940888 +1.41988921 -1.6325333 +1.40541489 -1.61597414 +1.39120894 -1.59972255 +1.37726393 -1.58376999 +1.3635727 -1.56810827 +1.35012836 -1.55272947 +1.33692428 -1.53762595 +1.32395404 -1.52279037 +1.31121146 -1.50821562 +1.29869059 -1.49389487 +1.28638565 -1.47982149 +1.2742911 -1.46598912 +1.26240155 -1.45239159 +1.25071183 -1.43902294 +1.23921691 -1.42587742 +1.22791195 -1.41294946 +1.21679227 -1.40023369 +1.20585331 -1.38772491 +1.19509071 -1.37541807 +1.1845002 -1.36330832 +1.17407768 -1.35139092 +1.16381916 -1.33966132 +1.1537208 -1.32811509 +1.14377884 -1.31674794 +1.13398968 -1.30555573 +1.1243498 -1.29453443 +1.11485579 -1.28368013 +1.10550437 -1.27298906 +1.09629231 -1.26245753 +1.08721653 -1.252082 +1.078274 -1.241859 +1.06946181 -1.23178518 +1.06077709 -1.22185729 +1.05221711 -1.21207215 +1.04377917 -1.20242671 +1.03546068 -1.19291797 +1.02725911 -1.18354303 +1.01917199 -1.17429908 +1.01119693 -1.16518338 +1.00333162 -1.15619326 +0.995573784 -1.14732614 +0.987921231 -1.13857949 +0.98037182 -1.12995087 +0.97292347 -1.12143788 +0.965574155 -1.11303821 +0.958321904 -1.1047496 +0.951164795 -1.09656985 +0.944100959 -1.08849682 +0.937128576 -1.08052841 +0.930245871 -1.07266261 +0.923451117 -1.06489743 +0.916742629 -1.05723093 +0.910118767 -1.04966125 +0.903577929 -1.04218655 +0.897118557 -1.03480504 +0.890739129 -1.02751498 +0.884438163 -1.02031467 +0.878214211 -1.01320246 +0.872065862 -1.00617673 +0.865991738 -0.999235893 +0.859990497 -0.992378423 +0.854060826 -0.985602815 +0.848201445 -0.978907601 +0.842411104 -0.972291352 +0.836688582 -0.965752669 +0.831032689 -0.959290189 +0.82544226 -0.952902578 +0.819916157 -0.946588534 +0.81445327 -0.940346787 +0.809052513 -0.934176092 +0.803712826 -0.928075237 +0.798433172 -0.922043034 +0.793212538 -0.916078324 +0.788049933 -0.910179972 +0.782944388 -0.904346869 +0.777894956 -0.898577932 +0.772900711 -0.8928721 +0.767960747 -0.887228337 +0.763074178 -0.881645627 +0.758240136 -0.876122979 +0.753457774 -0.870659421 +0.74872626 -0.865254004 +0.744044782 -0.859905797 +0.739412546 -0.854613891 +0.734828772 -0.849377394 +0.730292699 -0.844195434 +0.725803579 -0.839067157 +0.721360683 -0.833991728 +0.716963294 -0.828968326 +0.712610712 -0.82399615 +0.70830225 -0.819074414 +0.704037235 -0.814202348 +0.699815008 -0.809379199 +0.695634923 -0.804604227 +0.691496348 -0.799876708 +0.687398661 -0.795195933 +0.683341256 -0.790561205 +0.679323536 -0.785971843 +0.675344917 -0.78142718 +0.671404826 -0.776926558 +0.667502701 -0.772469336 +0.663637992 -0.768054883 +0.659810158 -0.763682581 +0.656018669 -0.759351825 +0.652263005 -0.75506202 +0.648542658 -0.750812581 +0.644857125 -0.746602938 +0.641205918 -0.742432528 +0.637588552 -0.738300801 +0.634004558 -0.734207215 +0.630453469 -0.73015124 +0.626934831 -0.726132356 +0.623448196 -0.722150051 +0.619993127 -0.718203822 +0.616569192 -0.714293178 +0.613175967 -0.710417634 +0.609813039 -0.706576715 +0.606479997 -0.702769955 +0.603176443 -0.698996895 +0.599901983 -0.695257085 +0.596656229 -0.691550084 +0.593438802 -0.687875456 +0.59024933 -0.684232775 +0.587087445 -0.680621623 +0.583952787 -0.677041587 +0.580845003 -0.673492262 +0.577763744 -0.66997325 +0.57470867 -0.666484162 +0.571679443 -0.663024612 +0.568675734 -0.659594222 +0.565697217 -0.656192623 +0.562743575 -0.652819447 +0.559814492 -0.649474338 +0.556909661 -0.646156941 +0.554028777 -0.642866911 +0.551171544 -0.639603905 +0.548337666 -0.636367589 +0.545526856 -0.633157632 +0.54273883 -0.62997371 +0.539973309 -0.626815503 +0.537230018 -0.623682698 +0.534508686 -0.620574986 +0.531809048 -0.617492062 +0.529130842 -0.614433627 +0.526473811 -0.611399388 +0.523837702 -0.608389054 +0.521222265 -0.605402341 +0.518627256 -0.602438968 +0.516052431 -0.599498659 +0.513497555 -0.596581142 +0.510962392 -0.593686151 +0.508446714 -0.590813421 +0.505950292 -0.587962693 +0.503472904 -0.585133713 +0.50101433 -0.582326228 +0.498574353 -0.579539992 +0.496152761 -0.576774761 +0.493749343 -0.574030296 +0.491363893 -0.571306358 +0.488996208 -0.568602717 +0.486646086 -0.565919143 +0.484313331 -0.56325541 +0.481997748 -0.560611295 +0.479699144 -0.55798658 +0.477417332 -0.555381049 +0.475152126 -0.552794489 +0.472903341 -0.550226691 +0.470670798 -0.547677448 +0.468454318 -0.545146556 +0.466253727 -0.542633816 +0.46406885 -0.54013903 +0.461899519 -0.537662003 +0.459745565 -0.535202543 +0.457606823 -0.532760462 +0.455483129 -0.530335572 +0.453374323 -0.52792769 +0.451280247 -0.525536634 +0.449200743 -0.523162227 +0.447135659 -0.520804292 +0.445084841 -0.518462656 +0.443048141 -0.516137147 +0.441025411 -0.513827596 +0.439016505 -0.511533837 +0.437021279 -0.509255707 +0.435039592 -0.506993042 +0.433071305 -0.504745685 +0.431116279 -0.502513476 +0.429174378 -0.500296261 +0.427245469 -0.498093886 +0.42532942 -0.495906201 +0.423426099 -0.493733057 +0.421535378 -0.491574305 +0.419657131 -0.489429802 +0.417791232 -0.487299405 +0.415937558 -0.485182971 +0.414095986 -0.483080362 +0.412266396 -0.48099144 +0.41044867 -0.478916069 +0.408642691 -0.476854117 +0.406848342 -0.474805449 +0.40506551 -0.472769937 +0.403294082 -0.470747451 +0.401533947 -0.468737864 +0.399784996 -0.466741051 +0.398047119 -0.464756889 +0.39632021 -0.462785254 +0.394604164 -0.460826027 +0.392898876 -0.458879089 +0.391204243 -0.456944321 +0.389520164 -0.455021608 +0.38784654 -0.453110835 +0.386183269 -0.451211889 +0.384530256 -0.449324659 +0.382887403 -0.447449033 +0.381254615 -0.445584904 +0.379631797 -0.443732164 +0.378018858 -0.441890706 +0.376415705 -0.440060425 +0.374822248 -0.438241218 +0.373238396 -0.436432983 +0.371664062 -0.434635618 +0.370099158 -0.432849024 +0.368543597 -0.431073101 +0.366997295 -0.429307753 +0.365460168 -0.427552884 +0.363932131 -0.425808398 +0.362413104 -0.424074201 +0.360903003 -0.4223502 +0.359401751 -0.420636305 +0.357909266 -0.418932423 +0.356425472 -0.417238467 +0.354950289 -0.415554346 +0.353483643 -0.413879975 +0.352025456 -0.412215265 +0.350575656 -0.410560133 +0.349134167 -0.408914494 +0.347700916 -0.407278264 +0.346275833 -0.405651362 +0.344858845 -0.404033704 +0.343449881 -0.402425212 +0.342048874 -0.400825806 +0.340655752 -0.399235406 +0.339270449 -0.397653935 +0.337892897 -0.396081317 +0.33652303 -0.394517475 +0.335160782 -0.392962334 +0.333806088 -0.391415821 +0.332458883 -0.389877861 +0.331119105 -0.388348382 +0.32978669 -0.386827312 +0.328461577 -0.38531458 +0.327143703 -0.383810117 +0.325833009 -0.382313853 +0.324529433 -0.380825719 +0.323232918 -0.379345647 +0.321943403 -0.37787357 +0.320660832 -0.376409423 +0.319385146 -0.374953138 +0.318116289 -0.373504653 +0.316854204 -0.372063901 +0.315598837 -0.370630821 +0.314350131 -0.369205348 +0.313108034 -0.367787422 +0.31187249 -0.36637698 +0.310643447 -0.364973961 +0.309420852 -0.363578307 +0.308204654 -0.362189956 +0.3069948 -0.360808851 +0.305791239 -0.359434933 +0.304593922 -0.358068145 +0.303402799 -0.35670843 +0.302217819 -0.35535573 +0.301038935 -0.354009992 +0.299866098 -0.352671159 +0.29869926 -0.351339176 +0.297538374 -0.350013991 +0.296383394 -0.348695548 +0.295234272 -0.347383797 +0.294090963 -0.346078683 +0.292953422 -0.344780156 +0.291821604 -0.343488164 +0.290695464 -0.342202656 +0.289574959 -0.340923582 +0.288460045 -0.339650893 +0.287350679 -0.33838454 +0.286246818 -0.337124472 +0.28514842 -0.335870644 +0.284055444 -0.334623006 +0.282967848 -0.333381512 +0.281885591 -0.332146114 +0.280808633 -0.330916767 +0.279736934 -0.329693425 +0.278670453 -0.328476043 +0.277609152 -0.327264575 +0.276552992 -0.326058977 +0.275501935 -0.324859206 +0.274455941 -0.323665217 +0.273414974 -0.322476968 +0.272378996 -0.321294416 +0.27134797 -0.320117518 +0.27032186 -0.318946234 +0.269300629 -0.31778052 +0.268284241 -0.316620337 +0.267272661 -0.315465644 +0.266265853 -0.3143164 +0.265263783 -0.313172566 +0.264266416 -0.312034102 +0.263273718 -0.31090097 +0.262285655 -0.30977313 +0.261302193 -0.308650544 +0.2603233 -0.307533174 +0.259348942 -0.306420983 +0.258379087 -0.305313933 +0.257413702 -0.304211988 +0.256452756 -0.303115111 +0.255496217 -0.302023265 +0.254544053 -0.300936416 +0.253596234 -0.299854528 +0.252652728 -0.298777564 +0.251713505 -0.297705492 +0.250778536 -0.296638275 +0.249847789 -0.29557588 +0.248921236 -0.294518274 +0.247998847 -0.293465422 +0.247080592 -0.292417291 +0.246166444 -0.291373849 +0.245256374 -0.290335062 +0.244350353 -0.289300899 +0.243448353 -0.288271327 +0.242550346 -0.287246315 +0.241656306 -0.286225832 +0.240766204 -0.285209846 +0.239880014 -0.284198326 +0.238997709 -0.283191241 +0.238119263 -0.282188563 +0.237244648 -0.281190259 +0.23637384 -0.280196302 +0.235506812 -0.27920666 +0.234643539 -0.278221306 +0.233783995 -0.277240209 +0.232928155 -0.276263342 +0.232075994 -0.275290676 +0.231227489 -0.274322183 +0.230382613 -0.273357835 +0.229541343 -0.272397603 +0.228703656 -0.271441462 +0.227869526 -0.270489383 +0.227038931 -0.269541339 +0.226211847 -0.268597304 +0.225388252 -0.267657252 +0.224568121 -0.266721156 +0.223751432 -0.26578899 +0.222938163 -0.264860728 +0.222128291 -0.263936345 +0.221321795 -0.263015816 +0.220518651 -0.262099114 +0.219718838 -0.261186216 +0.218922336 -0.260277097 +0.218129121 -0.259371732 +0.217339173 -0.258470097 +0.216552471 -0.257572168 +0.215768995 -0.256677921 +0.214988722 -0.255787332 +0.214211633 -0.254900378 +0.213437708 -0.254017036 +0.212666926 -0.253137282 +0.211899267 -0.252261095 +0.211134711 -0.25138845 +0.210373239 -0.250519326 +0.209614831 -0.2496537 +0.208859468 -0.248791551 +0.208107131 -0.247932856 +0.2073578 -0.247077594 +0.206611457 -0.246225743 +0.205868083 -0.245377281 +0.205127659 -0.244532188 +0.204390168 -0.243690443 +0.20365559 -0.242852024 +0.202923908 -0.242016911 +0.202195104 -0.241185084 +0.20146916 -0.240356522 +0.200746059 -0.239531205 +0.200025782 -0.238709114 +0.199308313 -0.237890227 +0.198593633 -0.237074526 +0.197881727 -0.236261991 +0.197172578 -0.235452603 +0.196466167 -0.234646342 +0.19576248 -0.23384319 +0.195061499 -0.233043127 +0.194363207 -0.232246135 +0.193667589 -0.231452196 +0.192974629 -0.23066129 +0.192284309 -0.2298734 +0.191596616 -0.229088507 +0.190911532 -0.228306594 +0.190229042 -0.227527642 +0.189549131 -0.226751635 +0.188871783 -0.225978553 +0.188196983 -0.225208381 +0.187524716 -0.2244411 +0.186854967 -0.223676693 +0.186187721 -0.222915144 +0.185522962 -0.222156435 +0.184860677 -0.221400551 +0.184200852 -0.220647473 +0.18354347 -0.219897186 +0.182888519 -0.219149674 +0.182235984 -0.218404919 +0.18158585 -0.217662907 +0.180938104 -0.21692362 +0.180292732 -0.216187044 +0.179649721 -0.215453162 +0.179009055 -0.214721959 +0.178370723 -0.213993419 +0.17773471 -0.213267527 +0.177101003 -0.212544267 +0.176469589 -0.211823625 +0.175840455 -0.211105586 +0.175213587 -0.210390134 +0.174588973 -0.209677255 +0.173966599 -0.208966934 +0.173346454 -0.208259156 +0.172728524 -0.207553908 +0.172112796 -0.206851174 +0.171499259 -0.206150941 +0.1708879 -0.205453194 +0.170278706 -0.204757919 +0.169671666 -0.204065102 +0.169066767 -0.20337473 +0.168463997 -0.202686789 +0.167863345 -0.202001264 +0.167264798 -0.201318144 +0.166668345 -0.200637413 +0.166073973 -0.19995906 +0.165481673 -0.19928307 +0.164891431 -0.198609431 +0.164303237 -0.197938129 +0.16371708 -0.197269152 +0.163132947 -0.196602486 +0.162550828 -0.195938119 +0.161970712 -0.195276039 +0.161392588 -0.194616233 +0.160816444 -0.193958688 +0.160242271 -0.193303392 +0.159670057 -0.192650332 +0.159099791 -0.191999497 +0.158531464 -0.191350875 +0.157965064 -0.190704452 +0.157400581 -0.190060218 +0.156838004 -0.189418161 +0.156277324 -0.188778268 +0.15571853 -0.188140529 +0.155161612 -0.187504931 +0.15460656 -0.186871463 +0.154053364 -0.186240113 +0.153502014 -0.185610871 +0.152952499 -0.184983725 +0.152404811 -0.184358663 +0.151858939 -0.183735675 +0.151314875 -0.18311475 +0.150772607 -0.182495877 +0.150232127 -0.181879044 +0.149693426 -0.181264241 +0.149156493 -0.180651457 +0.14862132 -0.180040682 +0.148087897 -0.179431905 +0.147556215 -0.178825116 +0.147026266 -0.178220304 +0.146498039 -0.177617458 +0.145971526 -0.177016569 +0.145446718 -0.176417626 +0.144923606 -0.175820619 +0.144402181 -0.175225538 +0.143882435 -0.174632374 +0.143364358 -0.174041115 +0.142847943 -0.173451753 +0.14233318 -0.172864277 +0.141820061 -0.172278677 +0.141308577 -0.171694945 +0.140798721 -0.17111307 +0.140290484 -0.170533043 +0.139783857 -0.169954855 +0.139278832 -0.169378496 +0.138775402 -0.168803956 +0.138273557 -0.168231226 +0.137773291 -0.167660298 +0.137274594 -0.167091162 +0.136777459 -0.166523809 +0.136281878 -0.16595823 +0.135787844 -0.165394416 +0.135295347 -0.164832357 +0.134804382 -0.164272046 +0.134314939 -0.163713474 +0.133827011 -0.163156631 +0.133340591 -0.162601509 +0.132855672 -0.162048099 +0.132372244 -0.161496394 +0.131890302 -0.160946383 +0.131409838 -0.16039806 +0.130930844 -0.159851415 +0.130453313 -0.15930644 +0.129977238 -0.158763127 +0.129502612 -0.158221467 +0.129029427 -0.157681453 +0.128557677 -0.157143077 +0.128087354 -0.156606329 +0.127618451 -0.156071203 +0.127150962 -0.155537691 +0.126684879 -0.155005783 +0.126220195 -0.154475473 +0.125756904 -0.153946753 +0.125295 -0.153419615 +0.124834474 -0.152894051 +0.12437532 -0.152370054 +0.123917533 -0.151847616 +0.123461104 -0.151326729 +0.123006028 -0.150807386 +0.122552298 -0.150289579 +0.122099908 -0.149773302 +0.121648851 -0.149258546 +0.12119912 -0.148745305 +0.12075071 -0.148233571 +0.120303613 -0.147723336 +0.119857824 -0.147214594 +0.119413337 -0.146707338 +0.118970145 -0.14620156 +0.118528242 -0.145697254 +0.118087622 -0.145194412 +0.117648278 -0.144693028 +0.117210206 -0.144193094 +0.116773398 -0.143694603 +0.116337849 -0.14319755 +0.115903552 -0.142701926 +0.115470503 -0.142207726 +0.115038695 -0.141714942 +0.114608121 -0.141223568 +0.114178778 -0.140733598 +0.113750657 -0.140245024 +0.113323755 -0.139757841 +0.112898065 -0.139272041 +0.112473582 -0.138787619 +0.112050299 -0.138304567 +0.111628212 -0.13782288 +0.111207315 -0.137342551 +0.110787602 -0.136863573 +0.110369067 -0.136385942 +0.109951707 -0.135909649 +0.109535514 -0.13543469 +0.109120483 -0.134961058 +0.10870661 -0.134488746 +0.108293889 -0.13401775 +0.107882314 -0.133548062 +0.107471881 -0.133079677 +0.107062584 -0.132612589 +0.106654418 -0.132146792 +0.106247377 -0.13168228 +0.105841457 -0.131219047 +0.105436653 -0.130757087 +0.105032959 -0.130296395 +0.104630371 -0.129836964 +0.104228883 -0.12937879 +0.103828491 -0.128921866 +0.103429189 -0.128466187 +0.103030973 -0.128011747 +0.102633837 -0.127558541 +0.102237777 -0.127106562 +0.101842789 -0.126655807 +0.101448866 -0.126206268 +0.101056005 -0.12575794 +0.100664201 -0.125310819 +0.100273449 -0.124864899 +0.0998837436 -0.124420174 +0.0994950812 -0.123976639 +0.0991074568 -0.123534289 +0.0987208659 -0.123093119 +0.0983353037 -0.122653123 +0.0979507658 -0.122214296 +0.0975672477 -0.121776633 +0.0971847448 -0.121340128 +0.0968032526 -0.120904778 +0.0964227668 -0.120470576 +0.0960432829 -0.120037517 +0.0956647964 -0.119605598 +0.0952873031 -0.119174811 +0.0949107985 -0.118745154 +0.0945352785 -0.11831662 +0.0941607385 -0.117889205 +0.0937871745 -0.117462903 +0.0934145821 -0.117037711 +0.0930429571 -0.116613623 +0.0926722953 -0.116190635 +0.0923025926 -0.115768741 +0.0919338448 -0.115347937 +0.0915660477 -0.114928218 +0.0911991973 -0.114509579 +0.0908332895 -0.114092017 +0.0904683202 -0.113675526 +0.0901042854 -0.113260101 +0.089741181 -0.112845739 +0.0893790032 -0.112432434 +0.0890177479 -0.112020182 +0.0886574112 -0.111608978 +0.0882979891 -0.111198819 +0.0879394778 -0.110789699 +0.0875818734 -0.110381614 +0.087225172 -0.10997456 +0.0868693698 -0.109568532 +0.086514463 -0.109163526 +0.0861604477 -0.108759538 +0.0858073203 -0.108356563 +0.085455077 -0.107954597 +0.0851037139 -0.107553636 +0.0847532276 -0.107153676 +0.0844036141 -0.106754712 +0.08405487 -0.10635674 +0.0837069914 -0.105959756 +0.0833599749 -0.105563756 +0.0830138167 -0.105168736 +0.0826685134 -0.104774692 +0.0823240613 -0.104381619 +0.0819804569 -0.103989513 +0.0816376967 -0.103598372 +0.0812957771 -0.103208189 +0.0809546947 -0.102818962 +0.080614446 -0.102430687 +0.0802750275 -0.10204336 +0.0799364359 -0.101656976 +0.0795986676 -0.101271532 +0.0792617193 -0.100887023 +0.0789255877 -0.100503447 +0.0785902693 -0.1001208 +0.0782557608 -0.0997390761 +0.077922059 -0.0993582733 +0.0775891604 -0.0989783874 +0.0772570618 -0.0985994146 +0.07692576 -0.0982213512 +0.0765952517 -0.0978441934 +0.0762655336 -0.0974679376 +0.0759366025 -0.09709258 +0.0756084553 -0.0967181172 +0.0752810887 -0.0963445453 +0.0749544996 -0.0959718608 +0.0746286848 -0.0956000602 +0.0743036413 -0.0952291397 +0.0739793658 -0.0948590959 +0.0736558553 -0.0944899253 +0.0733331067 -0.0941216243 +0.0730111169 -0.0937541893 +0.072689883 -0.093387617 +0.0723694017 -0.0930219039 +0.0720496702 -0.0926570464 +0.0717306854 -0.0922930413 +0.0714124444 -0.091929885 +0.0710949441 -0.0915675742 +0.0707781817 -0.0912061056 +0.0704621541 -0.0908454757 +0.0701468585 -0.0904856812 +0.0698322919 -0.0901267187 +0.0695184515 -0.0897685851 +0.0692053343 -0.089411277 +0.0688929375 -0.0890547911 +0.0685812583 -0.0886991243 +0.0682702937 -0.0883442731 +0.0679600411 -0.0879902345 +0.0676504976 -0.0876370052 +0.0673416603 -0.087284582 +0.0670335266 -0.0869329618 +0.0667260937 -0.0865821414 +0.0664193587 -0.0862321177 +0.0661133191 -0.0858828875 +0.065807972 -0.0855344478 +0.0655033147 -0.0851867955 +0.0651993446 -0.0848399274 +0.064896059 -0.0844938406 +0.0645934551 -0.0841485319 +0.0642915305 -0.0838039984 +0.0639902824 -0.0834602371 +0.0636897081 -0.0831172449 +0.0633898052 -0.0827750189 +0.0630905709 -0.082433556 +0.0627920028 -0.0820928535 +0.0624940982 -0.0817529082 +0.0621968545 -0.0814137174 +0.0619002693 -0.081075278 +0.06160434 -0.0807375873 +0.0613090641 -0.0804006423 +0.061014439 -0.0800644401 +0.0607204623 -0.0797289779 +0.0604271315 -0.0793942529 +0.0601344441 -0.0790602623 +0.0598423977 -0.0787270033 +0.0595509897 -0.0783944729 +0.0592602179 -0.0780626686 +0.0589700797 -0.0777315875 +0.0586805728 -0.0774012269 +0.0583916947 -0.077071584 +0.0581034431 -0.076742656 +0.0578158156 -0.0764144404 +0.0575288098 -0.0760869344 +0.0572424234 -0.0757601354 +0.056956654 -0.0754340405 +0.0566714994 -0.0751086473 +0.0563869572 -0.074783953 +0.056103025 -0.074459955 +0.0558197007 -0.0741366508 +0.0555369818 -0.0738140376 +0.0552548662 -0.0734921129 +0.0549733517 -0.0731708742 +0.0546924358 -0.0728503188 +0.0544121165 -0.0725304442 +0.0541323914 -0.0722112479 +0.0538532584 -0.0718927273 +0.0535747152 -0.0715748799 +0.0532967597 -0.0712577033 +0.0530193897 -0.0709411949 +0.052742603 -0.0706253522 +0.0524663975 -0.0703101727 +0.0521907709 -0.0699956541 +0.0519157211 -0.0696817939 +0.0516412461 -0.0693685895 +0.0513673437 -0.0690560387 +0.0510940118 -0.068744139 +0.0508212482 -0.068432888 +0.0505490509 -0.0681222833 +0.0502774179 -0.0678123226 +0.0500063469 -0.0675030034 +0.0497358361 -0.0671943235 +0.0494658833 -0.0668862804 +0.0491964864 -0.0665788719 +0.0489276436 -0.0662720957 +0.0486593526 -0.0659659493 +0.0483916116 -0.0656604306 +0.0481244184 -0.0653555372 +0.0478577712 -0.0650512669 +0.047591668 -0.0647476174 +0.0473261067 -0.0644445865 +0.0470610854 -0.0641421718 +0.0467966021 -0.0638403712 +0.0465326549 -0.0635391825 +0.0462692419 -0.0632386034 +0.0460063611 -0.0629386317 +0.0457440106 -0.0626392653 +0.0454821885 -0.0623405019 +0.0452208929 -0.0620423394 +0.044960122 -0.0617447757 +0.0446998737 -0.0614478085 +0.0444401462 -0.0611514357 +0.0441809378 -0.0608556553 +0.0439222464 -0.0605604651 +0.0436640703 -0.0602658629 +0.0434064077 -0.0599718467 +0.0431492566 -0.0596784144 +0.0428926153 -0.0593855639 +0.042636482 -0.0590932931 +0.0423808548 -0.0588016 +0.0421257319 -0.0585104825 +0.0418711116 -0.0582199386 +0.0416169921 -0.0579299662 +0.0413633716 -0.0576405633 +0.0411102483 -0.0573517279 +0.0408576205 -0.057063458 +0.0406054864 -0.0567757515 +0.0403538444 -0.0564886066 +0.0401026925 -0.0562020212 +0.0398520292 -0.0559159934 +0.0396018527 -0.0556305211 +0.0393521613 -0.0553456025 +0.0391029533 -0.0550612356 +0.038854227 -0.0547774185 +0.0386059807 -0.0544941491 +0.0383582128 -0.0542114257 +0.0381109215 -0.0539292464 +0.0378641052 -0.0536476091 +0.0376177622 -0.053366512 +0.0373718909 -0.0530859533 +0.0371264897 -0.052805931 +0.0368815569 -0.0525264434 +0.0366370909 -0.0522474885 +0.0363930901 -0.0519690644 +0.0361495528 -0.0516911694 +0.0359064774 -0.0514138017 +0.0356638624 -0.0511369593 +0.0354217062 -0.0508606405 +0.0351800072 -0.0505848435 +0.0349387637 -0.0503095664 +0.0346979743 -0.0500348075 +0.0344576373 -0.049760565 +0.0342177513 -0.0494868372 +0.0339783146 -0.0492136221 +0.0337393257 -0.0489409182 +0.0335007831 -0.0486687236 +0.0332626853 -0.0483970366 +0.0330250307 -0.0481258554 +0.0327878178 -0.0478551784 +0.0325510451 -0.0475850037 +0.0323147111 -0.0473153297 +0.0320788144 -0.0470461548 +0.0318433533 -0.0467774771 +0.0316083265 -0.0465092949 +0.0313737324 -0.0462416067 +0.0311395697 -0.0459744107 +0.0309058368 -0.0457077053 +0.0306725322 -0.0454414888 +0.0304396546 -0.0451757595 +0.0302072024 -0.0449105158 +0.0299751743 -0.044645756 +0.0297435688 -0.0443814785 +0.0295123845 -0.0441176818 +0.02928162 -0.0438543641 +0.0290512738 -0.0435915238 +0.0288213445 -0.0433291594 +0.0285918308 -0.0430672693 +0.0283627313 -0.0428058518 +0.0281340445 -0.0425449054 +0.027905769 -0.0422844284 +0.0276779036 -0.0420244194 +0.0274504468 -0.0417648768 +0.0272233973 -0.0415057989 +0.0269967537 -0.0412471843 +0.0267705146 -0.0409890314 +0.0265446788 -0.0407313387 +0.0263192448 -0.0404741046 +0.0260942113 -0.0402173276 +0.025869577 -0.0399610062 +0.0256453406 -0.0397051389 +0.0254215008 -0.0394497241 +0.0251980561 -0.0391947604 +0.0249750054 -0.0389402463 +0.0247523474 -0.0386861803 +0.0245300807 -0.0384325609 +0.024308204 -0.0381793866 +0.024086716 -0.037926656 +0.0238656155 -0.0376743676 +0.0236449013 -0.03742252 +0.0234245719 -0.0371711117 +0.0232046262 -0.0369201412 +0.0229850629 -0.0366696071 +0.0227658808 -0.0364195081 +0.0225470786 -0.0361698425 +0.022328655 -0.0359206092 +0.0221106088 -0.0356718065 +0.0218929388 -0.0354234332 +0.0216756438 -0.0351754879 +0.0214587225 -0.034927969 +0.0212421737 -0.0346808753 +0.0210259962 -0.0344342053 +0.0208101889 -0.0341879577 +0.0205947504 -0.0339421311 +0.0203796796 -0.0336967241 +0.0201649753 -0.0334517354 +0.0199506363 -0.0332071636 +0.0197366614 -0.0329630074 +0.0195230495 -0.0327192654 +0.0193097994 -0.0324759363 +0.0190969098 -0.0322330187 +0.0188843798 -0.0319905113 +0.018672208 -0.0317484129 +0.0184603933 -0.031506722 +0.0182489346 -0.0312654374 +0.0180378308 -0.0310245577 +0.0178270806 -0.0307840817 +0.017616683 -0.030544008 +0.0174066369 -0.0303043355 +0.017196941 -0.0300650627 +0.0169875944 -0.0298261884 +0.0167785958 -0.0295877113 +0.0165699441 -0.0293496302 +0.0163616383 -0.0291119438 +0.0161536773 -0.0288746509 +0.0159460598 -0.0286377501 +0.015738785 -0.0284012402 +0.0155318515 -0.0281651201 +0.0153252585 -0.0279293884 +0.0151190047 -0.0276940439 +0.0149130892 -0.0274590853 +0.0147075108 -0.0272245116 +0.0145022684 -0.0269903214 +0.0142973611 -0.0267565135 +0.0140927877 -0.0265230867 +0.0138885472 -0.0262900398 +0.0136846386 -0.0260573716 +0.0134810607 -0.025825081 +0.0132778126 -0.0255931666 +0.0130748932 -0.0253616274 +0.0128723014 -0.0251304622 +0.0126700363 -0.0248996697 +0.0124680969 -0.0246692489 +0.012266482 -0.0244391985 +0.0120651907 -0.0242095173 +0.0118642219 -0.0239802043 +0.0116635747 -0.0237512583 +0.0114632481 -0.023522678 +0.011263241 -0.0232944625 +0.0110635524 -0.0230666104 +0.0108641814 -0.0228391208 +0.0106651269 -0.0226119924 +0.010466388 -0.0223852242 +0.0102679637 -0.022158815 +0.010069853 -0.0219327637 +0.00987205488 -0.0217070692 +0.00967456846 -0.0214817303 +0.00947739274 -0.021256746 +0.00928052674 -0.0210321152 +0.0090839695 -0.0208078368 +0.00888772008 -0.0205839097 +0.00869177752 -0.0203603327 +0.00849614086 -0.0201371049 +0.00830080917 -0.0199142251 +0.0081057815 -0.0196916923 +0.00791105691 -0.0194695053 +0.00771663447 -0.0192476632 +0.00752251324 -0.0190261648 +0.00732869231 -0.0188050092 +0.00713517075 -0.0185841952 +0.00694194763 -0.0183637217 +0.00674902204 -0.0181435879 +0.00655639306 -0.0179237925 +0.0063640598 -0.0177043346 +0.00617202133 -0.0174852132 +0.00598027676 -0.0172664271 +0.00578882519 -0.0170479754 +0.00559766573 -0.0168298571 +0.00540679747 -0.0166120711 +0.00521621953 -0.0163946165 +0.00502593103 -0.0161774922 +0.00483593109 -0.0159606971 +0.00464621882 -0.0157442304 +0.00445679334 -0.015528091 +0.0042676538 -0.0153122778 +0.00407879931 -0.01509679 +0.00389022901 -0.0148816266 +0.00370194205 -0.0146667864 +0.00351393755 -0.0144522686 +0.00332621467 -0.0142380723 +0.00313877255 -0.0140241963 +0.00295161035 -0.0138106398 +0.00276472721 -0.0135974017 +0.00257812229 -0.0133844812 +0.00239179476 -0.0131718772 +0.00220574377 -0.0129595888 +0.0020199685 -0.0127476151 +0.0018344681 -0.0125359551 +0.00164924177 -0.0123246078 +0.00146428866 -0.0121135724 +0.00127960797 -0.0119028478 +0.00109519886 -0.0116924332 +0.000911060532 -0.0114823276 +0.000727192166 -0.01127253 +0.000543592955 -0.0110630397 +0.000360262093 -0.0108538556 +0.000177198776 -0.0106449768 +-5.59779523e-06 -0.0104364024 +-0.000188128419 -0.0102281316 +-0.000370393888 -0.0100201633 +-0.000552394996 -0.00981249677 +-0.000734132529 -0.009605131 +-0.000915607274 -0.00939806514 +-0.00109682001 -0.00919129828 +-0.00127777153 -0.00898482953 +-0.00145846259 -0.00877865802 +-0.00163889398 -0.00857278285 +-0.00181906646 -0.00836720314 +-0.00199898081 -0.00816191803 +-0.00217863779 -0.00795692663 +-0.00235803816 -0.00775222807 +-0.00253718269 -0.0075478215 +-0.00271607212 -0.00734370603 +-0.00289470722 -0.00713988082 +-0.00307308874 -0.006936345 +-0.00325121742 -0.00673309772 +-0.00342909401 -0.00653013813 +-0.00360671926 -0.00632746537 +-0.00378409391 -0.00612507861 +-0.00396121869 -0.005922977 +-0.00413809433 -0.0057211597 +-0.00431472159 -0.00551962587 +-0.00449110117 -0.00531837469 +-0.00466723382 -0.00511740531 +-0.00484312025 -0.00491671692 +-0.00501876119 -0.00471630868 +-0.00519415736 -0.00451617979 +-0.00536930948 -0.00431632941 +-0.00554421825 -0.00411675673 +-0.0057188844 -0.00391746094 +-0.00589330863 -0.00371844123 +-0.00606749165 -0.0035196968 +-0.00624143416 -0.00332122683 +-0.00641513687 -0.00312303054 +-0.00658860047 -0.00292510711 +-0.00676182566 -0.00272745575 +-0.00693481314 -0.00253007568 +-0.0071075636 -0.00233296609 +-0.00728007773 -0.00213612621 +-0.00745235621 -0.00193955525 +-0.00762439974 -0.00174325243 +-0.00779620898 -0.00154721697 +-0.00796778463 -0.00135144809 +-0.00813912736 -0.00115594502 +-0.00831023785 -0.000960706994 +-0.00848111676 -0.000765733237 +-0.00865176477 -0.000571022985 +-0.00882218255 -0.000376575478 +-0.00899237076 -0.000182389955 +-0.00916233007 1.15343411e-05 +-0.00933206114 0.000205198165 +-0.00950156462 0.000398602267 +-0.00967084117 0.000591747399 +-0.00983989145 0.000784634305 +-0.0100087161 0.000977263731 +-0.0101773158 0.00116963642 +-0.0103456911 0.0013617531 +-0.0105138428 0.00155361452 +-0.0106817715 0.00174522141 +-0.0108494777 0.00193657451 +-0.0110169622 0.00212767453 +-0.0111842256 0.0023185222 +-0.0113512685 0.00250911826 +-0.0115180915 0.00269946341 +-0.0116846953 0.00288955838 +-0.0118510805 0.00307940389 +-0.0120172477 0.00326900065 +-0.0121831976 0.00345834937 +-0.0123489307 0.00364745075 +-0.0125144478 0.00383630551 +-0.0126797493 0.00402491435 +-0.012844836 0.00421327797 +-0.0130097084 0.00440139707 +-0.0131743671 0.00458927234 +-0.0133388129 0.00477690449 +-0.0135030461 0.00496429419 +-0.0136670675 0.00515144216 +-0.0138308777 0.00533834905 +-0.0139944773 0.00552501558 +-0.0141578668 0.00571144241 +-0.0143210469 0.00589763023 +-0.0144840181 0.00608357971 +-0.0146467811 0.00626929154 +-0.0148093364 0.00645476638 +-0.0149716847 0.0066400049 +-0.0151338264 0.00682500778 +-0.0152957623 0.00700977568 +-0.0154574928 0.00719430927 +-0.0156190186 0.0073786092 +-0.0157803402 0.00756267615 +-0.0159414582 0.00774651075 +-0.0161023732 0.00793011368 +-0.0162630858 0.00811348559 +-0.0164235965 0.00829662711 +-0.0165839059 0.00847953892 +-0.0167440146 0.00866222164 +-0.016903923 0.00884467593 +-0.0170636319 0.00902690243 +-0.0172231418 0.00920890177 +-0.0173824531 0.0093906746 +-0.0175415665 0.00957222156 +-0.0177004826 0.00975354327 +-0.0178592018 0.00993464037 +-0.0180177248 0.0101155135 +-0.018176052 0.0102961633 +-0.0183341841 0.0104765903 +-0.0184921215 0.0106567952 +-0.0186498649 0.0108367787 +-0.0188074147 0.0110165413 +-0.0189647715 0.0111960836 +-0.0191219359 0.0113754063 +-0.0192789083 0.01155451 +-0.0194356894 0.0117333953 +-0.0195922796 0.0119120628 +-0.0197486795 0.0120905131 +-0.0199048896 0.0122687468 +-0.0200609105 0.0124467645 +-0.0202167426 0.0126245669 +-0.0203723865 0.0128021545 +-0.0205278427 0.0129795278 +-0.0206831118 0.0131566877 +-0.0208381942 0.0133336345 +-0.0209930906 0.0135103689 +-0.0211478013 0.0136868915 +-0.0213023269 0.0138632029 +-0.0214566679 0.0140393036 +-0.0216108249 0.0142151943 +-0.0217647983 0.0143908755 +-0.0219185886 0.0145663478 +-0.0220721965 0.0147416118 +-0.0222256223 0.0149166681 +-0.0223788665 0.0150915172 +-0.0225319298 0.0152661597 +-0.0226848125 0.0154405962 +-0.0228375151 0.0156148273 +-0.0229900383 0.0157888535 +-0.0231423824 0.0159626753 +-0.0232945479 0.0161362935 +-0.0234465354 0.0163097084 +-0.0235983454 0.0164829207 +-0.0237499783 0.0166559309 +-0.0239014346 0.0168287396 +-0.0240527148 0.0170013473 +-0.0242038193 0.0171737547 +-0.0243547488 0.0173459622 +-0.0245055036 0.0175179704 +-0.0246560843 0.0176897798 +-0.0248064912 0.017861391 +-0.024956725 0.0180328045 +-0.025106786 0.018204021 +-0.0252566747 0.0183750408 +-0.0254063917 0.0185458646 +-0.0255559373 0.0187164929 +-0.0257053121 0.0188869262 +-0.0258545165 0.0190571651 +-0.026003551 0.01922721 +-0.026152416 0.0193970616 +-0.0263011121 0.0195667204 +-0.0264496396 0.0197361868 +-0.0265979991 0.0199054615 +-0.0267461909 0.0200745449 +-0.0268942156 0.0202434375 +-0.0270420737 0.0204121399 +-0.0271897655 0.0205806526 +-0.0273372915 0.0207489761 +-0.0274846522 0.020917111 +-0.027631848 0.0210850577 +-0.0277788794 0.0212528167 +-0.0279257468 0.0214203887 +-0.0280724506 0.021587774 +-0.0282189914 0.0217549732 +-0.0283653696 0.0219219868 +-0.0285115855 0.0220888152 +-0.0286576397 0.0222554591 +-0.0288035325 0.0224219189 +-0.0289492645 0.0225881951 +-0.029094836 0.0227542882 +-0.0292402476 0.0229201987 +-0.0293854995 0.0230859271 +-0.0295305923 0.0232514739 +-0.0296755264 0.0234168396 +-0.0298203022 0.0235820246 +-0.0299649202 0.0237470295 +-0.0301093808 0.0239118548 +-0.0302536843 0.0240765009 +-0.0303978313 0.0242409683 +-0.0305418221 0.0244052576 +-0.0306856573 0.0245693691 +-0.0308293371 0.0247333034 +-0.030972862 0.024897061 +-0.0311162325 0.0250606423 +-0.0312594489 0.0252240478 +-0.0314025117 0.0253872779 +-0.0315454213 0.0255503333 +-0.0316881781 0.0257132142 +-0.0318307825 0.0258759213 +-0.0319732349 0.0260384549 +-0.0321155357 0.0262008156 +-0.0322576854 0.0263630038 +-0.0323996844 0.0265250199 +-0.032541533 0.0266868645 +-0.0326832317 0.0268485379 +-0.0328247808 0.0270100408 +-0.0329661808 0.0271713734 +-0.0331074321 0.0273325363 +-0.0332485351 0.02749353 +-0.0333894901 0.0276543548 +-0.0335302976 0.0278150113 +-0.033670958 0.0279754998 +-0.0338114716 0.0281358209 +-0.0339518389 0.0282959751 +-0.0340920602 0.0284559626 +-0.034232136 0.0286157841 +-0.0343720666 0.0287754398 +-0.0345118524 0.0289349304 +-0.0346514939 0.0290942562 +-0.0347909913 0.0292534177 +-0.0349303451 0.0294124153 +-0.0350695557 0.0295712494 +-0.0352086235 0.0297299205 +-0.0353475488 0.0298884291 +-0.035486332 0.0300467755 +-0.0356249735 0.0302049602 +-0.0357634737 0.0303629836 +-0.035901833 0.0305208462 +-0.0360400517 0.0306785484 +-0.0361781302 0.0308360906 +-0.0363160689 0.0309934733 +-0.0364538682 0.0311506969 +-0.0365915284 0.0313077617 +-0.0367290499 0.0314646683 +-0.0368664331 0.031621417 +-0.0370036784 0.0317780084 +-0.037140786 0.0319344427 +-0.0372777565 0.0320907204 +-0.0374145901 0.032246842 +-0.0375512872 0.0324028078 +-0.0376878482 0.0325586182 +-0.0378242735 0.0327142738 +-0.0379605634 0.0328697749 +-0.0380967182 0.0330251218 +-0.0382327384 0.0331803151 +-0.0383686242 0.0333353552 +-0.0385043762 0.0334902423 +-0.0386399945 0.033644977 +-0.0387754796 0.0337995597 +-0.0389108318 0.0339539907 +-0.0390460515 0.0341082705 +-0.039181139 0.0342623995 +-0.0393160947 0.034416378 +-0.0394509189 0.0345702065 +-0.039585612 0.0347238854 +-0.0397201744 0.034877415 +-0.0398546063 0.0350307959 +-0.0399889081 0.0351840282 +-0.0401230803 0.0353371126 +-0.040257123 0.0354900493 +-0.0403910367 0.0356428387 +-0.0405248217 0.0357954813 +-0.0406584784 0.0359479774 +-0.0407920071 0.0361003274 +-0.040925408 0.0362525318 +-0.0410586817 0.0364045908 +-0.0411918284 0.0365565049 +-0.0413248484 0.0367082745 +-0.0414577421 0.0368598999 +-0.0415905098 0.0370113816 +-0.0417231519 0.0371627199 +-0.0418556687 0.0373139152 +-0.0419880605 0.0374649679 +-0.0421203277 0.0376158783 +-0.0422524705 0.0377666469 +-0.0423844894 0.037917274 +-0.0425163846 0.03806776 +-0.0426481565 0.0382181052 +-0.0427798054 0.0383683101 +-0.0429113316 0.038518375 +-0.0430427355 0.0386683003 +-0.0431740173 0.0388180864 +-0.0433051775 0.0389677335 +-0.0434362163 0.0391172422 +-0.043567134 0.0392666127 +-0.043697931 0.0394158455 +-0.0438286077 0.0395649409 +-0.0439591642 0.0397138992 +-0.044089601 0.0398627208 +-0.0442199183 0.0400114061 +-0.0443501164 0.0401599555 +-0.0444801958 0.0403083693 +-0.0446101567 0.0404566478 +-0.0447399993 0.0406047915 +-0.0448697241 0.0407528007 +-0.0449993314 0.0409006757 +-0.0451288214 0.0410484169 +-0.0452581944 0.0411960247 +-0.0453874509 0.0413434994 +-0.045516591 0.0414908413 +-0.0456456151 0.0416380509 +-0.0457745235 0.0417851284 +-0.0459033165 0.0419320742 +-0.0460319944 0.0420788887 +-0.0461605575 0.0422255722 +-0.0462890062 0.0423721251 +-0.0464173407 0.0425185477 +-0.0465455613 0.0426648403 +-0.0466736684 0.0428110034 +-0.0468016622 0.0429570371 +-0.046929543 0.043102942 +-0.0470573111 0.0432487183 +-0.0471849669 0.0433943664 +-0.0473125106 0.0435398865 +-0.0474399426 0.0436852792 +-0.0475672631 0.0438305446 +-0.0476944723 0.0439756831 +-0.0478215707 0.0441206951 +-0.0479485586 0.0442655809 +-0.0480754361 0.0444103408 +-0.0482022036 0.0445549752 +-0.0483288614 0.0446994844 +-0.0484554098 0.0448438687 +-0.048581849 0.0449881285 +-0.0487081794 0.0451322641 +-0.0488344013 0.0452762758 +-0.0489605149 0.045420164 +-0.0490865205 0.0455639289 +-0.0492124184 0.0457075709 +-0.0493382089 0.0458510904 +-0.0494638924 0.0459944877 +-0.0495894689 0.046137763 +-0.0497149389 0.0462809167 +-0.0498403027 0.0464239492 +-0.0499655605 0.0465668607 +-0.0500907125 0.0467096516 +-0.0502157592 0.0468523221 +-0.0503407007 0.0469948727 +-0.0504655373 0.0471373037 +-0.0505902694 0.0472796152 +-0.0507148971 0.0474218078 +-0.0508394208 0.0475638816 +-0.0509638408 0.047705837 +-0.0510881573 0.0478476744 +-0.0512123705 0.047989394 +-0.0513364809 0.0481309961 +-0.0514604886 0.048272481 +-0.0515843939 0.0484138492 +-0.0517081971 0.0485551008 +-0.0518318985 0.0486962362 +-0.0519554983 0.0488372557 +-0.0520789968 0.0489781596 +-0.0522023943 0.0491189482 +-0.0523256911 0.0492596218 +-0.0524488873 0.0494001808 +-0.0525719833 0.0495406253 +-0.0526949794 0.0496809559 +-0.0528178758 0.0498211726 +-0.0529406727 0.0499612759 +-0.0530633705 0.0501012661 +-0.0531859694 0.0502411434 +-0.0533084697 0.0503809081 +-0.0534308716 0.0505205606 +-0.0535531754 0.0506601011 +-0.0536753814 0.05079953 +-0.0537974898 0.0509388475 +-0.0539195008 0.0510780539 +-0.0540414148 0.0512171496 +-0.054163232 0.0513561348 +-0.0542849527 0.0514950099 +-0.054406577 0.051633775 +-0.0545281054 0.0517724306 +-0.0546495379 0.0519109769 +-0.054770875 0.0520494142 +-0.0548921167 0.0521877428 +-0.0550132635 0.0523259629 +-0.0551343155 0.0524640749 +-0.0552552731 0.0526020791 +-0.0553761363 0.0527399758 +-0.0554969056 0.0528777651 +-0.0556175811 0.0530154475 +-0.0557381632 0.0531530232 +-0.055858652 0.0532904925 +-0.0559790478 0.0534278557 +-0.0560993509 0.053565113 +-0.0562195614 0.0537022648 +-0.0563396798 0.0538393113 +-0.0564597061 0.0539762528 +-0.0565796406 0.0541130896 +-0.0566994837 0.054249822 +-0.0568192355 0.0543864502 +-0.0569388963 0.0545229746 +-0.0570584663 0.0546593954 +-0.0571779458 0.0547957129 +-0.057297335 0.0549319274 +-0.0574166342 0.0550680391 +-0.0575358435 0.0552040483 +-0.0576549633 0.0553399553 +-0.0577739938 0.0554757604 +-0.0578929352 0.0556114638 +-0.0580117878 0.0557470659 +-0.0581305517 0.0558825668 +-0.0582492273 0.0560179669 +-0.0583678148 0.0561532665 +-0.0584863144 0.0562884658 +-0.0586047264 0.056423565 +-0.0587230509 0.0565585645 +-0.0588412883 0.0566934645 +-0.0589594387 0.0568282653 +-0.0590775024 0.0569629671 +-0.0591954797 0.0570975703 +-0.0593133707 0.057232075 +-0.0594311757 0.0573664816 +-0.0595488949 0.0575007904 +-0.0596665286 0.0576350015 +-0.059784077 0.0577691152 +-0.0599015403 0.0579031319 +-0.0600189188 0.0580370517 +-0.0601362126 0.058170875 +-0.0602534221 0.058304602 +-0.0603705474 0.0584382329 +-0.0604875887 0.0585717681 +-0.0606045464 0.0587052077 +-0.0607214206 0.0588385521 +-0.0608382115 0.0589718014 +-0.0609549194 0.0591049561 +-0.0610715445 0.0592380162 +-0.0611880871 0.0593709821 +-0.0613045473 0.059503854 +-0.0614209253 0.0596366322 +-0.0615372215 0.059769317 +-0.061653436 0.0599019085 +-0.061769569 0.0600344071 +-0.0618856208 0.060166813 +-0.0620015916 0.0602991265 +-0.0621174816 0.0604313477 +-0.0622332911 0.060563477 +-0.0623490201 0.0606955146 +-0.0624646691 0.0608274608 +-0.0625802382 0.0609593158 +-0.0626957275 0.0610910798 +-0.0628111374 0.0612227531 +-0.062926468 0.061354336 +-0.0630417196 0.0614858287 +-0.0631568924 0.0616172315 +-0.0632719865 0.0617485445 +-0.0633870023 0.0618797681 +-0.0635019399 0.0620109025 +-0.0636167996 0.0621419479 +-0.0637315814 0.0622729046 +-0.0638462858 0.0624037728 +-0.0639609128 0.0625345528 +-0.0640754628 0.0626652447 +-0.0641899358 0.062795849 +-0.0643043322 0.0629263657 +-0.0644186521 0.0630567952 +-0.0645328957 0.0631871376 +-0.0646470633 0.0633173932 +-0.0647611551 0.0634475623 +-0.0648751712 0.0635776451 +-0.0649891119 0.0637076419 +-0.0651029774 0.0638375528 +-0.0652167678 0.0639673781 +-0.0653304835 0.064097118 +-0.0654441247 0.0642267729 +-0.0655576914 0.0643563428 +-0.0656711839 0.0644858281 +-0.0657846025 0.064615229 +-0.0658979473 0.0647445458 +-0.0660112186 0.0648737786 +-0.0661244165 0.0650029276 +-0.0662375413 0.0651319932 +-0.0663505931 0.0652609756 +-0.0664635722 0.0653898749 +-0.0665764787 0.0655186915 +-0.066689313 0.0656474255 +-0.066802075 0.0657760772 +-0.0669147652 0.0659046468 +-0.0670273836 0.0660331346 +-0.0671399305 0.0661615407 +-0.0672524061 0.0662898655 +-0.0673648105 0.066418109 +-0.067477144 0.0665462716 +-0.0675894068 0.0666743535 +-0.067701599 0.0668023549 +-0.0678137209 0.0669302761 +-0.0679257727 0.0670581172 +-0.0680377545 0.0671858785 +-0.0681496666 0.0673135602 +-0.0682615092 0.0674411626 +-0.0683732824 0.0675686858 +-0.0684849864 0.0676961301 +-0.0685966215 0.0678234957 +-0.0687081879 0.0679507828 +-0.0688196856 0.0680779917 +-0.068931115 0.0682051225 +-0.0690424763 0.0683321756 +-0.0691537695 0.0684591511 +-0.069264995 0.0685860492 +-0.0693761528 0.0687128702 +-0.0694872432 0.0688396142 +-0.0695982665 0.0689662815 +-0.0697092227 0.0690928724 +-0.069820112 0.069219387 +-0.0699309348 0.0693458255 +-0.070041691 0.0694721882 +-0.0701523811 0.0695984753 +-0.070263005 0.0697246869 +-0.0703735631 0.0698508234 +-0.0704840554 0.069976885 +-0.0705944823 0.0701028717 +-0.0707048439 0.070228784 +-0.0708151403 0.0703546219 +-0.0709253717 0.0704803857 +-0.0710355385 0.0706060756 +-0.0711456406 0.0707316918 +-0.0712556784 0.0708572345 +-0.071365652 0.070982704 +-0.0714755615 0.0711081004 +-0.0715854073 0.071233424 +-0.0716951893 0.0713586749 +-0.071804908 0.0714838535 +-0.0719145633 0.0716089598 +-0.0720241556 0.0717339941 +-0.072133685 0.0718589567 +-0.0722431516 0.0719838477 +-0.0723525557 0.0721086673 +-0.0724618975 0.0722334157 +-0.072571177 0.0723580932 +-0.0726803946 0.0724826999 +-0.0727895504 0.0726072361 +-0.0728986445 0.0727317019 +-0.0730076772 0.0728560976 +-0.0731166486 0.0729804234 +-0.0732255589 0.0731046795 +-0.0733344083 0.073228866 +-0.0734431969 0.0733529833 +-0.073551925 0.0734770314 +-0.0736605928 0.0736010107 +-0.0737692003 0.0737249212 +-0.0738777478 0.0738487632 +-0.0739862354 0.073972537 +-0.0740946634 0.0740962426 +-0.0742030319 0.0742198804 +-0.0743113411 0.0743434504 +-0.0744195912 0.074466953 +-0.0745277822 0.0745903883 +-0.0746359145 0.0747137565 +-0.0747439882 0.0748370578 +-0.0748520035 0.0749602924 +-0.0749599605 0.0750834606 +-0.0750678593 0.0752065624 +-0.0751757003 0.0753295981 +-0.0752834836 0.075452568 +-0.0753912092 0.0755754721 +-0.0754988775 0.0756983108 +-0.0756064885 0.0758210841 +-0.0757140425 0.0759437924 +-0.0758215397 0.0760664357 +-0.0759289801 0.0761890143 +-0.0760363639 0.0763115284 +-0.0761436914 0.0764339781 +-0.0762509627 0.0765563638 +-0.076358178 0.0766786854 +-0.0764653375 0.0768009434 +-0.0765724412 0.0769231378 +-0.0766794894 0.0770452688 +-0.0767864823 0.0771673367 +-0.07689342 0.0772893416 +-0.0770003027 0.0774112837 +-0.0771071305 0.0775331633 +-0.0772139037 0.0776549804 +-0.0773206223 0.0777767353 +-0.0774272867 0.0778984282 +-0.0775338968 0.0780200593 +-0.077640453 0.0781416288 +-0.0777469553 0.0782631368 +-0.0778534039 0.0783845836 +-0.077959799 0.0785059693 +-0.0780661408 0.0786272941 +-0.0781724294 0.0787485582 +-0.078278665 0.0788697619 +-0.0783848477 0.0789909052 +-0.0784909777 0.0791119884 +-0.0785970553 0.0792330117 +-0.0787030804 0.0793539752 +-0.0788090534 0.0794748791 +-0.0789149744 0.0795957237 +-0.0790208435 0.079716509 +-0.0791266608 0.0798372354 +-0.0792324267 0.079957903 +-0.0793381411 0.0800785119 +-0.0794438044 0.0801990623 +-0.0795494165 0.0803195545 +-0.0796549778 0.0804399886 +-0.0797604884 0.0805603648 +-0.0798659483 0.0806806833 +-0.0799713579 0.0808009442 +-0.0800767172 0.0809211478 +-0.0801820264 0.0810412943 +-0.0802872857 0.0811613837 +-0.0803924952 0.0812814163 +-0.0804976551 0.0814013923 +-0.0806027655 0.0815213119 +-0.0807078266 0.0816411752 +-0.0808128386 0.0817609824 +-0.0809178016 0.0818807338 +-0.0810227158 0.0820004294 +-0.0811275813 0.0821200694 +-0.0812323983 0.0822396541 +-0.0813371669 0.0823591836 +-0.0814418874 0.0824786581 +-0.0815465598 0.0825980778 +-0.0816511843 0.0827174428 +-0.0817557611 0.0828367534 +-0.0818602903 0.0829560097 +-0.0819647721 0.0830752118 +-0.0820692067 0.08319436 +-0.0821735941 0.0833134545 +-0.0822779346 0.0834324953 +-0.0823822282 0.0835514828 +-0.0824864753 0.083670417 +-0.0825906758 0.0837892982 +-0.08269483 0.0839081264 +-0.082798938 0.084026902 +-0.082903 0.084145625 +-0.0830070161 0.0842642957 +-0.0831109865 0.0843829142 +-0.0832149113 0.0845014807 +-0.0833187907 0.0846199953 +-0.0834226248 0.0847384583 +-0.0835264138 0.0848568698 +-0.0836301578 0.08497523 +-0.083733857 0.085093539 +-0.0838375116 0.0852117971 +-0.0839411216 0.0853300043 +-0.0840446873 0.085448161 +-0.0841482088 0.0855662671 +-0.0842516862 0.085684323 +-0.0843551197 0.0858023288 +-0.0844585094 0.0859202846 +-0.0845618555 0.0860381906 +-0.0846651582 0.0861560471 +-0.0847684175 0.0862738541 +-0.0848716337 0.0863916118 +-0.0849748068 0.0865093205 +-0.0850779371 0.0866269802 +-0.0851810247 0.0867445911 +-0.0852840697 0.0868621535 +-0.0853870722 0.0869796674 +-0.0854900325 0.0870971331 +-0.0855929506 0.0872145507 +-0.0856958268 0.0873319204 +-0.0857986611 0.0874492424 +-0.0859014537 0.0875665167 +-0.0860042048 0.0876837437 +-0.0861069145 0.0878009234 +-0.0862095829 0.087918056 +-0.0863122102 0.0880351417 +-0.0864147966 0.0881521806 +-0.0865173421 0.088269173 +-0.0866198469 0.0883861189 +-0.0867223113 0.0885030186 +-0.0868247352 0.0886198722 +-0.0869271189 0.0887366799 +-0.0870294625 0.0888534418 +-0.0871317662 0.0889701581 +-0.08723403 0.0890868289 +-0.0873362542 0.0892034545 +-0.0874384389 0.089320035 +-0.0875405842 0.0894365706 +-0.0876426902 0.0895530614 +-0.0877447572 0.0896695075 +-0.0878467852 0.0897859092 +-0.0879487743 0.0899022667 +-0.0880507249 0.0900185799 +-0.0881526369 0.0901348493 +-0.0882545105 0.0902510748 +-0.0883563459 0.0903672566 +-0.0884581432 0.090483395 +-0.0885599025 0.0905994901 +-0.088661624 0.090715542 +-0.0887633078 0.0908315509 +-0.0888649541 0.0909475169 +-0.088966563 0.0910634403 +-0.0890681346 0.0911793212 +-0.0891696691 0.0912951596 +-0.0892711667 0.0914109559 +-0.0893726274 0.0915267102 +-0.0894740514 0.0916424225 +-0.0895754388 0.0917580932 +-0.0896767898 0.0918737223 +-0.0897781046 0.0919893099 +-0.0898793832 0.0921048563 +-0.0899806258 0.0922203617 +-0.0900818325 0.092335826 +-0.0901830035 0.0924512497 +-0.090284139 0.0925666327 +-0.0903852389 0.0926819752 +-0.0904863036 0.0927972774 +-0.0905873331 0.0929125395 +-0.0906883275 0.0930277616 +-0.090789287 0.0931429438 +-0.0908902118 0.0932580864 +-0.0909911019 0.0933731894 +-0.0910919576 0.0934882531 +-0.0911927789 0.0936032776 +-0.0912935659 0.093718263 +-0.0913943189 0.0938332095 +-0.0914950379 0.0939481173 +-0.0915957231 0.0940629864 +-0.0916963747 0.0941778172 +-0.0917969927 0.0942926096 +-0.0918975773 0.0944073639 +-0.0919981286 0.0945220803 +-0.0920986468 0.0946367588 +-0.092199132 0.0947513996 +-0.0922995843 0.094866003 +-0.0924000038 0.0949805689 +-0.0925003908 0.0950950977 +-0.0926007453 0.0952095894 +-0.0927010675 0.0953240442 +-0.0928013575 0.0954384623 +-0.0929016154 0.0955528437 +-0.0930018414 0.0956671887 +-0.0931020355 0.0957814975 +-0.0932021981 0.09589577 +-0.093302329 0.0960100066 +-0.0934024286 0.0961242074 +-0.0935024969 0.0962383724 +-0.0936025341 0.0963525019 +-0.0937025403 0.0964665961 +-0.0938025156 0.096580655 +-0.0939024601 0.0966946788 +-0.0940023741 0.0968086676 +-0.0941022575 0.0969226217 +-0.0942021107 0.0970365412 +-0.0943019336 0.0971504261 +-0.0944017264 0.0972642768 +-0.0945014893 0.0973780932 +-0.0946012223 0.0974918756 +-0.0947009257 0.0976056241 +-0.0948005995 0.0977193389 +-0.0949002439 0.0978330201 +-0.094999859 0.0979466678 +-0.0950994449 0.0980602823 +-0.0951990018 0.0981738636 +-0.0952985297 0.0982874119 +-0.0953980289 0.0984009274 +-0.0954974994 0.0985144101 +-0.0955969414 0.0986278603 +-0.095696355 0.0987412781 +-0.0957957404 0.0988546637 +-0.0958950976 0.0989680171 +-0.0959944268 0.0990813385 +-0.0960937282 0.0991946282 +-0.0961930018 0.0993078862 +-0.0962922477 0.0994211126 +-0.0963914662 0.0995343077 +-0.0964906573 0.0996474715 +-0.0965898212 0.0997606042 +-0.096688958 0.099873706 +-0.0967880678 0.099986777 +-0.0968871507 0.100099817 +-0.0969862069 0.100212827 +-0.0970852365 0.100325807 +-0.0971842397 0.100438756 +-0.0972832165 0.100551675 +-0.0973821671 0.100664565 +-0.0974810916 0.100777424 +-0.0975799901 0.100890254 +-0.0976788628 0.101003054 +-0.0977777098 0.101115825 +-0.0978765312 0.101228567 +-0.0979753272 0.10134128 +-0.0980740978 0.101453964 +-0.0981728432 0.101566619 +-0.0982715635 0.101679245 +-0.0983702589 0.101791843 +-0.0984689295 0.101904413 +-0.0985675753 0.102016954 +-0.0986661966 0.102129468 +-0.0987647934 0.102241953 +-0.0988633659 0.102354411 +-0.0989619142 0.102466841 +-0.0990604384 0.102579244 +-0.0991589387 0.102691619 +-0.0992574151 0.102803967 +-0.0993558678 0.102916288 +-0.099454297 0.103028582 +-0.0995527026 0.103140849 +-0.099651085 0.10325309 +-0.0997494442 0.103365304 +-0.0998477802 0.103477492 +-0.0999460933 0.103589654 +-0.100044384 0.103701789 +-0.100142651 0.103813899 +-0.100240896 0.103925983 +-0.100339119 0.104038041 +-0.100437319 0.104150073 +-0.100535497 0.104262081 +-0.100633653 0.104374063 +-0.100731786 0.10448602 +-0.100829898 0.104597952 +-0.100927989 0.104709859 +-0.101026057 0.104821742 +-0.101124105 0.1049336 +-0.101222131 0.105045434 +-0.101320135 0.105157243 +-0.101418119 0.105269028 +-0.101516081 0.10538079 +-0.101614023 0.105492527 +-0.101711944 0.105604241 +-0.101809844 0.105715932 +-0.101907724 0.105827598 +-0.102005583 0.105939242 +-0.102103422 0.106050863 +-0.102201241 0.10616246 +-0.10229904 0.106274035 +-0.102396819 0.106385587 +-0.102494578 0.106497116 +-0.102592318 0.106608623 +-0.102690038 0.106720108 +-0.102787739 0.10683157 +-0.10288542 0.10694301 +-0.102983082 0.107054429 +-0.103080725 0.107165826 +-0.103178349 0.107277201 +-0.103275955 0.107388555 +-0.103373541 0.107499887 +-0.10347111 0.107611198 +-0.103568659 0.107722488 +-0.103666191 0.107833757 +-0.103763704 0.107945006 +-0.103861199 0.108056233 +-0.103958676 0.108167441 +-0.104056135 0.108278627 +-0.104153576 0.108389794 +-0.104251 0.10850094 +-0.104348407 0.108612067 +-0.104445796 0.108723173 +-0.104543167 0.10883426 +-0.104640522 0.108945328 +-0.104737859 0.109056376 +-0.10483518 0.109167404 +-0.104932484 0.109278414 +-0.105029771 0.109389404 +-0.105127042 0.109500376 +-0.105224296 0.109611329 +-0.105321534 0.109722263 +-0.105418756 0.109833178 +-0.105515961 0.109944076 +-0.105613151 0.110054955 +-0.105710325 0.110165816 +-0.105807483 0.110276659 +-0.105904626 0.110387484 +-0.106001753 0.110498292 +-0.106098865 0.110609082 +-0.106195961 0.110719855 +-0.106293043 0.11083061 +-0.106390109 0.110941349 +-0.10648716 0.11105207 +-0.106584197 0.111162774 +-0.106681219 0.111273462 +-0.106778227 0.111384133 +-0.10687522 0.111494788 +-0.106972199 0.111605426 +-0.107069163 0.111716048 +-0.107166114 0.111826654 +-0.10726305 0.111937244 +-0.107359973 0.112047819 +-0.107456882 0.112158377 +-0.107553778 0.11226892 +-0.107650659 0.112379448 +-0.107747528 0.112489961 +-0.107844383 0.112600458 +-0.107941226 0.11271094 +-0.108038055 0.112821408 +-0.108134871 0.112931861 +-0.108231675 0.113042299 +-0.108328465 0.113152722 +-0.108425244 0.113263132 +-0.10852201 0.113373527 +-0.108618763 0.113483908 +-0.108715505 0.113594275 +-0.108812234 0.113704628 +-0.108908951 0.113814968 +-0.109005656 0.113925294 +-0.10910235 0.114035607 +-0.109199032 0.114145906 +-0.109295703 0.114256193 +-0.109392362 0.114366466 +-0.10948901 0.114476726 +-0.109585647 0.114586974 +-0.109682272 0.114697209 +-0.109778887 0.114807432 +-0.109875491 0.114917642 +-0.109972084 0.11502784 +-0.110068667 0.115138026 +-0.110165239 0.1152482 +-0.110261801 0.115358362 +-0.110358353 0.115468512 +-0.110454894 0.115578651 +-0.110551426 0.115688779 +-0.110647947 0.115798895 +-0.110744459 0.115909 +-0.110840961 0.116019094 +-0.110937454 0.116129177 +-0.111033937 0.116239249 +-0.111130411 0.116349311 +-0.111226876 0.116459362 +-0.111323331 0.116569403 +-0.111419778 0.116679433 +-0.111516216 0.116789454 +-0.111612645 0.116899464 +-0.111709065 0.117009465 +-0.111805477 0.117119456 +-0.111901881 0.117229437 +-0.111998276 0.117339409 +-0.112094663 0.117449371 +-0.112191042 0.117559324 +-0.112287413 0.117669269 +-0.112383776 0.117779204 +-0.112480132 0.11788913 +-0.11257648 0.117999048 +-0.11267282 0.118108957 +-0.112769153 0.118218858 +-0.112865479 0.11832875 +-0.112961798 0.118438635 +-0.113058109 0.118548511 +-0.113154414 0.118658379 +-0.113250712 0.11876824 +-0.113347003 0.118878093 +-0.113443288 0.118987938 +-0.113539566 0.119097777 +-0.113635838 0.119207607 +-0.113732104 0.119317431 +-0.113828363 0.119427248 +-0.113924617 0.119537058 +-0.114020864 0.119646861 +-0.114117106 0.119756657 +-0.114213343 0.119866447 +-0.114309573 0.119976231 +-0.114405799 0.120086009 +-0.114502018 0.12019578 +-0.114598233 0.120305546 +-0.114694443 0.120415305 +-0.114790647 0.120525059 +-0.114886847 0.120634808 +-0.114983042 0.120744551 +-0.115079233 0.120854288 +-0.115175419 0.120964021 +-0.1152716 0.121073748 +-0.115367777 0.121183471 +-0.11546395 0.121293189 +-0.115560119 0.121402902 +-0.115656284 0.12151261 +-0.115752445 0.121622314 +-0.115848603 0.121732014 +-0.115944757 0.12184171 +-0.116040907 0.121951402 +-0.116137054 0.12206109 +-0.116233197 0.122170774 +-0.116329338 0.122280454 +-0.116425475 0.122390131 +-0.11652161 0.122499805 +-0.116617741 0.122609475 +-0.11671387 0.122719143 +-0.116809997 0.122828807 +-0.116906121 0.122938469 +-0.117002242 0.123048127 +-0.117098361 0.123157783 +-0.117194478 0.123267437 +-0.117290593 0.123377089 +-0.117386707 0.123486738 +-0.117482818 0.123596385 +END diff --git a/examples/calculator/my_simulation.in b/examples/calculator/my_simulation.in new file mode 100644 index 0000000..3ac35ce --- /dev/null +++ b/examples/calculator/my_simulation.in @@ -0,0 +1,35 @@ +spinsys { + +channels 1H +nuclei 1H 1H +shift 1 2.5p 0 0 0 0 0 +shift 2 7.0p 0 0 0 0 0 + +} + +par { + crystal_file rep100 + detect_operator I1p + gamma_angles 10 + method direct + np 4096 + proton_frequency 400MHz + spin_rate 10e3 + start_operator I1x + sw 2000 + verbose 0 + variable ref 0 +} + +proc pulseq {} {} + + +proc main {} { + global par + set f [fsimpson] + faddlb $f 20 0 + fzerofill $f 4096 + fft $f + fset $f -ref $par(ref) + fsave $f $par(name).spe +} diff --git a/examples/scripts/build_calculator.py b/examples/scripts/build_calculator.py new file mode 100644 index 0000000..2fb3fa9 --- /dev/null +++ b/examples/scripts/build_calculator.py @@ -0,0 +1,48 @@ +""" +Example: Build a SIMPSON input file step by step using SimpCalc. + +This script shows how to use SimpCalc directly for full control over all +simulation parameters, pulse sequence selection, and output configuration. +The generated .in file can be run with SIMPSON or inspected manually. +""" + +from simpyson import SimpCalc + +# Define a spin system (two 1H sites with a shift difference) +spinsys = """ +channels 1H +nuclei 1H 1H +shift 1 5p 0 0 0 0 0 +shift 2 8p 0 0 0 0 0 +""" + +# Create a calculator with a no-pulse experiment +calc = SimpCalc( + spinsys=spinsys, + pulse_sequence="no_pulse", + proton_frequency=400e6, + spin_rate=10000, + start_operator="Inx", + detect_operator="Inp", + np=4096, + sw=10000, + method="direct", + crystal_file="rep100", + gamma_angles=10, + verbose=0, + out_name="example_output", + out_format="spe", + lb=50, + zerofill=4096, +) + +# Preview the generated SIMPSON input file +print(calc) + +# Save to disk +calc.save("example_simulation.in") +print("\nSaved to example_simulation.in") + +# To actually run the simulation (requires SIMPSON in PATH): +# result = calc.run(read_output=True, delete_files=True) +# print(result.spe['hz'][:10]) diff --git a/examples/scripts/read_spectrum.py b/examples/scripts/read_spectrum.py new file mode 100644 index 0000000..3b1409b --- /dev/null +++ b/examples/scripts/read_spectrum.py @@ -0,0 +1,37 @@ +""" +Example: Read and inspect a SIMPSON spectrum file. + +This script shows how to load a .spe file, access its data, and optionally +convert the frequency axis to ppm. +""" + +from simpyson import read_simp + +# --- Read a spectrum file --- +data = read_simp("read/ethanol.spe") + +# Access the frequency-domain data +spe = data.spe +print(f"Number of points: {spe['np']}") +print(f"Spectral width: {spe['sw']} Hz") +print(f"Hz range: {spe['hz'][0]:.1f} to {spe['hz'][-1]:.1f} Hz") + +# --- Convert to ppm (requires b0 and nucleus) --- +data.b0 = "400MHz" +data.nucleus = "1H" + +ppm = data.ppm +if ppm is not None: + print(f"ppm range: {ppm['ppm'][0]:.2f} to {ppm['ppm'][-1]:.2f} ppm") + + +# --- Read an FID file --- +fid_data = read_simp("read/ethanol.fid") + +fid = fid_data.fid +print(f"\nFID points: {fid['np']}") +print(f"Time range: {fid['time'][0]:.3f} to {fid['time'][-1]:.3f} ms") + +# The FID can be auto-converted to a spectrum: +spe_from_fid = fid_data.spe +print(f"FFT result: {len(spe_from_fid['real'])} points") diff --git a/examples/scripts/simulate_basic.py b/examples/scripts/simulate_basic.py new file mode 100644 index 0000000..6ab90a6 --- /dev/null +++ b/examples/scripts/simulate_basic.py @@ -0,0 +1,36 @@ +""" +Example: Simulate a basic NMR spectrum using simulate_spectrum(). + +This script demonstrates the simplest way to run a SIMPSON simulation from +Python. It creates a spin system by hand, runs a no-pulse simulation, and +prints basic info about the result. + +NOTE: Requires a working SIMPSON installation in your PATH. +""" + +from simpyson import simulate_spectrum + +# Define a simple spin system with two 13C sites +spinsys = """ +channels 13C +nuclei 13C 13C +shift 1 10p 0 0 0 0 0 +shift 2 50p 0 0 0 0 0 +""" + +# simulate_spectrum() auto-calculates sw, offset, and ref from the shifts +result = simulate_spectrum( + spinsys, + proton_frequency=400e6, + spin_rate=10000, +) + +# The result is a Simpy object with spectrum data +spe = result.spe +print(f"Number of points: {spe['np']}") +print(f"Spectral width: {spe['sw']} Hz") + +# ppm is auto-calculated because proton_frequency and nucleus are known +ppm = result.ppm +if ppm is not None: + print(f"ppm range: {ppm['ppm'][0]:.1f} to {ppm['ppm'][-1]:.1f}") diff --git a/examples/write/castep_sim_al.in b/examples/write/castep_sim_al.in index 299bc89..dd0cfdb 100644 --- a/examples/write/castep_sim_al.in +++ b/examples/write/castep_sim_al.in @@ -3,49 +3,52 @@ spinsys { channels 27Al nuclei 27Al 27Al 27Al 27Al 27Al 27Al 27Al 27Al -shift 1 28.659576262296923p 20.339232414170812p 0.33357164499732 120.68739637466554 108.34146564492772 57.07900668662663 -shift 2 28.659594686146875p 20.339079612873356p 0.3335707832321997 120.68729053714353 108.34165156941647 57.07927851066677 -shift 3 21.260721702489263p 6.021638198368237p 0.5603677873359818 154.52675697316138 134.2842035838119 188.46181652671046 -shift 4 21.261185828250404p 6.021267235392466p 0.5603809857706147 154.5201635571047 134.28865610066472 188.4474794499714 -shift 5 26.804606792343975p 16.610044414890808p 0.43920832902520096 44.3693125593008 91.46223326686302 19.790616815926047 -shift 6 26.80450424280565p 16.61015629939243p 0.4392093536016056 44.36905216300481 91.46220549447884 19.79144448313827 -shift 7 27.002370931728137p 12.477978221999894p 0.9698656658362816 -28.18161339187243 80.88893725042178 -40.4310367965887 -shift 8 27.00248797350349p 12.478025074581561p 0.9698661041125336 -28.179616205384004 80.89000255334261 -40.43233519932931 - -quadrupole 1 2 -4391507.710667592 0.13482756539739116 118.72154026102976 107.83278417199723 -62.1385310601917 -quadrupole 2 2 -4391460.595816191 0.13482521631465047 118.72120349456422 107.83300423300427 -62.13643227095904 -quadrupole 3 2 -2586921.597391124 0.8975633833663132 182.79196913563652 135.83446332739499 99.91942187470819 -quadrupole 4 2 -2586899.140424663 0.8975762548794866 182.79196390049384 135.83494352611865 99.9195031341442 -quadrupole 5 2 -3346451.5758902277 0.37494720816177507 222.52714159614257 90.96960079423924 64.44986680825893 -quadrupole 6 2 -3346490.5668859677 0.37495574138281695 222.52691157806385 90.9692815605824 64.44782347978472 -quadrupole 7 2 -3409437.545224899 0.9852246051158867 -33.691695142416606 89.41971318385414 43.27188776461466 -quadrupole 8 2 -3409420.632330633 0.9852409861884698 -33.69103750897958 89.42046162642166 43.27152530553932 +shift 1 28.934270944197635p 20.339232414170812p 0.33357164499732 120.68739637466554 108.34146564492772 57.07900668662663 +shift 2 28.934289358126534p 20.339079612873356p 0.3335707832321997 120.68729053714353 108.34165156941647 57.07927851066675 +shift 3 21.539400592638003p 6.021638198368237p 0.5603677873359818 154.52675697316135 134.2842035838119 188.46181652671046 +shift 4 21.53986446847216p 6.021267235392466p 0.5603809857706147 154.5201635571047 134.28865610066472 188.4474794499714 +shift 5 27.08030035651791p 16.610044414890808p 0.43920832902520096 44.3693125593008 91.46223326686302 19.790616815926054 +shift 6 27.080197862201487p 16.61015629939243p 0.4392093536016056 44.36905216300482 91.46220549447884 19.791444483138278 +shift 7 27.27795800191592p 12.477978221999894p 0.9698656658362816 -28.18161339187243 80.88893725042176 -40.4310367965887 +shift 8 27.27807498066545p 12.478025074581561p 0.9698661041125336 -28.179616205384004 80.89000255334261 -40.43233519932931 + +quadrupole 1 2 -4391507.716632987 0.13482756539739116 118.72154026102976 107.83278417199723 -62.1385310601917 +quadrupole 2 2 -4391460.601781524 0.13482521631465047 118.72120349456418 107.83300423300427 -62.13643227095902 +quadrupole 3 2 -2586921.6009051814 0.8975633833663132 182.7919691356365 135.83446332739496 99.9194218747082 +quadrupole 4 2 -2586899.1439386904 0.8975762548794866 182.79196390049384 135.83494352611865 99.9195031341442 +quadrupole 5 2 -3346451.5804360257 0.37494720816177507 222.52714159614257 90.96960079423923 64.44986680825893 +quadrupole 6 2 -3346490.571431819 0.37495574138281695 222.52691157806385 90.9692815605824 64.44782347978472 +quadrupole 7 2 -3409437.5498562567 0.9852246051158867 -33.691695142416606 89.41971318385414 43.27188776461466 +quadrupole 8 2 -3409420.6369619677 0.9852409861884698 -33.69103750897958 89.42046162642166 43.27152530553932 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/castep_sim_p.in b/examples/write/castep_sim_p.in index 485b9e0..916351d 100644 --- a/examples/write/castep_sim_p.in +++ b/examples/write/castep_sim_p.in @@ -3,41 +3,44 @@ spinsys { channels 31P nuclei 31P 31P 31P 31P 31P 31P 31P 31P -shift 1 -27.107293311462286p -13.871235393589927p 0.669346560283497 173.05892322554195 39.10682592980573 -69.87267392506803 -shift 2 -21.400062317422567p 21.357522305551733p 0.6581252618670956 144.13264733815635 115.45052823824665 130.04000464418206 -shift 3 -21.399922596088288p 21.357327527396627p 0.6581243741085694 144.13283799677419 115.45129678085269 130.04014397321865 -shift 4 -27.93940485615724p 11.985094349492972p 0.7566984185314088 53.600576109356986 84.56458904567452 8.537864161255676 -shift 5 -27.93928142045263p 11.985068779933954p 0.7566970751009692 53.60154110711636 84.56424613175977 8.53673951940185 -shift 6 -32.193556752635914p -7.78685539569138p 0.23014757532595317 25.93420687371549 133.98128531339432 -157.86737323841035 -shift 7 -32.193252796156855p -7.786692766361853p 0.23012827123942808 25.935744079574366 133.97881513465325 -157.83171072071679 -shift 8 -27.107423530151664p -13.871678737774989p 0.6692764453091742 173.05730925989897 39.106947329395496 -69.8740130745334 +shift 1 -27.019059670663466p -13.871235393589927p 0.669346560283497 173.05892322554195 39.10682592980573 -69.87267392506803 +shift 2 -21.31344815169166p 21.357522305551733p 0.6581252618670956 144.13264733815635 115.45052823824665 130.04000464418206 +shift 3 -21.313308470004472p 21.357327527396627p 0.6581243741085694 144.13283799677419 115.45129678085273 130.04014397321862 +shift 4 -27.850935096669332p 11.985094349492972p 0.7566984185314088 53.600576109356986 84.56458904567452 8.537864161255676 +shift 5 -27.85081169599067p 11.985068779933954p 0.7566970751009692 53.60154110711636 84.56424613175977 8.53673951940186 +shift 6 -32.103879841564606p -7.78685539569138p 0.23014757532595317 25.93420687371549 133.98128531339432 -157.86737323841035 +shift 7 -32.103575971335715p -7.786692766361853p 0.23012827123942808 25.935744079574366 133.97881513465325 -157.83171072071679 +shift 8 -27.019189852402178p -13.871678737774989p 0.6692764453091742 173.05730925989894 39.10694732939549 -69.87401307453337 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inp - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 30000.0 - verbose 01 - variable tsw 30000.0 + crystal_file rep168 + detect_operator Inp + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 30000.0 + verbose 0 + variable offset 0.0 + variable tsw 30000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/ethanol_sim.in b/examples/write/ethanol_sim.in index 4ba184a..03906d0 100644 --- a/examples/write/ethanol_sim.in +++ b/examples/write/ethanol_sim.in @@ -3,39 +3,42 @@ spinsys { channels 1H nuclei 1H 1H 1H 1H 1H 1H -shift 1 0.8354293713394547p 11.796351880247721p 0.36054492072508726 175.3463230730489 97.75242531497987 152.81319215023692 -shift 2 5.204130041124756p -5.349798389334978p 0.9581850459396797 114.11524726996608 105.13997392615444 16.52713641675679 -shift 3 4.701577378305853p -4.792032594746104p 0.9640880093346293 -127.0807351287339 9.211192124778933 213.61109043726432 -shift 4 1.6150349868294533p 6.354642648658222p 0.1791579524422889 32.27006429212434 75.77438493212512 49.35693621831093 -shift 5 2.1542775521498356p 4.986897261933615p 0.23191892678522574 -52.3556046241893 83.76484132085078 -27.316825651903315 -shift 6 1.4943315697030926p 5.328448270122085p 0.19284348566489434 33.43333937902465 157.3640548958986 -40.91271867921063 +shift 1 0.8364077472138689p 11.796351880247721p 0.36054492072508726 175.3463230730489 97.75242531497986 152.81319215023692 +shift 2 5.204969933577864p -5.349798389334978p 0.9581850459396797 114.11524726996608 105.13997392615444 16.527136416756797 +shift 3 4.702433201173378p -4.792032594746104p 0.9640880093346293 -127.0807351287339 9.211192124778933 213.61109043726432 +shift 4 1.6159886499892515p 6.354642648658222p 0.1791579524422889 32.27006429212434 75.77438493212512 49.35693621831093 +shift 5 2.1552141218621763p 4.986897261933615p 0.23191892678522574 -52.3556046241893 83.76484132085078 -27.316825651903315 +shift 6 1.4952890590399228p 5.328448270122085p 0.19284348566489434 33.433339379024666 157.3640548958986 -40.91271867921064 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 400000000.0 - start_operator Inx - detect_operator Inp - method direct - crystal_file rep256 - gamma_angles 6 - variable sw 10000.0 - verbose 01 - variable tsw 10000.0 + crystal_file rep256 + detect_operator Inp + gamma_angles 6 + method direct + np 2048 + proton_frequency 400000000.0 + spin_rate 40000.0 + start_operator Inx + sw 10000.0 + verbose 0 + variable offset 0.0 + variable tsw 10000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_0.in b/examples/write/split_simulation_al/castep_sim_al_0.in index 7376f18..7e4bb59 100644 --- a/examples/write/split_simulation_al/castep_sim_al_0.in +++ b/examples/write/split_simulation_al/castep_sim_al_0.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 28.659576262296923p 20.339232414170812p 0.33357164499732 120.68739637466554 108.34146564492772 57.07900668662663 +shift 1 28.934270944197635p 20.339232414170812p 0.33357164499732 120.68739637466554 108.34146564492772 57.07900668662663 -quadrupole 1 2 -4391507.710667592 0.13482756539739116 118.72154026102976 107.83278417199723 -62.1385310601917 +quadrupole 1 2 -4391507.716632987 0.13482756539739116 118.72154026102976 107.83278417199723 -62.1385310601917 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_1.in b/examples/write/split_simulation_al/castep_sim_al_1.in index 505f6d4..3898b11 100644 --- a/examples/write/split_simulation_al/castep_sim_al_1.in +++ b/examples/write/split_simulation_al/castep_sim_al_1.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 28.659594686146875p 20.339079612873356p 0.3335707832321997 120.68729053714353 108.34165156941647 57.07927851066677 +shift 1 28.934289358126534p 20.339079612873356p 0.3335707832321997 120.68729053714353 108.34165156941647 57.07927851066675 -quadrupole 1 2 -4391460.595816191 0.13482521631465047 118.72120349456422 107.83300423300427 -62.13643227095904 +quadrupole 1 2 -4391460.601781524 0.13482521631465047 118.72120349456418 107.83300423300427 -62.13643227095902 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_2.in b/examples/write/split_simulation_al/castep_sim_al_2.in index b61ad59..1834847 100644 --- a/examples/write/split_simulation_al/castep_sim_al_2.in +++ b/examples/write/split_simulation_al/castep_sim_al_2.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 21.260721702489263p 6.021638198368237p 0.5603677873359818 154.52675697316138 134.2842035838119 188.46181652671046 +shift 1 21.539400592638003p 6.021638198368237p 0.5603677873359818 154.52675697316135 134.2842035838119 188.46181652671046 -quadrupole 1 2 -2586921.597391124 0.8975633833663132 182.79196913563652 135.83446332739499 99.91942187470819 +quadrupole 1 2 -2586921.6009051814 0.8975633833663132 182.7919691356365 135.83446332739496 99.9194218747082 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_3.in b/examples/write/split_simulation_al/castep_sim_al_3.in index 9db0b5d..b90dfac 100644 --- a/examples/write/split_simulation_al/castep_sim_al_3.in +++ b/examples/write/split_simulation_al/castep_sim_al_3.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 21.261185828250404p 6.021267235392466p 0.5603809857706147 154.5201635571047 134.28865610066472 188.4474794499714 +shift 1 21.53986446847216p 6.021267235392466p 0.5603809857706147 154.5201635571047 134.28865610066472 188.4474794499714 -quadrupole 1 2 -2586899.140424663 0.8975762548794866 182.79196390049384 135.83494352611865 99.9195031341442 +quadrupole 1 2 -2586899.1439386904 0.8975762548794866 182.79196390049384 135.83494352611865 99.9195031341442 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_4.in b/examples/write/split_simulation_al/castep_sim_al_4.in index 13f414b..e4cf0fd 100644 --- a/examples/write/split_simulation_al/castep_sim_al_4.in +++ b/examples/write/split_simulation_al/castep_sim_al_4.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 26.804606792343975p 16.610044414890808p 0.43920832902520096 44.3693125593008 91.46223326686302 19.790616815926047 +shift 1 27.08030035651791p 16.610044414890808p 0.43920832902520096 44.3693125593008 91.46223326686302 19.790616815926054 -quadrupole 1 2 -3346451.5758902277 0.37494720816177507 222.52714159614257 90.96960079423924 64.44986680825893 +quadrupole 1 2 -3346451.5804360257 0.37494720816177507 222.52714159614257 90.96960079423923 64.44986680825893 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_5.in b/examples/write/split_simulation_al/castep_sim_al_5.in index 3b3454b..395154b 100644 --- a/examples/write/split_simulation_al/castep_sim_al_5.in +++ b/examples/write/split_simulation_al/castep_sim_al_5.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 26.80450424280565p 16.61015629939243p 0.4392093536016056 44.36905216300481 91.46220549447884 19.79144448313827 +shift 1 27.080197862201487p 16.61015629939243p 0.4392093536016056 44.36905216300482 91.46220549447884 19.791444483138278 -quadrupole 1 2 -3346490.5668859677 0.37495574138281695 222.52691157806385 90.9692815605824 64.44782347978472 +quadrupole 1 2 -3346490.571431819 0.37495574138281695 222.52691157806385 90.9692815605824 64.44782347978472 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_6.in b/examples/write/split_simulation_al/castep_sim_al_6.in index 0c7ca6a..1ad28ac 100644 --- a/examples/write/split_simulation_al/castep_sim_al_6.in +++ b/examples/write/split_simulation_al/castep_sim_al_6.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 27.002370931728137p 12.477978221999894p 0.9698656658362816 -28.18161339187243 80.88893725042178 -40.4310367965887 +shift 1 27.27795800191592p 12.477978221999894p 0.9698656658362816 -28.18161339187243 80.88893725042176 -40.4310367965887 -quadrupole 1 2 -3409437.545224899 0.9852246051158867 -33.691695142416606 89.41971318385414 43.27188776461466 +quadrupole 1 2 -3409437.5498562567 0.9852246051158867 -33.691695142416606 89.41971318385414 43.27188776461466 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/castep_sim_al_7.in b/examples/write/split_simulation_al/castep_sim_al_7.in index 90229a6..0e69db5 100644 --- a/examples/write/split_simulation_al/castep_sim_al_7.in +++ b/examples/write/split_simulation_al/castep_sim_al_7.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 27.00248797350349p 12.478025074581561p 0.9698661041125336 -28.179616205384004 80.89000255334261 -40.43233519932931 +shift 1 27.27807498066545p 12.478025074581561p 0.9698661041125336 -28.179616205384004 80.89000255334261 -40.43233519932931 -quadrupole 1 2 -3409420.632330633 0.9852409861884698 -33.69103750897958 89.42046162642166 43.27152530553932 +quadrupole 1 2 -3409420.6369619677 0.9852409861884698 -33.69103750897958 89.42046162642166 43.27152530553932 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_0.in b/examples/write/split_simulation_al/vasp_sim_al_0.in index bc69a7c..897a728 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_0.in +++ b/examples/write/split_simulation_al/vasp_sim_al_0.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 28.517806300141274p 23.744106628195063p 0.49696578370315025 300.22026356605477 75.69096733225767 -36.894969762184566 +shift 1 28.796976255513528p 23.744106628195063p 0.49696578370315025 300.2202635660547 75.69096733225767 -36.89496976218459 -quadrupole 1 2 -4237903.378587841 0.15475002879406435 119.91086470298939 107.44487850174394 -58.32192040478167 +quadrupole 1 2 -4237903.378587841 0.15475002879406444 119.91086470298939 107.44487850174397 -58.321920404781615 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_1.in b/examples/write/split_simulation_al/vasp_sim_al_1.in index 74287d6..783f151 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_1.in +++ b/examples/write/split_simulation_al/vasp_sim_al_1.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 28.517810300141377p 23.744056986791556p 0.49696594355577667 300.2203027407815 75.69104903077609 -36.895122935434586 +shift 1 28.79698025334301p 23.744056986791556p 0.49696594355577667 300.22030274078145 75.69104903077611 -36.895122935434614 -quadrupole 1 2 -4237935.238076809 0.15471905675314232 119.91082042347692 107.44577352512546 -58.30933489691791 +quadrupole 1 2 -4237935.238076813 0.15471905675314263 119.91082042347692 107.4457735251254 -58.309334896918 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_2.in b/examples/write/split_simulation_al/vasp_sim_al_2.in index f754a61..4807ee0 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_2.in +++ b/examples/write/split_simulation_al/vasp_sim_al_2.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 21.388626300141368p -6.257019743073291p 0.8367903155968939 139.5371039694557 37.278747979069905 -3.5709995529362515 +shift 1 21.671665014505038p -6.257019743073291p 0.8367903155968939 139.5371039694557 37.278747979069905 -3.570999552936264 -quadrupole 1 2 -2592229.2519974154 0.8443715250679894 183.21153936151418 135.30598602051853 99.94488259253322 +quadrupole 1 2 -2592229.2519974164 0.8443715250679895 183.21153936151418 135.30598602051853 99.94488259253325 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_3.in b/examples/write/split_simulation_al/vasp_sim_al_3.in index 7ee30ea..b407fd2 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_3.in +++ b/examples/write/split_simulation_al/vasp_sim_al_3.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 21.38870096680796p -6.256977303386671p 0.8367941766325279 139.5373733211059 37.2787843478556 -3.571643349265338 +shift 1 21.671739640652618p -6.256977303386671p 0.8367941766325279 139.5373733211059 37.2787843478556 -3.5716433492653503 -quadrupole 1 2 -2592248.889793758 0.8444092162822544 183.21871182805836 135.30537256707245 99.9564109109623 +quadrupole 1 2 -2592248.889793757 0.8444092162822548 183.21871182805833 135.30537256707245 99.95641091096228 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_4.in b/examples/write/split_simulation_al/vasp_sim_al_4.in index 57ae659..0bcae42 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_4.in +++ b/examples/write/split_simulation_al/vasp_sim_al_4.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 26.82932896680802p 18.916512119805702p 0.581483082371978 42.331773293948 95.1337895247013 5.760842708399566 +shift 1 27.109415200330886p 18.916512119805702p 0.581483082371978 42.331773293948 95.13378952470131 5.760842708399566 -quadrupole 1 2 -3278173.629342681 0.3547002286841776 221.89070050212965 91.17997390893728 64.5600497111172 +quadrupole 1 2 -3278173.6293426827 0.35470022868417767 221.89070050212962 91.17997390893728 64.56004971111722 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_5.in b/examples/write/split_simulation_al/vasp_sim_al_5.in index 7cc8d7f..a97da1b 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_5.in +++ b/examples/write/split_simulation_al/vasp_sim_al_5.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 26.82929996680798p 18.916504966291768p 0.5814836864516915 42.33183626741488 95.13380910165105 5.761105192773971 +shift 1 27.10938621606806p 18.916504966291768p 0.5814836864516915 42.331836267414886 95.13380910165105 5.7611051927739725 -quadrupole 1 2 -3278173.629342681 0.3547002286841776 221.89070050212965 91.17997390893728 64.5600497111172 +quadrupole 1 2 -3278173.6293426827 0.35470022868417767 221.89070050212962 91.17997390893728 64.56004971111722 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_6.in b/examples/write/split_simulation_al/vasp_sim_al_6.in index 55002b7..b66596f 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_6.in +++ b/examples/write/split_simulation_al/vasp_sim_al_6.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 27.00378963347464p -15.793349583521035p 0.7840648430136579 77.40686845203096 44.59627179084524 84.63191941039362 +shift 1 27.283781193237928p -15.793349583521035p 0.7840648430136579 77.40686845203096 44.59627179084524 84.63191941039362 -quadrupole 1 2 3402907.6864150735 0.9839516192937835 235.72036638710676 133.16907267064025 -0.9432217250969338 +quadrupole 1 2 3402907.686415075 0.9839516192937839 235.72036638710676 133.16907267064025 -0.9432217250969084 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/split_simulation_al/vasp_sim_al_7.in b/examples/write/split_simulation_al/vasp_sim_al_7.in index 3391813..17f68c1 100644 --- a/examples/write/split_simulation_al/vasp_sim_al_7.in +++ b/examples/write/split_simulation_al/vasp_sim_al_7.in @@ -3,35 +3,38 @@ spinsys { channels 27Al nuclei 27Al -shift 1 27.003783966807987p -15.793382124481582p 0.7840665519505524 77.40688677154138 44.596231250968955 84.63192023428246 +shift 1 27.28377552964639p -15.793382124481582p 0.7840665519505524 77.40688677154138 44.596231250968955 84.63192023428246 -quadrupole 1 2 3402907.6864150735 0.9839516192937835 235.72036638710676 133.16907267064025 -0.9432217250969338 +quadrupole 1 2 3402907.686415075 0.9839516192937839 235.72036638710676 133.16907267064025 -0.9432217250969084 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/vasp_sim_al.in b/examples/write/vasp_sim_al.in index 3468e9c..0f98512 100644 --- a/examples/write/vasp_sim_al.in +++ b/examples/write/vasp_sim_al.in @@ -3,49 +3,52 @@ spinsys { channels 27Al nuclei 27Al 27Al 27Al 27Al 27Al 27Al 27Al 27Al -shift 1 28.517806300141274p 23.744106628195063p 0.49696578370315025 300.22026356605477 75.69096733225767 -36.894969762184566 -shift 2 28.517810300141377p 23.744056986791556p 0.49696594355577667 300.2203027407815 75.69104903077609 -36.895122935434586 -shift 3 21.388626300141368p -6.257019743073291p 0.8367903155968939 139.5371039694557 37.278747979069905 -3.5709995529362515 -shift 4 21.38870096680796p -6.256977303386671p 0.8367941766325279 139.5373733211059 37.2787843478556 -3.571643349265338 -shift 5 26.82932896680802p 18.916512119805702p 0.581483082371978 42.331773293948 95.1337895247013 5.760842708399566 -shift 6 26.82929996680798p 18.916504966291768p 0.5814836864516915 42.33183626741488 95.13380910165105 5.761105192773971 -shift 7 27.00378963347464p -15.793349583521035p 0.7840648430136579 77.40686845203096 44.59627179084524 84.63191941039362 -shift 8 27.003783966807987p -15.793382124481582p 0.7840665519505524 77.40688677154138 44.596231250968955 84.63192023428246 - -quadrupole 1 2 -4237903.378587841 0.15475002879406435 119.91086470298939 107.44487850174394 -58.32192040478167 -quadrupole 2 2 -4237935.238076809 0.15471905675314232 119.91082042347692 107.44577352512546 -58.30933489691791 -quadrupole 3 2 -2592229.2519974154 0.8443715250679894 183.21153936151418 135.30598602051853 99.94488259253322 -quadrupole 4 2 -2592248.889793758 0.8444092162822544 183.21871182805836 135.30537256707245 99.9564109109623 -quadrupole 5 2 -3278173.629342681 0.3547002286841776 221.89070050212965 91.17997390893728 64.5600497111172 -quadrupole 6 2 -3278173.629342681 0.3547002286841776 221.89070050212965 91.17997390893728 64.5600497111172 -quadrupole 7 2 3402907.6864150735 0.9839516192937835 235.72036638710676 133.16907267064025 -0.9432217250969338 -quadrupole 8 2 3402907.6864150735 0.9839516192937835 235.72036638710676 133.16907267064025 -0.9432217250969338 +shift 1 28.796976255513528p 23.744106628195063p 0.49696578370315025 300.2202635660547 75.69096733225767 -36.89496976218459 +shift 2 28.79698025334301p 23.744056986791556p 0.49696594355577667 300.22030274078145 75.69104903077611 -36.895122935434614 +shift 3 21.671665014505038p -6.257019743073291p 0.8367903155968939 139.5371039694557 37.278747979069905 -3.570999552936264 +shift 4 21.671739640652618p -6.256977303386671p 0.8367941766325279 139.5373733211059 37.2787843478556 -3.5716433492653503 +shift 5 27.109415200330886p 18.916512119805702p 0.581483082371978 42.331773293948 95.13378952470131 5.760842708399566 +shift 6 27.10938621606806p 18.916504966291768p 0.5814836864516915 42.331836267414886 95.13380910165105 5.7611051927739725 +shift 7 27.283781193237928p -15.793349583521035p 0.7840648430136579 77.40686845203096 44.59627179084524 84.63191941039362 +shift 8 27.28377552964639p -15.793382124481582p 0.7840665519505524 77.40688677154138 44.596231250968955 84.63192023428246 + +quadrupole 1 2 -4237903.378587841 0.15475002879406444 119.91086470298939 107.44487850174397 -58.321920404781615 +quadrupole 2 2 -4237935.238076813 0.15471905675314263 119.91082042347692 107.4457735251254 -58.309334896918 +quadrupole 3 2 -2592229.2519974164 0.8443715250679895 183.21153936151418 135.30598602051853 99.94488259253325 +quadrupole 4 2 -2592248.889793757 0.8444092162822548 183.21871182805833 135.30537256707245 99.95641091096228 +quadrupole 5 2 -3278173.6293426827 0.35470022868417767 221.89070050212962 91.17997390893728 64.56004971111722 +quadrupole 6 2 -3278173.6293426827 0.35470022868417767 221.89070050212962 91.17997390893728 64.56004971111722 +quadrupole 7 2 3402907.686415075 0.9839516192937839 235.72036638710676 133.16907267064025 -0.9432217250969084 +quadrupole 8 2 3402907.686415075 0.9839516192937839 235.72036638710676 133.16907267064025 -0.9432217250969084 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inc - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 20000.0 - verbose 01 - variable tsw 20000.0 + crystal_file rep168 + detect_operator Inc + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 20000.0 + verbose 0 + variable offset 0.0 + variable tsw 20000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/examples/write/vasp_sim_p.in b/examples/write/vasp_sim_p.in index ecc4bf2..968d830 100644 --- a/examples/write/vasp_sim_p.in +++ b/examples/write/vasp_sim_p.in @@ -3,41 +3,44 @@ spinsys { channels 31P nuclei 31P 31P 31P 31P 31P 31P 31P 31P -shift 1 -31.37517499985887p -10.017885454189997p 0.574356782025788 -144.41674047227295 36.94605105115046 155.72037979835474 -shift 2 -25.912102666525413p -19.207649282399945p 0.6805549709989523 -5.1035607168904535 134.69063442515392 -273.43574767372627 -shift 3 -21.39543199985883p 24.54343683353636p 0.8112344064136188 144.9307149549837 109.44999723882509 141.6164001777775 -shift 4 -21.39543733319215p 24.543342597579567p 0.8112346636756782 144.93060821100497 109.45010118290232 141.6163152357628 -shift 5 -26.953617666525417p -16.175202200987275p 0.9799738910776477 35.119648100114624 169.67423334267676 -21.83766658357776 -shift 6 -26.95358733319216p -16.1752179058916p 0.9799712546586452 35.11859378408896 169.6741544535453 -21.83896458208024 -shift 7 -31.375266666525476p -10.017909334940402p 0.5743395755395448 -144.41671851881833 36.94574971948297 155.72015140233577 -shift 8 -25.912153666525455p -19.207674376160675p 0.6805556645251947 -5.103466766779169 134.6908207393528 -273.4351880805532 +shift 1 -31.279233015735713p -10.017885454189997p 0.574356782025788 -144.41674047227292 36.94605105115046 155.72037979835468 +shift 2 -25.817769083530266p -19.207649282399945p 0.6805549709989523 -5.103560716890429 134.69063442515392 -273.43574767372627 +shift 3 -21.302428184758412p 24.54343683353636p 0.8112344064136188 144.93071495498367 109.44999723882509 141.61640017777748 +shift 4 -21.30243351652149p 24.543342597579567p 0.8112346636756782 144.93060821100497 109.45010118290232 141.6163152357628 +shift 5 -26.85897744766703p -16.175202200987275p 0.9799738910776477 35.119648100114624 169.67423334267676 -21.837666583577764 +shift 6 -26.85894712326433p -16.1752179058916p 0.9799712546586452 35.11859378408896 169.6741544535453 -21.83896458208024 +shift 7 -31.279324655414428p -10.017909334940402p 0.5743395755395448 -144.41671851881827 36.94574971948297 155.72015140233577 +shift 8 -25.817820068515232p -19.207674376160675p 0.6805556645251947 -5.103466766779169 134.6908207393528 -273.4351880805532 } - par { - spin_rate 40000.0 - np 2048 - proton_frequency 800000000.0 - start_operator Inx - detect_operator Inp - method direct - crystal_file rep168 - gamma_angles 6 - variable sw 30000.0 - verbose 01 - variable tsw 30000.0 + crystal_file rep168 + detect_operator Inp + gamma_angles 6 + method direct + np 2048 + proton_frequency 800000000.0 + spin_rate 40000.0 + start_operator Inx + sw 30000.0 + verbose 0 + variable offset 0.0 + variable tsw 30000.0 } + proc pulseq {} { global par + offset $par(offset) acq_block { - delay $par(tsw) + delay $par(tsw) } } + proc main {} { global par set f [fsimpson] diff --git a/mkdocs.yml b/mkdocs.yml index 9c8f009..32f34d2 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -7,14 +7,16 @@ nav: - Installation: - installation/install.md - User Guide: - - Prepare Simpson simulations: user_guide/write_simpson.ipynb - - Read Simpson files: user_guide/read_files.ipynb + - Reading SIMPSON files: user_guide/01_reading_files.ipynb + - A Simpson python calculator: user_guide/02_simulation_calculator.ipynb + - From DFT to SIMPSON: user_guide/03_dft_to_simpson.ipynb - Code Documentation: reference/ - About: - about/contributors.md - about/changelog.md - about/license.md +site_url: https://nuts-org.github.io/simpyson/ repo_url: https://github.com/nuts-org/simpyson/ edit_uri: blob/main/docs/ @@ -81,9 +83,6 @@ plugins: - search: separator: '[\s\-,:!=\[\]()"`/]+|\.(?!\d)|&[lg]t;|(?!\b)(?=[A-Z][a-z])' - mknotebooks: - input_dir: notebooks - output_dir: docs/notebooks - exclude: ['.*_checkpoint.ipynb'] - autorefs - social - offline diff --git a/pyproject.toml b/pyproject.toml index 92081b6..6448bbc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -5,9 +5,9 @@ build-backend = "setuptools.build_meta" [project] name = "simpyson" description="A python interface to Simpson" -version = "0.1.1" +version = "0.2.0" readme = "README.md" -license = { text = "BSD-3" } +license = { text = "MIT" } authors = [ { name = "Carlos Bornes"}, { name = "Daniel Pereira"}, @@ -18,19 +18,21 @@ classifiers = [ "Development Status :: 3 - Alpha", "Intended Audience :: Science/Research", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", - "Intended Audience :: Science/Research", "Topic :: Scientific/Engineering", "Operating System :: Microsoft :: Windows", "Operating System :: Unix", "Operating System :: MacOS", ] -requires-python = ">=3.9" -dependencies = ["numpy", "ase", "pandas", "soprano", "plotly", "PyQt5", "PyQtWebEngine"] +requires-python = ">=3.10" +dependencies = [ + "numpy", "ase", "pandas", "soprano", "plotly", "PyQt5", "PyQtWebEngine", + "csdmpy", + "astropy", # missing from csdmpy dependency declaration +] [project.optional-dependencies] dev = ["codecov-cli>=0.4.1", "pytest>=7.4.0", "pytest-cov>=3.0.0", "ruff>=0.0.285"] @@ -40,7 +42,7 @@ docs = [ "mkdocs-gen-files>=0.5.0", "mkdocs-literate-nav>=0.6.0", "pillow>=10.0.0", - "cairosvg>=2.7.1" + "cairosvg>=2.7.1", ] [project.urls] diff --git a/src/simpyson/__init__.py b/src/simpyson/__init__.py index 9c4fb43..494380b 100644 --- a/src/simpyson/__init__.py +++ b/src/simpyson/__init__.py @@ -1,8 +1,18 @@ -"""Init data""" +"""SimPYson: A Pythonic interface for SIMPSON solid-state NMR simulations.""" from __future__ import annotations from importlib.metadata import version -# Load the version -__version__ = version("simpyson") \ No newline at end of file +from simpyson.calculator import SimpCalc, simulate_spectrum +from simpyson.io import read_simp +from simpyson.simpy import Simpy + +__version__ = version("simpyson") + +__all__ = [ + "SimpCalc", + "Simpy", + "read_simp", + "simulate_spectrum", +] diff --git a/src/simpyson/calculator.py b/src/simpyson/calculator.py new file mode 100644 index 0000000..0c664ad --- /dev/null +++ b/src/simpyson/calculator.py @@ -0,0 +1,772 @@ +from __future__ import annotations + +import contextlib +import logging +import math +import os +import re +import shutil +import subprocess +import tempfile +from pathlib import Path + +from simpyson.converter import ppm2hz +from simpyson.io import read_simp +from simpyson.templates import ( + CPMAS, + CustomPulseSequence, + PulseSequenceTemplate, + get_template, + pulseq_templates, +) +from simpyson.utils import get_larmor_freq, get_spin + +logger = logging.getLogger("simpyson") + + +def _proton_freq_to_b0(proton_freq): + """ + Convert a proton_frequency value to a b0 string like '800.0MHz'. + + Parameters + ---------- + proton_freq : int, float, or str + Proton frequency in Hz (numeric) or as a string with units. + + Returns + ------- + str or None + B0 string suitable for ``hz2ppm`` / ``ppm2hz``, or None if conversion + is not possible. + """ + unit_to_hz = {'hz': 1.0, 'khz': 1e3, 'mhz': 1e6, 'ghz': 1e9, 'thz': 1e12} + + if isinstance(proton_freq, (int, float)): + if proton_freq > 1e6: + return f"{proton_freq / 1e6:.1f}MHz" + # Small numeric values are assumed to already be in MHz + return f"{float(proton_freq)}MHz" + if isinstance(proton_freq, str): + match = re.match( + r'(\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\s*([kMGT]?Hz)?\s*$', + proton_freq.strip(), + re.IGNORECASE, + ) + if match: + value, unit = match.groups() + if not unit: + # Bare numeric strings follow the numeric rule: + # > 1e6 means Hz (e.g. '8e8' -> 800 MHz), otherwise MHz. + return _proton_freq_to_b0(float(value)) + # Normalise any Hz-based unit to MHz, since get_larmor_freq() + # only accepts 'T' or 'MHz'. + factor = unit_to_hz.get(unit.lower()) + if factor is not None: + return f"{float(value) * factor / 1e6}MHz" + return None + + +def _extract_nucleus(spinsys_str): + """ + Extract the observed nucleus from a SIMPSON spinsys string. + + Looks for the first nucleus on the ``channels`` line, falling back to the + first nucleus on the ``nuclei`` line. + + Parameters + ---------- + spinsys_str : str + SIMPSON spinsys block as a string. + + Returns + ------- + str or None + Nucleus string (e.g. ``'1H'``, ``'13C'``), or None if not found. + """ + # [^\n]+ instead of [\w\s]+: \s matches newlines, which made the old + # pattern swallow the following spinsys lines as well. + channels_match = re.search(r'channels[ \t]+([^\n]+)', spinsys_str) + if channels_match: + nuclei_list = channels_match.group(1).split() + if nuclei_list: + return nuclei_list[0] + nuclei_match = re.search(r'nuclei\s+(\w+)', spinsys_str) + if nuclei_match: + return nuclei_match.group(1) + return None + + +def _extract_turnoff_interactions(spinsys_str: str) -> list[str]: + """ + Return the interaction names present in a spinsys block. + + Scans for ``dipole`` and ``jcoupling`` lines and returns the names in the + form expected by SIMPSON's ``turnoff`` command (e.g. ``dipole_1_2``). + """ + interactions = [] + pattern = re.compile(r'(dipole|jcoupling)\s+(\d+)\s+(\d+)', re.IGNORECASE) + for line in spinsys_str.splitlines(): + m = pattern.match(line.strip()) + if m: + interactions.append(f"{m.group(1).lower()}_{m.group(2)}_{m.group(3)}") + return interactions + + +def _is_ct_operator(detect_op: str) -> bool: + """Return True if detect_op selects only the central transition.""" + return bool(re.search(r'I(?:n|\d+)c', detect_op)) + + +class SimpCalc: + """ + Generator for SIMPSON simulation input files (``.tcl``). + + Assembles the four main sections of a SIMPSON input file (spinsys, par, + pulseq, main) from a spin system definition, pulse sequence template, + and simulation parameters. + + Parameters + ---------- + spinsys : str or object + Spin system definition. Can be a SIMPSON spinsys block string, the + body of a spinsys block (starting with ``channels`` or ``nuclei``), + or a Soprano SpinSystem object with a ``to_simpson()`` method. + pulse_sequence : str, PulseSequenceTemplate, or None + Pulse sequence to use. Can be a template name (``'no_pulse'``, + ``'pulse_90'``, ``'cp_mas'``), a custom Tcl code string, a + ``PulseSequenceTemplate`` instance, or None for no pulse sequence. + **kwargs + Simulation parameters. Required: ``proton_frequency``, ``spin_rate``, + ``start_operator``, ``detect_operator``, ``np``, ``sw``, ``method``, + ``crystal_file``, ``gamma_angles``, ``verbose``. + + Output options: ``out_name``, ``out_format``, ``lb``, ``gauss_lb``, + ``zerofill``. Note that ``zerofill`` defaults to ``np`` (i.e. no + zero-filling); pass e.g. ``zerofill=2*np`` to interpolate the + spectrum. + + Raises + ------ + ValueError + If ``spinsys`` is None or ``pulse_sequence`` has an invalid type. + + Examples + -------- + >>> calc = SimpCalc( + ... spinsys="channels 1H\\nnuclei 1H\\nshift 1 5p 0 0 0 0 0", + ... pulse_sequence='no_pulse', + ... proton_frequency=400e6, spin_rate=10000, sw=20000, np=1024, + ... start_operator='Inx', detect_operator='Inp', method='direct', + ... crystal_file='rep100', gamma_angles=10, verbose=0, + ... ) + >>> calc.save("simulation.in") + """ + + @staticmethod + def _normalize_spinsys(spinsys: str | object) -> str: + """Return a canonical ``spinsys { … }`` block string.""" + if spinsys is None: + raise ValueError("spinsys cannot be None") + if hasattr(spinsys, 'to_simpson'): + spinsys = spinsys.to_simpson() + if not isinstance(spinsys, str): + raise ValueError( + f"spinsys must be a string or a Soprano SpinSystem object, got {type(spinsys)}" + ) + stripped = spinsys.strip() + if stripped.startswith("spinsys"): + return stripped + "\n" + return f"spinsys {{\n{stripped}\n}}\n" + + @property + def spinsys(self) -> str: + """The normalized ``spinsys { … }`` block string.""" + return self._spinsys + + @spinsys.setter + def spinsys(self, value: str | object) -> None: + self._spinsys = self._normalize_spinsys(value) + if hasattr(self, 'pulse_sequence') and isinstance(self.pulse_sequence, CPMAS): + self.pulse_sequence.turnoff_interactions = _extract_turnoff_interactions(self._spinsys) + + def __init__(self, spinsys: str | object, pulse_sequence: str | PulseSequenceTemplate | None = None, **kwargs) -> None: + self.spinsys = spinsys # calls setter, raises on bad input + self.parameters = kwargs + self.output_config = {} + + output_keys = ['out_name', 'out_format', 'lb', 'zerofill', 'gauss_lb'] + for key in output_keys: + if key in self.parameters: + self.output_config[key.replace('out_', '')] = self.parameters.pop(key) + + # hz = f_SPE - ref = (d_Hz - OFFSET) - (-OFFSET) = d_Hz + if 'variable_offset' in self.parameters and 'variable_ref' not in self.parameters: + self.parameters['variable_ref'] = -self.parameters['variable_offset'] + + self.pulse_sequence = self._setup_pulse_sequence(pulse_sequence) + + def __str__(self) -> str: + """Generate the complete SIMPSON input file as a string.""" + sections = [] + sections.append(self.generate_spinsys()) + sections.append(self.generate_par()) + sections.append(self.generate_pulseq()) + sections.append(self.generate_main()) + return "\n".join(sections) + + + def _setup_pulse_sequence(self, pulse_sequence: str | PulseSequenceTemplate | None) -> PulseSequenceTemplate | None: + """Set up the pulse sequence based on user input.""" + if pulse_sequence is None: + return None + + if isinstance(pulse_sequence, str): + if pulse_sequence in pulseq_templates: + template_class = pulseq_templates[pulse_sequence] + template_instance = template_class() + + # Get variable parameters + required_clean = {param.replace('variable_', '') + for param in template_instance.get_required_parameters()} + + # Extract matching parameters from user input + pulseq_params = {} + for param in required_clean: + if param in self.parameters: + pulseq_params[param] = self.parameters[param] + + # Pass offset if it exists + if 'variable_offset' in self.parameters: + pulseq_params['offset'] = self.parameters['variable_offset'] + + # Count channels so the template emits the right number of offset args + channels_match = re.search(r'channels\s+([^\n]+)', self.spinsys) + if channels_match: + pulseq_params['num_channels'] = len(channels_match.group(1).split()) + + # Create template with extracted parameters + return get_template(pulse_sequence, **pulseq_params) + else: + # Custom string sequence + return CustomPulseSequence(pulse_sequence, **self.parameters) + + elif isinstance(pulse_sequence, PulseSequenceTemplate): + return pulse_sequence + + else: + raise ValueError( + f"Invalid pulse_sequence type: {type(pulse_sequence)}. " + "Must be a template name (str), a custom string, or " + "a PulseSequenceTemplate object" + ) + + def generate_spinsys(self) -> str: + """ + Return the spinsys section of the SIMPSON input file. + + The spinsys is normalised once at construction (or when the + ``spinsys`` property is set) and returned verbatim here. + + Returns + ------- + str + The ``spinsys { … }`` block as a string. + """ + return self.spinsys + + def generate_par(self) -> str: + """ + Generate the par section of the SIMPSON input file. + + Returns + ------- + str + The par section as a string. + + Raises + ------ + ValueError + If required simulation parameters are missing. + """ + + # Parameters required for every simulation + required_params = { + "proton_frequency", "spin_rate", "start_operator", "detect_operator", + "np", "sw", "method", "crystal_file", "gamma_angles", "verbose" + } + + + missing_params = required_params - set(self.parameters.keys()) + if missing_params: + raise ValueError(f"Missing required parameters: {', '.join(missing_params)}") + + par_block = "par {\n" + + + for param in sorted(required_params): + if param in self.parameters: + value = self.parameters[param] + par_block += f" {param:<20} {value}\n" + + # Add pulse sequence parameters as variables + pulse_sequence_vars = set() + if self.pulse_sequence: + for param, value in sorted(self.pulse_sequence.parameters.items()): + if param.startswith('variable_'): + var_name = param.replace('variable_', '') + pulse_sequence_vars.add(var_name) + # Only add as variable if it's not already a standard parameter + if var_name not in required_params: + par_block += f" variable {var_name:<15} {value}\n" + + # Add other variables from parameters + for param, value in sorted(self.parameters.items()): + if param.startswith('variable_'): + var_name = param.replace('variable_', '') + if var_name not in pulse_sequence_vars: + par_block += f" variable {var_name:<15} {value}\n" + + # Add any remaining parameters + processed_params = required_params | {k for k in self.parameters if k.startswith('variable_')} | pulse_sequence_vars + remaining_params = {k: v for k, v in self.parameters.items() + if k not in processed_params} + + for param, value in sorted(remaining_params.items()): + if not param.startswith('out_'): + par_block += f" {param:<20} {value}\n" + + par_block += "}\n" + return par_block + + def generate_pulseq(self) -> str: + """ + Generate the pulseq section of the SIMPSON input file. + + Returns + ------- + str + The pulseq section as a string. + """ + if not self.pulse_sequence: + # Return empty pulseq block if no sequence provided + return "proc pulseq {} {}\n" + + # Lazily populate CPMAS turnoff list from the spinsys so this works + # even when a CPMAS instance is passed directly to SimpCalc. + if isinstance(self.pulse_sequence, CPMAS) and not self.pulse_sequence.turnoff_interactions: + self.pulse_sequence.turnoff_interactions = _extract_turnoff_interactions(self.spinsys) + + return self.pulse_sequence.generate_code() + + def generate_main(self) -> str: + """ + Generate the main section of the SIMPSON input file. + + Returns + ------- + str + The main section as a string. + + Raises + ------ + ValueError + If ``out_format`` is not one of ``'fid'``, ``'spe'``, ``'xreim'``. + """ + + # Output settings are popped from kwargs into output_config in __init__ + out_format = self.output_config.get('format', 'spe') + out_name = self.output_config.get('name', '$par(name)') + lb = self.output_config.get('lb', 20) + gauss_lb = self.output_config.get('gauss_lb', 0) + zerofill = self.output_config.get('zerofill', self.parameters.get('np', 0)) + + + indent = " " + + gauss_line = f"{indent}faddlb $f {gauss_lb} 1\n" if gauss_lb else "" + + if out_format == "fid": + return f""" +proc main {{}} {{ +{indent}global par +{indent}set f [fsimpson] +{indent}faddlb $f {lb} 0 +{gauss_line}{indent}fzerofill $f {zerofill} +{indent}fsave $f {out_name}.fid +}} +""" + elif out_format == "spe": + main_block = f""" +proc main {{}} {{ +{indent}global par +{indent}set f [fsimpson] +{indent}faddlb $f {lb} 0 +{gauss_line}{indent}fzerofill $f {zerofill} +{indent}fft $f +""" + if 'variable_ref' in self.parameters or 'ref' in self.parameters: + main_block += f"{indent}fset $f -ref $par(ref)\n" + + main_block += f"{indent}fsave $f {out_name}.spe\n}}\n" + return main_block + elif out_format == "xreim": + return f""" +proc main {{}} {{ +{indent}global par +{indent}set f [fsimpson] +{indent}fsave $f {out_name}.xreim -xreim +}} +""" + else: + raise ValueError(f"Unknown out_format '{out_format}'. Supported formats: 'fid', 'spe', 'xreim'") + + def save(self, filepath: str) -> None: + """ + Save the SIMPSON input file to disk. + + Parameters + ---------- + filepath : str + Path to write the ``.in`` / ``.tcl`` file. + """ + with Path(filepath).open('w') as file: + file.write(str(self)) + + def print(self) -> None: + """Print the SIMPSON input file to the console (stdout).""" + print(str(self)) # noqa: T201 + + def run( + self, + filepath: str | None = None, + timeout: int | None = None, + read_output: bool = True, + delete_files: bool = True, + b0: str | None = None, + nucleus: str | None = None, + simpson_path: str | None = None, + dry_run: bool = False, + ) -> str | object: + """ + Run the SIMPSON simulation and optionally read the results. + + Parameters + ---------- + filepath : str or None + Path to save the input file. If None, a temporary file is created. + timeout : int or None + Timeout in seconds for the SIMPSON process. + read_output : bool + If True (default), read the output file and return a Simpy object. + If False, return SIMPSON's stdout as a string. + delete_files : bool + If True (default), delete input and output files after reading. + b0 : str or None + Magnetic field strength (e.g., ``'400MHz'``). Auto-derived from + ``proton_frequency`` if not provided. Only used with + ``read_output=True``. + nucleus : str or None + Nucleus type (e.g., ``'1H'``). Auto-extracted from the spinsys + if not provided. Only used with ``read_output=True``. + simpson_path : str or None + Custom path to the SIMPSON executable. + dry_run : bool + If True, generate the input file and return the command string + without running SIMPSON. + + Returns + ------- + str or Simpy + The SIMPSON command (if ``dry_run``), stdout output (if not + ``read_output``), or a ``Simpy`` object with simulation results. + + Raises + ------ + FileNotFoundError + If SIMPSON is not found in PATH or at the specified path. + subprocess.TimeoutExpired + If the simulation exceeds the timeout. + subprocess.CalledProcessError + If SIMPSON returns a non-zero exit code. + """ + # Find the SIMPSON executable + simpson_executable = None + + if simpson_path: + if Path(simpson_path).exists(): + simpson_executable = simpson_path + else: + raise FileNotFoundError(f"SIMPSON executable not found at specified path: {simpson_path}") + + if simpson_executable is None: + simpson_executable = shutil.which("simpson") + + if simpson_executable is None and not dry_run: + raise FileNotFoundError( + "SIMPSON executable not found in PATH or at the specified path.\n" + "Please ensure SIMPSON is installed and available in your PATH, or provide the correct path." + ) + + temp_file = None + if filepath is None: + temp_fd, temp_file = tempfile.mkstemp(suffix='.in') + os.close(temp_fd) + filepath = temp_file + + base_filepath = str(Path(filepath).with_suffix('')) + + self.save(filepath) + + if dry_run: + cmd = [simpson_executable if simpson_executable else "simpson", filepath] + logger.info("Dry run: Generated input file at %s", filepath) + logger.info("Command: %s", ' '.join(cmd)) + return ' '.join(cmd) + + # Determine expected output filename/locations + # (output settings are popped from kwargs into output_config in __init__) + out_format = self.output_config.get('format', 'spe') + + out_name = self.output_config.get('name', base_filepath) + if out_name == '$par(name)': + out_name = base_filepath + + output_filename = f"{Path(out_name).name}.{out_format}" + + possible_locations = [ + str(Path(filepath).parent / output_filename), + str(Path.cwd() / output_filename), + f"{out_name}.{out_format}" + ] + + # Remember which candidate output files already exist, so cleanup + # never deletes a pre-existing user file that happens to share a name. + preexisting = {loc for loc in possible_locations if Path(loc).exists()} + + try: + cmd = [simpson_executable, filepath] + + try: + result = subprocess.run(cmd, + check=True, + capture_output=True, + text=True, + timeout=timeout) + except subprocess.CalledProcessError as e: + raise RuntimeError( + f"SIMPSON failed with exit code {e.returncode}.\n" + f"SIMPSON stderr:\n{e.stderr}\n" + f"SIMPSON stdout:\n{e.stdout}" + ) from e + + # Read output from run + if read_output: + output_file = None + for location in possible_locations: + if Path(location).exists(): + output_file = location + break + + if output_file is None: + raise FileNotFoundError( + f"SIMPSON output file not found. Looked in: {possible_locations}\n" + f"SIMPSON stdout: {result.stdout}\n" + f"SIMPSON stderr: {result.stderr}" + ) + + # Auto-extract magnetic field if not provided + if b0 is None and 'proton_frequency' in self.parameters: + b0 = _proton_freq_to_b0(self.parameters['proton_frequency']) + + # Auto-extract nucleus information if not provided. + # Use detect_operator (e.g. 'I2p') to identify, nucleus compare with spinsys nuclei list. + # Falls back to the first channel for global operators ('Inp', 'Inc'). + if nucleus is None: + spinsys_str = self.generate_spinsys() + detect_op = self.parameters.get('detect_operator', '') + indices = re.findall(r'I(\d+)', detect_op) + if indices: + nuclei_match = re.search(r'nuclei[ \t]+([^\n]+)', spinsys_str) + if nuclei_match: + nuclei_list = nuclei_match.group(1).split() + idx = int(indices[0]) - 1 # SIMPSON is 1-indexed + if 0 <= idx < len(nuclei_list): + nucleus = nuclei_list[idx] + if nucleus is None: + nucleus = _extract_nucleus(spinsys_str) + + # Read the output file + return read_simp(output_file, format=out_format, b0=b0, nucleus=nucleus) + else: + return result.stdout + + finally: + if delete_files: + if temp_file and Path(temp_file).exists(): + Path(temp_file).unlink() + elif filepath and Path(filepath).exists(): + Path(filepath).unlink() + + for location in possible_locations: + if location in preexisting: + continue + with contextlib.suppress(OSError): + Path(location).unlink(missing_ok=True) + +def simulate_spectrum( + spinsys: str | object, + delete_files: bool = True, + filepath: str | None = None, + **kwargs, +) -> object: + """ + Simulate a spectrum from a spin system with smart defaults. + + Automatically calculates the spectral width and center frequency from the + chemical shifts in the spin system, then runs a ``no_pulse`` simulation + via SIMPSON. + + Parameters + ---------- + spinsys : str or object + Spin system definition. Can be a SIMPSON spinsys string or a Soprano + SpinSystem object with a ``to_simpson()`` method. + delete_files : bool + If True (default), delete input/output files after simulation. + filepath : str or None + Path to save the SIMPSON input file. If None, uses a temporary file. + **kwargs + Override any default simulation parameter. Common overrides: + ``proton_frequency``, ``spin_rate``, ``lb``, ``zerofill``, + ``detect_operator``. + + Returns + ------- + Simpy + Object containing the simulated spectrum. + """ + # Defaults + defaults = { + 'proton_frequency': 800e6, + 'spin_rate': 30e3, + 'start_operator': 'Inx', + 'detect_operator': 'Inp', + 'crystal_file': 'rep2000', + 'gamma_angles': 16, + 'np': 4096, + 'method': 'direct', + 'verbose': 0, + 'out_format': 'spe', + 'lb': 100, + 'zerofill': 4096, + 'pulse_sequence': 'no_pulse' + } + + params = defaults.copy() + # Update with user kwargs + user_detect_op = 'detect_operator' in kwargs + params.update(kwargs) + + # Static spectra require gamma_angles=1 + if params.get('spin_rate', 0) == 0 and 'gamma_angles' not in kwargs: + params['gamma_angles'] = 1 + + # Extract spinsys string + spinsys_str = "" + if hasattr(spinsys, 'to_simpson'): + spinsys_str = spinsys.to_simpson() + else: + spinsys_str = str(spinsys) + + # Detect nucleus and spin early — needed for both detect_operator selection and SW estimation + b0 = _proton_freq_to_b0(params['proton_frequency']) + nucleus = _extract_nucleus(spinsys_str) or '1H' + spin = None + try: + spin = get_spin(nucleus) + except ValueError: + logger.debug("Could not determine spin for nucleus %s", nucleus) + + # Switch to Inc (central transition) for quadrupolar nuclei unless the user explicitly set detect_operator. + if not user_detect_op and spin is not None and spin > 0.5: + params['detect_operator'] = 'Inc' + + # Parse chemical shifts and quadrupolar couplings in one pass + shifts = [] + quadrupoles = [] + for line in spinsys_str.splitlines(): + stripped = line.strip() + if stripped.startswith('shift'): + parts = stripped.split() + if len(parts) > 2: + val_str = parts[2] + if val_str.endswith('p'): + shifts.append(float(val_str[:-1])) + else: + with contextlib.suppress(ValueError): + shifts.append(float(val_str)) + elif stripped.startswith('quadrupole'): + parts = stripped.split() + # quadrupole site order Cq eta alpha beta gamma + if len(parts) >= 4: + with contextlib.suppress(ValueError): + quadrupoles.append(abs(float(parts[3]))) + + spin_rate = params['spin_rate'] + + if 'sw' not in kwargs: + # get_larmor_freq() is signed (follows gamma). Spectral widths must use + # the magnitude, or every negative-gamma nucleus gets a collapsed / + # negative SW. The sign itself is still needed for the carrier offset. + nu_l_signed = get_larmor_freq(b0, nucleus) + gamma_sign = 1.0 if nu_l_signed >= 0 else -1.0 + nu_l_hz = abs(nu_l_signed) * 1e6 + is_ct = _is_ct_operator(params['detect_operator']) + + if shifts: + min_shift = min(shifts) + max_shift = max(shifts) + center_ppm = (min_shift + max_shift) / 2 + center_hz = ppm2hz(center_ppm, b0, nucleus) + width_hz = abs(ppm2hz(max_shift, b0, nucleus) - ppm2hz(min_shift, b0, nucleus)) + + if quadrupoles and is_ct: + # CT width dominated by second-order quadrupolar broadening + max_cq = max(quadrupoles) + required_sw = max(max_cq ** 2 / nu_l_hz, nu_l_hz * 10e-6) + else: + # Floor at 10 ppm so a single peak gets a usable window + required_sw = max(width_hz * 2, nu_l_hz * 10e-6) + + # The carrier offset is a rotating-frame frequency and follows the + # sign of gamma; the REF correction acts on the (sign-free) absolute + # axis, so it is always -center_hz. Verified empirically against + # SIMPSON for both gamma signs (13C and 29Si). + if 'variable_offset' not in kwargs: + params['variable_offset'] = gamma_sign * center_hz + if 'variable_ref' not in kwargs: + params['variable_ref'] = -center_hz + + elif quadrupoles: + max_cq = max(quadrupoles) + raw_sw = max_cq ** 2 / nu_l_hz if is_ct else 2.5 * max_cq + required_sw = max(raw_sw, nu_l_hz * 10e-6) + + else: + raise ValueError( + "Cannot auto-estimate spectral width: no 'shift' or 'quadrupole' " + "interactions found in spinsys. Provide 'sw' explicitly." + ) + + # Round up to the nearest multiple of spin_rate for MAS; use directly for static + if spin_rate > 0: + n = max(1, math.ceil(required_sw / spin_rate)) + sw_hz = n * spin_rate + else: + sw_hz = required_sw + + params['sw'] = sw_hz + + # Create calculator and run + calc = SimpCalc(spinsys, **params) + return calc.run(read_output=True, filepath=filepath, delete_files=delete_files) diff --git a/src/simpyson/cli.py b/src/simpyson/cli.py index b63e14c..0820066 100644 --- a/src/simpyson/cli.py +++ b/src/simpyson/cli.py @@ -1,16 +1,28 @@ +from __future__ import annotations + import argparse + from simpyson.gui import main as gui_main -def main(): + +def main() -> None: + """ + Entry point for the ``simpyson`` command-line interface. + + Subcommands + ----------- + gui + Launch the simpyson GUI. Optionally pass file paths to open on start. + """ parser = argparse.ArgumentParser(prog="simpyson") subparsers = parser.add_subparsers(dest="command") parser_gui = subparsers.add_parser("gui", help="Launch the GUI") - parser_gui.set_defaults(func=lambda args: gui_main()) + parser_gui.add_argument('files', nargs='*', help='Optional file(s) to open.') + parser_gui.set_defaults(func=lambda args: gui_main(args.files)) args = parser.parse_args() if hasattr(args, "func"): args.func(args) else: parser.print_help() - diff --git a/src/simpyson/converter.py b/src/simpyson/converter.py index a40674c..bf08dc3 100644 --- a/src/simpyson/converter.py +++ b/src/simpyson/converter.py @@ -1,147 +1,218 @@ +from __future__ import annotations + +from pathlib import Path + import ase.io import numpy as np import scipy.constants as const -import os -import json from simpyson.utils import get_larmor_freq -def read_vasp(file, format): - """ - This function reads NMR data from a VASP OUTCAR file. - Args: - file (str): The path to the VASP OUTCAR file. - format (str): The format of the VASP OUTCAR file. +def _find_line(lines: list[str], marker: str) -> int: + """Return the index of the last line containing *marker*, or raise.""" + idx = None + for i, line in enumerate(lines): + if marker in line: + idx = i + if idx is None: + raise ValueError( + f"Expected OUTCAR section '{marker}' not found. " + "Is this a VASP NMR calculation OUTCAR?" + ) + return idx - Returns: - ase.Atoms: The Atoms object with the NMR data. - Example: - reader = read_vasp('OUTCAR', 'vasp-out') +def read_vasp(file: str, format: str) -> ase.Atoms: + """ + Read NMR data from a VASP OUTCAR file. + + Parses electric field gradients (EFG) and magnetic shielding tensors from + a VASP NMR calculation and attaches them to an ASE Atoms object as arrays + named ``'efg'`` and ``'ms'``. + + Parameters + ---------- + file : str + Path to the VASP OUTCAR file. + format : str + ASE format string for reading the structure (e.g., ``'vasp-out'``). + + Returns + ------- + ase.Atoms + Atoms object with ``'efg'`` and ``'ms'`` arrays attached. + + Raises + ------ + ValueError + If the OUTCAR is missing expected NMR sections. + + Examples + -------- + >>> atoms = read_vasp('OUTCAR', 'vasp-out') + >>> atoms.get_array('ms') # magnetic shielding tensors """ - filename = ase.io.read(file, format=format) - n_atoms = filename.get_global_number_of_atoms() + atoms = ase.io.read(file, format=format) + n_atoms = atoms.get_global_number_of_atoms() np.set_printoptions(suppress=True) + + with Path(file).open() as outcar: + lines = outcar.readlines() + + # Locate required OUTCAR sections + idx_efg = _find_line(lines, "Electric field gradients (V/A^2)") + idx_sym = _find_line(lines, "SYMMETRIZED TENSORS") + idx_g0 = _find_line(lines, "G=0 CONTRIBUTION TO CHEMICAL SHIFT") + idx_core = _find_line(lines, "Core NMR properties") + + # Magnetic susceptibility + idx_sus = _find_line(lines, "Core contribution to magnetic susceptibility:") + sus_parts = lines[idx_sus].split() + mag_sus = float(sus_parts[5]) * 10 ** int(sus_parts[6][-2:]) + + # Cell volume (first occurrence) + volume = None + for line in lines: + if "volume of cell" in line: + volume = float(line.split()[4]) + break + if volume is None: + raise ValueError("Cell volume not found in OUTCAR.") + + # Avogadro-based conversion factor for magnetic susceptibility + chi_fact = 3.0 / 8.0 / np.pi * volume * 6.022142e23 / 1e24 + + # --- EFG tensors --- efg = [] + for i in range(n_atoms): + # EFG data starts 4 lines after the header: V_xx, V_yy, V_zz, V_xy, V_xz, V_yz + grad = lines[idx_efg + 4 + i].split()[1:] + matrix = np.array( + [ + [grad[0], grad[3], grad[4]], # xx xy xz + [grad[3], grad[1], grad[5]], # xy yy yz + [grad[4], grad[5], grad[2]], # xz yz zz + ] + ) + efg.append(matrix) + + # --- Symmetrized shielding tensors (3 rows per atom, every 4th line is a separator) --- sym_tensor = [] + for i in range(n_atoms * 4): + if i % 4 != 0: + sym_tensor.append(lines[idx_sym + i + 1].split()) + + # --- G=0 constant shielding (3x3 tensor) --- + # VASP 6.4.1+ has an extra description line + if lines[idx_g0 + 1].strip() == "using pGv susceptibility, excluding core contribution": + start_idx = idx_g0 + 5 + else: + start_idx = idx_g0 + 4 + const_shield = [] - core_shield_dict = [] - ms = [] - volume = None - with open(file, 'r') as outcar: - lines = outcar.readlines() - #Find lines with specific header - for line in lines: - if line.find("Electric field gradients (V/A^2)") != -1: - idx_header1 = lines.index(line) #efg - if line.find("SYMMETRIZED TENSORS") != -1: - idx_header2 = [] - idx_header2.append(lines.index(line)) #sym tensor - need to take second one (unsym. tensors) - if line.find("G=0 CONTRIBUTION TO CHEMICAL SHIFT") != -1: - idx_header3 = lines.index(line) #constant shielding - if line.find('Core NMR properties') != -1: - idx_header4 = lines.index(line) #core NMR prop - depends on atom type - if line.find("Core contribution to magnetic susceptibility:") != -1: - val = line.split()[5] - exp = line.split()[6][-2:] - mag_sus = float(val)*10**int(exp) - if line.find("volume of cell") != -1 and volume is None: - volume = float(line.split()[4]) - - chi_fact = 3.0/8.0/np.pi*volume*6.022142e23/1e24 # Conversion factor for magnetic susceptibility - - #Calculate tensors for every atoms - for i in range(n_atoms): - grad = (lines[idx_header1+4+i]).split()[1:] # V_xx, V_yy, V_zz, V_xy, V_xz, V_yz - matrix = np.array([[grad[0],grad[3],grad[4]], #xx xy xz - [grad[3],grad[1],grad[5]], #xy yy yz - [grad[4],grad[5],grad[2]]]) #xz yz zz - efg.append(matrix) - - for i in range(n_atoms*4): - if i % 4 != 0: - sym=lines[idx_header2[-1] + i + 1].split() - sym_tensor.append(lines[idx_header2[-1] + i + 1].split()) - - # Newer version of VASP 6.4.1 - if lines[idx_header3 + 1].strip() == "using pGv susceptibility, excluding core contribution": - start_idx = idx_header3 + 5 - # Older version of VASP - else: - start_idx = idx_header3 + 4 - - for i in range(3): - const_shield.append((lines[start_idx + i]).split()[1:]) - - for i in range(len(np.unique(filename.get_chemical_symbols()))): - core_shield_dict.append((lines[idx_header4 + 4 + i]).split()[1:]) - core_shield_dict = dict((k[0], float(k[1:][0])) for k in core_shield_dict) - core_shield = [] - - for i in filename.get_chemical_symbols(): - core_shield.append(core_shield_dict[i]) - - #Process results - efg = np.array(efg,dtype=float) #resulting EFG matrix + for i in range(3): + const_shield.append(lines[start_idx + i].split()[1:]) + + # --- Core shielding per element type --- + unique_elements = np.unique(atoms.get_chemical_symbols()) + core_shield_rows = [] + for i in range(len(unique_elements)): + core_shield_rows.append(lines[idx_core + 4 + i].split()[1:]) + core_shield_map = {row[0]: float(row[1]) for row in core_shield_rows} + core_shield = np.array([core_shield_map[el] for el in atoms.get_chemical_symbols()]) + + # --- Assemble results --- + efg = np.array(efg, dtype=float) efg = efg * 1e20 / const.physical_constants["atomic unit of electric field gradient"][0] - sym_tensor = np.split(np.array(sym_tensor,dtype=float), n_atoms) #symmetry tensors - const_shield = np.array(const_shield, dtype=float) #constant shielding of the lattice - core_shield = np.array(core_shield,dtype=float) #core shielding depending on atom type - + sym_tensor = np.split(np.array(sym_tensor, dtype=float), n_atoms) + const_shield = np.array(const_shield, dtype=float) + + ms = [] for i in range(n_atoms): core_diag = np.diag(core_shield[i] * np.ones(3)) - ms_tensor = sym_tensor[i] + const_shield + core_diag + mag_sus/chi_fact*1e6*np.eye(3) #calculating MS tensor - ms.append(-ms_tensor) # calculating MS tensors - ms=np.array(np.array(ms).tolist(),dtype=float) #processing MS tensor to work with ase - - filename.set_array('efg', efg) - filename.set_array('ms', ms) - - return filename - -def hz2ppm(hz, b0, nucleus, isotope_file=None): + ms_tensor = ( + sym_tensor[i] + + const_shield + + core_diag + + mag_sus / chi_fact * 1e6 * np.eye(3) + ) + ms.append(-ms_tensor) + ms = np.array(np.array(ms).tolist(), dtype=float) + + atoms.set_array('efg', efg) + atoms.set_array('ms', ms) + + return atoms + + +def hz2ppm( + hz: np.ndarray | float, + b0: str, + nucleus: str, + isotope_file: str | None = None, +) -> np.ndarray | float: """ - Convert Hz values to ppm values. - - Args: - hz (numpy.ndarray): Frequency values in Hz - b0 (str): Magnetic field strength (e.g., '400MHz' or '9.4T') - nucleus (str): Nucleus type (e.g., '1H' or '13C') - isotope_file (str, optional): Path to isotope data file. If None, uses default. - - Returns: - numpy.ndarray: Chemical shift values in ppm - - Raises: - ValueError: If B0 unit is invalid or nucleus not found + Convert frequency values from Hz to ppm. + + Parameters + ---------- + hz : numpy.ndarray or float + Frequency values in Hz. + b0 : str + Magnetic field strength (e.g., ``'400MHz'`` or ``'9.4T'``). + nucleus : str + Nucleus type (e.g., ``'1H'``, ``'13C'``). + isotope_file : str or None + Path to isotope data JSON file. If None, uses the bundled default. + + Returns + ------- + numpy.ndarray or float + Chemical shift values in ppm. + + Raises + ------ + ValueError + If the B0 unit is invalid or the nucleus is not found. """ - - larmor_freq = get_larmor_freq(b0, nucleus, isotope_file) - - ppm = hz / np.abs(larmor_freq) - - return ppm - -def ppm2hz(ppm, b0, nucleus, isotope_file=None): + # SIMPSON places +delta at +delta*|nu_L| regardless of the sign of gamma, + # so the axis conversion must use the Larmor frequency magnitude. + # Using the signed value mirrored every negative-gamma (29Si, 15N, ...) axis. + larmor_freq = abs(get_larmor_freq(b0, nucleus, isotope_file)) + return hz / larmor_freq + + +def ppm2hz( + ppm: np.ndarray | float, + b0: str, + nucleus: str, + isotope_file: str | None = None, +) -> np.ndarray | float: """ - Convert ppm values to Hz values. - - Args: - ppm (numpy.ndarray): Chemical shift values in ppm - b0 (str): Magnetic field strength (e.g., '400MHz' or '9.4T') - nucleus (str): Nucleus type (e.g., '1H' or '13C') - isotope_file (str, optional): Path to isotope data file. If None, uses default. - - Returns: - numpy.ndarray: Frequency values in Hz - - Raises: - ValueError: If B0 unit is invalid or nucleus not found + Convert chemical shift values from ppm to Hz. + + Parameters + ---------- + ppm : numpy.ndarray or float + Chemical shift values in ppm. + b0 : str + Magnetic field strength (e.g., ``'400MHz'`` or ``'9.4T'``). + nucleus : str + Nucleus type (e.g., ``'1H'``, ``'13C'``). + isotope_file : str or None + Path to isotope data JSON file. If None, uses the bundled default. + + Returns + ------- + numpy.ndarray or float + Frequency values in Hz. + + Raises + ------ + ValueError + If the B0 unit is invalid or the nucleus is not found. """ - - larmor_freq = get_larmor_freq(b0, nucleus, isotope_file) - - hz = ppm * np.abs(larmor_freq) - - return hz + # See hz2ppm: SIMPSON's frequency axis convention uses |nu_L|. + larmor_freq = abs(get_larmor_freq(b0, nucleus, isotope_file)) + return ppm * larmor_freq diff --git a/src/simpyson/gui.py b/src/simpyson/gui.py index ddf5f69..918aa58 100644 --- a/src/simpyson/gui.py +++ b/src/simpyson/gui.py @@ -1,35 +1,58 @@ # src/simpyson/gui.py +from __future__ import annotations -from PyQt5 import QtWidgets +import re import sys +import tempfile +from pathlib import Path + +import plotly.graph_objects as go +from PyQt5 import QtWidgets +from PyQt5.QtCore import Qt, QUrl +from PyQt5.QtWebEngineWidgets import QWebEngineView from PyQt5.QtWidgets import ( - QFileDialog, QMessageBox, QVBoxLayout, QWidget, QMainWindow, QAction, QInputDialog, - QSplitter, QListWidget, QHBoxLayout, QDialog, QFormLayout, QLineEdit, QDialogButtonBox + QAction, + QComboBox, + QDialog, + QDialogButtonBox, + QFileDialog, + QFormLayout, + QGroupBox, + QHBoxLayout, + QLabel, + QLineEdit, + QListWidget, + QMainWindow, + QMessageBox, + QPushButton, + QSplitter, + QVBoxLayout, + QWidget, ) -from PyQt5.QtCore import Qt -from PyQt5.QtWebEngineWidgets import QWebEngineView -import plotly.graph_objects as go -from simpyson.io import SimpReader -import numpy as np -import os -import copy -from simpyson.converter import hz2ppm, ppm2hz -from simpyson.utils import get_larmor_freq + +from simpyson.io import read_simp +from simpyson.utils import add_spectra, get_larmor_freq class SimpysonGUI(QMainWindow): - def __init__(self): + def __init__(self, files_to_open=None): super().__init__() self.setWindowTitle("Simpyson GUI") self.setGeometry(100, 100, 1200, 800) - self.files_data = {} # Dictionary to store {filename: data} + self.files_data = {} self.current_file = None self.data = None - self.filename = None # Added to store full path + self.filename = None + self.b0_edit = None + self.nucleus_edit = None + self.view_combo = None self.init_ui() + if files_to_open: + self.open_files(files_to_open) + def init_ui(self): self.create_menu() self.create_main_layout() @@ -39,7 +62,7 @@ def file_list_key_press(self, event): selected_items = self.file_list.selectedItems() if selected_items: confirmation = QMessageBox.question( - self, 'Remove Files', + self, 'Remove Files', f'Remove {len(selected_items)} selected file(s)?', QMessageBox.Yes | QMessageBox.No ) @@ -75,14 +98,52 @@ def create_main_layout(self): # Create splitter for resizable panels splitter = QSplitter(Qt.Horizontal) - # Create file list widget with multiple selection + # LEFT PANEL: file list + selection panel + left_panel = QWidget() + left_layout = QVBoxLayout(left_panel) + left_layout.setContentsMargins(0, 0, 0, 0) + left_layout.setSpacing(6) + + # File list self.file_list = QListWidget() self.file_list.setSelectionMode(QListWidget.ExtendedSelection) self.file_list.itemSelectionChanged.connect(self.on_selection_changed) - splitter.addWidget(self.file_list) self.file_list.keyPressEvent = self.file_list_key_press + left_layout.addWidget(self.file_list) + + # Selection settings panel + controls = QGroupBox('Selection settings') + form = QFormLayout(controls) + form.setContentsMargins(8, 8, 8, 8) - # Create plot area + self.b0_edit = QLineEdit() + self.b0_edit.setPlaceholderText('e.g., 400MHz or 9.4T') + form.addRow(QLabel('B0:'), self.b0_edit) + + self.nucleus_edit = QLineEdit() + self.nucleus_edit.setPlaceholderText('e.g., 1H or 13C') + form.addRow(QLabel('Nucleus:'), self.nucleus_edit) + + # View toggle (Hz/ppm) + self.view_combo = QComboBox() + self.view_combo.addItems(['Hz', 'ppm']) + form.addRow(QLabel('View:'), self.view_combo) + + # Action buttons + btn_row = QHBoxLayout() + apply_btn = QPushButton('Apply to selection') + apply_btn.clicked.connect(self.apply_selection_settings) + set_view_btn = QPushButton('Set view for selection') + set_view_btn.clicked.connect(self.change_view_from_combo) + btn_row.addWidget(apply_btn) + btn_row.addWidget(set_view_btn) + form.addRow(btn_row) + + left_layout.addWidget(controls) + + splitter.addWidget(left_panel) + + # RIGHT PANEL: plot area plot_widget = QWidget() plot_layout = QVBoxLayout(plot_widget) self.browser = QWebEngineView() @@ -90,7 +151,7 @@ def create_main_layout(self): plot_widget.setLayout(plot_layout) splitter.addWidget(plot_widget) - splitter.setSizes([200, 1000]) # Left panel 200px, rest for plot + splitter.setSizes([260, 940]) # Left panel width, rest for plot layout.addWidget(splitter) @@ -117,7 +178,7 @@ def create_menu(self): exit_action.triggered.connect(QtWidgets.qApp.quit) file_menu.addAction(exit_action) - # Process Menu + # Process Menu process_menu = menubar.addMenu('Process') setup_conversions = QAction('Setup Conversions', self) @@ -125,6 +186,11 @@ def create_menu(self): setup_conversions.setShortcut('Ctrl+g') process_menu.addAction(setup_conversions) + # Combine spectra menu + combine_spectra = QAction('Combine Spectra', self) + combine_spectra.triggered.connect(self.combine_selected_spectra) + process_menu.addAction(combine_spectra) + # View Menu view_menu = menubar.addMenu('View') @@ -157,39 +223,53 @@ def save_file(self): self, 'Save File', '', - 'All Supported Files (*.csv *.fid *.spe);;CSV Files (*.csv);;FID Files (*.fid);;SPE Files (*.spe)', + 'All Supported Files (*.csv *.fid *.spe *.xreim *.csdf);;CSV Files (*.csv);;' + 'FID Files (*.fid);;SPE Files (*.spe);;XREIM Files (*.xreim);;CSDF Files (*.csdf)', options=options ) - if not save_filename: return + if not save_filename: + return try: - format = save_filename.lower().split('.')[-1] + format = save_filename.lower().split('.')[-1] - if format not in ['spe', 'fid', 'csv']: + if format not in ['spe', 'fid', 'csv', 'xreim', 'csdf']: QMessageBox.warning(self, 'Save File', 'Unsupported file format!') return - self.data.save(save_filename, format=format) + self.data.write(save_filename, format=format) QMessageBox.information(self, 'Save File', 'File saved successfully!') except Exception as e: - QMessageBox.warning(self, 'Save File', f'Error saving file: {str(e)}') - - def open_file(self): - options = QFileDialog.Options() - filenames, _ = QFileDialog.getOpenFileNames( - self, 'Open File', '', 'SIMPSON Files (*.spe *.fid)', options=options - ) + QMessageBox.warning(self, 'Save File', f'Error saving file: {e!s}') + def open_files(self, filenames): for filename in filenames: if filename: - file_format = filename.split('.')[-1] - base_name = os.path.basename(filename) - data = SimpReader(filename, format=file_format) - view = 'hz' if file_format == 'spe' else 'fid' + file_format = Path(filename).suffix.lstrip('.').lower() + base_name = Path(filename).name + + if file_format in ('spe', 'csdf'): + view = 'hz' + elif file_format == 'fid': + view = 'fid' + elif file_format == 'xreim': + view = 'xreim' + else: + QMessageBox.warning( + self, 'Open File', + f'Unsupported file format: {base_name}. ' + 'Supported: .spe, .fid, .xreim, .csdf', + ) + continue + + try: + data = read_simp(filename, format=file_format) + except (OSError, ValueError) as e: + QMessageBox.warning(self, 'Open File', f'Error reading {base_name}: {e!s}') + continue - # Store both the data and full path self.files_data[base_name] = { 'data': data, 'path': filename, @@ -205,7 +285,17 @@ def open_file(self): self.current_file = base_name self.data = self.files_data[base_name]['data'] self.filename = filename - self.plot_data() + + if self.current_file: + self.plot_data() + + def open_file(self): + options = QFileDialog.Options() + filenames, _ = QFileDialog.getOpenFileNames( + self, 'Open File', '', 'SIMPSON Files (*.spe *.fid *.xreim *.csdf)', options=options + ) + if filenames: + self.open_files(filenames) def on_selection_changed(self): selected_items = self.file_list.selectedItems() @@ -226,98 +316,158 @@ def plot_data(self, selected_items=None): first_file = self.files_data[selected_items[0].text()] first_data = first_file['data'] - if not 'view' in first_file: + if 'view' not in first_file: QMessageBox.warning(self, 'Plot Data', 'Data does not contain valid axis information.') return + # Get data based on view match first_file['view']: case 'ppm': + if not first_data.ppm: + QMessageBox.warning(self, 'Plot Data', 'No ppm data available. Set B0 and nucleus first.') + return x_axis = 'ppm' + data_source = 'ppm' xlabel = 'Chemical Shift (ppm)' case 'hz': + if not first_data.spe: + QMessageBox.warning(self, 'Plot Data', 'No spectrum data available.') + return x_axis = 'hz' + data_source = 'spe' xlabel = 'Frequency (Hz)' case 'fid': + if not first_data.fid: + QMessageBox.warning(self, 'Plot Data', 'No FID data available.') + return x_axis = 'time' + data_source = 'fid' xlabel = 'Time (ms)' + case 'xreim': + if not first_data.xreim: + QMessageBox.warning(self, 'Plot Data', 'No xreim data available.') + return + x_axis = 'time' + data_source = 'xreim' + xlabel = 'Time' # Plot each selected spectrum for item in selected_items: data = self.files_data[item.text()]['data'] - if x_axis in data.data: + + # Access data via property (fid/spe/ppm) + data_dict = getattr(data, data_source) + if data_dict and x_axis in data_dict: fig.add_trace(go.Scatter( - x=data.data[x_axis], - y=data.data['real'], + x=data_dict[x_axis], + y=data_dict['real'], name=item.text(), mode='lines' )) + else: + QMessageBox.warning(self, 'Plot Data', f'Missing data for {item.text()}.') + continue # Update layout with consistent axis settings fig.update_layout( - title='NMR Spectrum', xaxis_title=xlabel, yaxis_title='Intensity', showlegend=True ) + # Remove grids + fig.update_xaxes(showgrid=False, showline=True, linewidth=2, linecolor='black', ticks='outside', tickwidth=2, tickcolor='black') + fig.update_yaxes(showgrid=False, showline=True, linewidth=2, linecolor='black', ticks='outside', tickwidth=2, tickcolor='black') + + fig.update_layout( + plot_bgcolor='rgba(0,0,0,0)', + paper_bgcolor='rgba(0,0,0,0)' + ) + # Always invert x-axis for ppm and hz - if x_axis in ['ppm', 'hz']: + if first_file['view'] in ['ppm', 'hz']: fig.update_xaxes(autorange="reversed") # Update plot display - html_content = fig.to_html(include_plotlyjs='cdn', full_html=True) - self.browser.setHtml(html_content) + html_content = fig.to_html(include_plotlyjs=True, full_html=True) + + html_content = re.sub(r':focus-visible\s*\{[^}]*\}', '', html_content) + + # Save to temp file and load + temp_path = Path(tempfile.gettempdir()) / 'simpyson_plot.html' + with temp_path.open('w', encoding='utf-8') as f: + f.write(html_content) + + self.browser.load(QUrl.fromLocalFile(str(temp_path))) else: self.browser.setHtml('

No data to display

') QMessageBox.warning(self, 'Plot Data', 'No data to plot!') - def change_view(self, view): - if not (selected_items := self.get_selection()): return - - if not all(self.has_setup(item.text()) for item in selected_items): - QMessageBox.warning(self, 'Not Setup', 'Not all selected items have been setup') + def apply_selection_settings(self): + if not (selected_items := self.get_selection()): return - + + b0 = self.b0_edit.text().strip() + nucleus = self.nucleus_edit.text().strip() + + if not (b0 and nucleus): + QMessageBox.warning(self, 'Selection settings', 'Please fill both B0 and Nucleus.') + return + + try: + # Validate inputs + _ = get_larmor_freq(b0, nucleus) + except ValueError as e: + QMessageBox.warning(self, 'Selection settings', f'Invalid input: {e}') + return + + # Apply to all selected files for item in selected_items: file_name = item.text() - file_data = self.files_data[file_name]['data'] - - view_key = 'time' if view == 'fid' else view + data = self.files_data[file_name]['data'] + data.b0 = b0 + data.nucleus = nucleus - if not view_key in file_data.data: - self.convert_to(file_name, view) + # If current view is ppm (selected in combo), update view too + if self.view_combo.currentText().lower() == 'ppm': + self.change_view_from_combo() + else: + self.plot_data(selected_items) - self.files_data[file_name]['view'] = view + # Change view based on combo for selected items + def change_view_from_combo(self): + if not (selected_items := self.get_selection()): + return + + desired = self.view_combo.currentText().lower() # 'hz' or 'ppm' + if desired == 'ppm' and not all(self.has_setup(item.text()) for item in selected_items): + QMessageBox.warning(self, 'Selection settings', 'B0 and Nucleus must be set for all selected items to use ppm.') + return + + for item in selected_items: + file_name = item.text() + self.files_data[file_name]['view'] = desired self.plot_data(selected_items) - def convert_to(self, file_name, target): - file_data = self.files_data[file_name]['data'] - - match target: - case 'fid': - if file_data.format == 'fid': return # Already FID - new_data = file_data.to_fid() - case 'hz': - if file_data.format == 'spe': return # SPE always has Hz - new_data = file_data.to_spe() - case 'ppm': - if 'ppm' in file_data.data: return # Already had ppm - if file_data.format == 'fid': - new_data = file_data.to_spe() - else: - new_data = file_data - hz = new_data.data['hz'] - b0 = new_data.b0 - nucleus = new_data.nucleus - new_data.data['ppm'] = hz2ppm(hz, b0, nucleus) + def change_view(self, view): + if not (selected_items := self.get_selection()): + return - self.files_data[file_name]['data'] = new_data - if file_name == self.current_file: self.data = new_data + if view == 'ppm' and not all(self.has_setup(item.text()) for item in selected_items): + QMessageBox.warning(self, 'Not Setup', 'B0 and nucleus must be set for PPM view') + return + + for item in selected_items: + file_name = item.text() + self.files_data[file_name]['view'] = view + + self.plot_data(selected_items) def setup_conversions(self): - if not (selected_items := self.get_selection()): return - + if not (selected_items := self.get_selection()): + return + dialog = QDialog(self) dialog.setWindowTitle('Setup Conversions') form = QFormLayout(dialog) @@ -342,11 +492,11 @@ def setup_conversions(self): if not (b0 and nucleus): return - + try: _ = get_larmor_freq(b0, nucleus) except ValueError as e: - QMessageBox.warning(self, 'Setup Conversions', f'Invalid Input: {str(e)}') + QMessageBox.warning(self, 'Setup Conversions', f'Invalid Input: {e!s}') return for item in selected_items: @@ -355,23 +505,72 @@ def setup_conversions(self): file_data.b0 = b0 file_data.nucleus = nucleus - + + # Combine spectra + def combine_selected_spectra(self): + """Combine multiple selected spectra into a single spectrum.""" + if not (selected_items := self.get_selection()): + return + + if len(selected_items) < 2: + QMessageBox.warning(self, 'Combine Spectra', 'Please select at least two spectra to combine') + return + + # Check that all selected items have spectrum data + for item in selected_items: + file_data = self.files_data[item.text()]['data'] + if not file_data.spe: + QMessageBox.warning(self, 'Combine Spectra', + f'{item.text()} is not in spectrum format. Convert all files to spectra first.') + return + + # Collect all Simpy objects + spectra_list = [self.files_data[item.text()]['data'] for item in selected_items] + + try: + # Combine spectra + combined = add_spectra(spectra_list) + + # Create a new name for the combined spectrum + base_names = [item.text().split('.')[0] for item in selected_items] + new_name = f"Combined_{'_'.join(base_names[:2])}" + if len(base_names) > 2: + new_name += f"_plus{len(base_names)-2}" + new_name += '.spe' + + # Add to file list + self.files_data[new_name] = { + 'data': combined, + 'path': None, + 'view': 'hz' + } + + self.file_list.addItem(new_name) + new_item = self.file_list.findItems(new_name, Qt.MatchExactly)[0] + self.file_list.setCurrentItem(new_item) + + QMessageBox.information(self, 'Combine Spectra', + f'Successfully combined {len(spectra_list)} spectra') + + except Exception as e: + QMessageBox.critical(self, 'Error', f'Failed to combine spectra: {e!s}') + def get_selection(self): selected_items = self.file_list.selectedItems() if not selected_items: QMessageBox.warning(self, 'No Selection', 'Please select at least one item') return None - + return selected_items def has_setup(self, file_name): data = self.files_data[file_name]['data'] return not (data.b0 is None or data.nucleus is None) -def main(): +def main(files=None): app = QtWidgets.QApplication(sys.argv) - gui = SimpysonGUI() + gui = SimpysonGUI(files_to_open=files) gui.show() sys.exit(app.exec_()) diff --git a/src/simpyson/io.py b/src/simpyson/io.py index d52985e..39fe85d 100644 --- a/src/simpyson/io.py +++ b/src/simpyson/io.py @@ -1,261 +1,247 @@ -# This module contains functions for analyzing NMR data from SIMPSON simulations. -# -# It provides functions for reading NMR data from SPE and FID files, performing -# Fourier transforms, and plotting NMR spectra. +from __future__ import annotations + +import logging +from collections.abc import Callable +from pathlib import Path import numpy as np -import json -import os -import sys -from soprano.calculate.nmr.simpson import write_spinsys -import copy -from simpyson.converter import hz2ppm - -class SimpReader: + +from simpyson.simpy import Simpy + +logger = logging.getLogger("simpyson") + + +def read_spe(filename: str, simpy_data: Simpy) -> None: """ - A class to read and process NMR data from SIMPSON files. + Read NMR data from a SIMPSON SPE file. + + Parameters + ---------- + filename : str + Path to the ``.spe`` file. + simpy_data : Simpy + Object to populate with spectrum data. + + Raises + ------ + ValueError + If required header fields (NP, SW) are missing. + """ + with Path(filename).open() as f: + data_sec = False + real: list[float] = [] + imag: list[float] = [] + ref = 0.0 + np_value: float | None = None + sw: float | None = None + for line in f: + if line.startswith('NP'): + np_value = float(line.split('=')[1]) + elif line.startswith('SW'): + sw = float(line.split('=')[1]) + elif line.startswith('REF'): + ref = float(line.split('=')[1]) + elif line.startswith('DATA'): + data_sec = True + elif data_sec and line.startswith('END'): + break + elif data_sec: + a, b = map(float, line.split()) + real.append(a) + imag.append(b) + + if np_value is None or sw is None: + raise ValueError( + f"Missing required header fields in {filename}: " + f"{'NP' if np_value is None else ''}" + f"{' and ' if np_value is None and sw is None else ''}" + f"{'SW' if sw is None else ''} not found." + ) + + if ref != 0.0: + logger.debug("Applying REF=%g Hz from SPE header: hz = f_SPE - REF", ref) + indices = np.arange(np_value) + hz = sw * (indices / np_value - 0.5) - ref + + simpy_data.from_spe(real, imag, np_value, sw, hz) - Attributes: - filename (str): The name of the file to read. - format (str): The format of the file (spe, fid, xreim). - b0 (str, optional): The magnetic field strength in MHz or T. - nucleus (str, optional): The nucleus type. - Example: - reader = SimpReader('spe_file', 'spe', b0='9.4T', nucleus='13C') +def read_fid(filename: str, simpy_data: Simpy) -> None: """ - def __init__(self, filename, format, b0=None, nucleus=None): - self.filename = filename - self.format = format - self.b0 = b0 - self.nucleus = nucleus - self._read_file() - - def _read_file(self): - if self.format == 'spe': - self._read_spe() - elif self.format == 'fid': - self._read_fid() - elif self.format == 'xreim': - self._read_xreim() - else: - raise ValueError('Invalid format. Supported formats are spe, fid, and xreim.') - - def _read_spe(self): - """ - This method reads NMR data from a SIMPSON SPE file. - """ - if self.b0 is None and self.nucleus is None: - with open(self.filename) as f: - data_sec = False - real = [] - imag = [] - for line in f: - if line.startswith('NP'): - np_value = float(line.split('=')[1]) - elif line.startswith('SW'): - sw = float(line.split('=')[1]) - elif line.startswith('DATA'): - data_sec = True - elif data_sec and line.startswith('END'): - break - elif data_sec: - a, b = map(float, line.split()) - real.append(a) - imag.append(b) - hz = np.linspace(-int(sw) / 2, int(sw) / 2, int(np_value)) - real = np.array(real) - imag = np.array(imag) - hz = np.array(hz) - self.data = {'real': real, 'imag': imag, 'np': np_value, 'sw': sw, 'hz': hz} - elif self.b0 is not None and self.nucleus is None or self.b0 is None and self.nucleus is not None: - raise ValueError('Both B0 and nucleus must be specified.') - else: - dir = os.path.dirname(os.path.realpath(__file__)) - with open(self.filename) as f: - data_sec = False - real = [] - imag = [] - for line in f: - if line.startswith('NP'): - np_value = float(line.split('=')[1]) - elif line.startswith('SW'): - sw = float(line.split('=')[1]) - elif line.startswith('DATA'): - data_sec = True - elif data_sec and line.startswith('END'): - break - elif data_sec: - a, b = map(float, line.split()) - real.append(a) - imag.append(b) - hz = np.linspace(-int(sw) / 2, int(sw) / 2, int(np_value)) - real = np.array(real) - imag = np.array(imag) - hz = np.array(hz) - - try: - ppm = hz2ppm(hz, self.b0, self.nucleus) - self.data = {'real': real, 'imag': imag, 'np': np_value, 'sw': sw, 'hz': hz, 'ppm': ppm} - except ValueError as e: - print(f"Error converting to ppm: {e}") - - def _read_fid(self): - """ - This method reads NMR data from a SIMPSON FID file. - """ - with open(self.filename) as f: - data_sec = False - real = [] - imag = [] - for line in f: - if line.startswith('NP'): - np_value = float(line.split('=')[1]) - elif line.startswith('SW'): - sw = float(line.split('=')[1]) - elif line.startswith('DATA'): - data_sec = True - elif data_sec and line.startswith('END'): - break - elif data_sec: - a, b = map(float, line.split()) - real.append(a) - imag.append(b) - dt = 1.0 / sw - time = np.linspace(0, np_value*dt, int(np_value)) - real = np.array(real) - imag = np.array(imag) - time = np.array(time)*10e3 - self.data = {'real': real, 'imag': imag, 'np': np_value, 'sw': sw, 'time': time} - - def _read_xreim(self): - """ - This method reads NMR data from a SIMPSON saved with -xreim option. - """ - with open(self.filename) as f: - time = [] - real = [] - imag = [] - for line in f: - time.append(float(line.split()[0])) - real.append(float(line.split()[1])) - imag.append(float(line.split()[2])) - time = np.array(time) - real = np.array(real) - imag = np.array(imag) - self.data = {'time': time, 'real': real, 'imag': imag} - - def to_spe(self): - """ - Converts FID data to spectrum (SPE). - - Raises: - ValueError: If the format is not FID. - - Returns: - SimpReader: A new SimpReader instance with SPE format data. - - Example: - spectrum = reader.to_spe() - """ - if self.format != 'fid': - raise ValueError('Only FID format can be converted to SPE.') - - spectrum = copy.deepcopy(self) - - npoints = spectrum.data['np'] - sw = spectrum.data['sw'] - raw_signal = spectrum.data['real'] + 1j * spectrum.data['imag'] - signal = np.fft.fftshift(np.fft.fft(raw_signal)) - real = np.real(signal) - imag = np.imag(signal) - hz = np.linspace(-sw/2, sw/2, int(npoints)) - spectrum.data = {'real': real, 'imag': imag, 'np': npoints, 'sw': sw, 'hz': hz} - - if spectrum.b0 is not None and spectrum.nucleus is not None: - try: - spectrum.data['ppm'] = hz2ppm(hz, spectrum.b0, spectrum.nucleus) - except ValueError as e: - print(f"Error converting to ppm: {e}") - - spectrum.format = 'spe' - - return spectrum - - def to_fid(self): - """ - Converts spectrum (SPE) data to FID. - - Raises: - ValueError: If the format is not SPE. - - Returns: - SimpReader: A new SimpReader instance with FID format data. - """ - if self.format != 'spe': - raise ValueError('Only SPE format can be converted to FID.') - - fid = copy.deepcopy(self) - - npoints = fid.data['np'] - sw = fid.data['sw'] - hz = fid.data['hz'] - signal = fid.data['real'] + 1j * fid.data['imag'] - signal = np.fft.ifft(np.fft.ifftshift(signal)) - real = np.real(signal) - imag = np.imag(signal) - dt = 1.0 / sw - time = np.linspace(0, npoints*dt, int(npoints)) * 10e3 # Match _read_fid scaling - fid.data = {'real': real, 'imag': imag, 'np': npoints, 'sw': sw, 'time': time} - - fid.format = 'fid' - - return fid - - def save(self, filename, format='csv'): - _format = self.format - - if format == 'csv': - if 'hz' in self.data: - x_data = self.data['hz'] - x_label = 'Hz' - elif 'ppm' in self.data: - x_data = self.data['ppm'] - x_label = 'ppm' - elif 'time' in self.data: - x_data = self.data['time'] - x_label = 'Time' - - np.savetxt( - filename, - np.column_stack((x_data, self.data['real'])), - delimiter=",", - header=f"{x_label},Real", - comments="" + Read NMR data from a SIMPSON FID file. + + Parameters + ---------- + filename : str + Path to the ``.fid`` file. + simpy_data : Simpy + Object to populate with FID data. + + Raises + ------ + ValueError + If required header fields (NP, SW) are missing. + """ + with Path(filename).open() as f: + data_sec = False + real: list[float] = [] + imag: list[float] = [] + np_value: float | None = None + sw: float | None = None + for line in f: + if line.startswith('NP'): + np_value = float(line.split('=')[1]) + elif line.startswith('SW'): + sw = float(line.split('=')[1]) + elif line.startswith('DATA'): + data_sec = True + elif data_sec and line.startswith('END'): + break + elif data_sec: + a, b = map(float, line.split()) + real.append(a) + imag.append(b) + + if np_value is None or sw is None: + raise ValueError( + f"Missing required header fields in {filename}: " + f"{'NP' if np_value is None else ''}" + f"{' and ' if np_value is None and sw is None else ''}" + f"{'SW' if sw is None else ''} not found." ) - return - if format != _format: - if format == 'spe': - self.to_spe() - if format == 'fid': - self.to_fid() + # Let from_fid() compute the time axis (avoids duplicating the calculation) + simpy_data.from_fid(np.array(real), np.array(imag), np_value, sw) - data = [ - 'SIMP\n', - f'NP={self.data["np"]}\n', - f'SW={self.data["sw"]}\n', - f'TYPE={format.upper()}\n', - 'DATA\n' - ] - for re, im in zip(self.data['real'], self.data['imag']): - data.extend(f'{re} {im}\n') +def read_xreim(filename: str, simpy_data: Simpy) -> None: + """ + Read NMR data from a SIMPSON file saved with the ``-xreim`` option. + + Parameters + ---------- + filename : str + Path to the ``.xreim`` file. + simpy_data : Simpy + Object to populate with xreim data. + """ + with Path(filename).open() as f: + time: list[float] = [] + real: list[float] = [] + imag: list[float] = [] + for line in f: + parts = line.split() + time.append(float(parts[0])) + real.append(float(parts[1])) + imag.append(float(parts[2])) - data.extend('END') + simpy_data.from_xreim(np.array(time), np.array(real), np.array(imag)) - with open(filename, 'w') as f: - f.writelines(data) - self.format = _format - return +def read_csdf(filename: str, simpy_data: Simpy) -> None: + """ + Read NMR data from a CSDF file (CSDM format). + + Requires the optional ``csdmpy`` dependency. The frequency axis is + always converted to Hz; files storing coordinates in other units (e.g. + kHz) are handled automatically via unit conversion. + + Parameters + ---------- + filename : str + Path to the ``.csdf`` file. + simpy_data : Simpy + Object to populate with spectrum data. + """ + import csdmpy as csdm # noqa: PLC0415 + + data = csdm.load(filename) + hz = data.dimensions[0].coordinates.to('Hz').value + real = data.dependent_variables[0].components[0].real + imag = data.dependent_variables[0].components[0].imag + np_value = len(hz) + if np_value < 2: + raise ValueError(f"CSDF file {filename!r} contains fewer than two points.") + # Full spectral width is N * step, not the coordinate span (N-1) * step + sw = float(np.abs(hz[1] - hz[0])) * np_value + + simpy_data.from_csdf(real, imag, hz, np_value, sw) + + +# Defined once, after the reader functions below +_EXT_TO_FMT: dict[str, str] = { + '.spe': 'spe', + '.fid': 'fid', + '.xreim': 'xreim', + '.csdf': 'csdf', +} + +_READERS: dict[str, Callable[[str, Simpy], None]] = { + 'spe': read_spe, + 'fid': read_fid, + 'xreim': read_xreim, + 'csdf': read_csdf, +} + + +def read_simp( + filename: str, + format: str | None = None, + b0: str | None = None, + nucleus: str | None = None, +) -> Simpy: + """ + Read SIMPSON NMR data from a file into a unified Simpy object. + + The file format is determined from the extension if ``format`` is not + given explicitly. + + Parameters + ---------- + filename : str + Path to the SIMPSON output file. + format : str or None + File format (``'spe'``, ``'fid'``, ``'xreim'``, ``'csdf'``). + If None, guessed from the file extension. + b0 : str or None + Magnetic field strength (e.g., ``'9.4T'``, ``'400MHz'``). + Needed for ppm conversion. + nucleus : str or None + Nucleus type (e.g., ``'1H'``, ``'13C'``). + Needed for ppm conversion. + + Returns + ------- + Simpy + Object containing the loaded data. + + Raises + ------ + ValueError + If the file format cannot be determined or is unsupported. + OSError + If the file cannot be read or parsed. + """ + if format is not None: + format = format.lower() + else: + ext = Path(filename).suffix.lower() + format = _EXT_TO_FMT.get(ext) + if format is None: + raise ValueError( + f"Cannot determine file format of {filename!r}. " + f"Supported extensions: {sorted(_EXT_TO_FMT)}" + ) + + reader = _READERS.get(format) + if reader is None: + raise ValueError( + f"Unsupported format {format!r}. Supported: {sorted(_READERS)}" + ) + + simpy_data = Simpy(b0=b0, nucleus=nucleus) + try: + reader(filename, simpy_data) + except (ValueError, KeyError, IndexError, OSError) as e: + raise OSError(f"Error reading {filename!r} as {format!r}: {e}") from e + return simpy_data diff --git a/src/simpyson/isotope_data.json b/src/simpyson/isotope_data.json index c1a9172..949b57f 100644 --- a/src/simpyson/isotope_data.json +++ b/src/simpyson/isotope_data.json @@ -2,13 +2,13 @@ "Ir": { "191": { "Spin": "3/2", - "NatAbudance": 37.3, + "NatAbundance": 37.3, "Gamma": 0.4812, "QMoment": 81.6 }, "193": { "Spin": "3/2", - "NatAbudance": 62.7, + "NatAbundance": 62.7, "Gamma": 0.5227, "QMoment": 75.1 } @@ -16,7 +16,7 @@ "Au": { "197": { "Spin": "3/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 0.47306, "QMoment": 54.7 } @@ -24,7 +24,7 @@ "U": { "235": { "Spin": "7/2", - "NatAbudance": 0.72, + "NatAbundance": 0.72, "Gamma": -0.52, "QMoment": 493.6 } @@ -32,13 +32,13 @@ "Os": { "187": { "Spin": "1/2", - "NatAbudance": 1.96, + "NatAbundance": 1.96, "Gamma": 0.61929, "QMoment": 0 }, "189": { "Spin": "3/2", - "NatAbudance": 16.15, + "NatAbundance": 16.15, "Gamma": 2.10713, "QMoment": 85.6 } @@ -46,13 +46,13 @@ "Hf": { "179": { "Spin": "9/2", - "NatAbudance": 13.62, + "NatAbundance": 13.62, "Gamma": -0.6821, "QMoment": 379.3 }, "177": { "Spin": "7/2", - "NatAbudance": 18.6, + "NatAbundance": 18.6, "Gamma": 1.086, "QMoment": 336.5 } @@ -60,19 +60,19 @@ "K": { "41": { "Spin": "3/2", - "NatAbudance": 6.7302, + "NatAbundance": 6.7302, "Gamma": 0.68607, "QMoment": 7.11 }, "39": { "Spin": "3/2", - "NatAbudance": 93.2581, + "NatAbundance": 93.2581, "Gamma": 1.25006, "QMoment": 5.85 }, "40": { "Spin": 4, - "NatAbudance": 0.0117, + "NatAbundance": 0.0117, "Gamma": -1.55429, "QMoment": -7.3 } @@ -80,7 +80,7 @@ "Er": { "167": { "Spin": "7/2", - "NatAbudance": 22.93, + "NatAbundance": 22.93, "Gamma": -0.77157, "QMoment": 356.5 } @@ -88,13 +88,13 @@ "Gd": { "155": { "Spin": "3/2", - "NatAbudance": 14.8, + "NatAbundance": 14.8, "Gamma": -0.82132, "QMoment": 127 }, "157": { "Spin": "3/2", - "NatAbudance": 15.65, + "NatAbundance": 15.65, "Gamma": -1.0769, "QMoment": 135 } @@ -102,7 +102,7 @@ "Rh": { "103": { "Spin": "1/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": -0.8468, "QMoment": 0 } @@ -110,7 +110,7 @@ "Fe": { "57": { "Spin": "1/2", - "NatAbudance": 2.119, + "NatAbundance": 2.119, "Gamma": 0.86806, "QMoment": 0 } @@ -118,13 +118,13 @@ "Nd": { "145": { "Spin": "7/2", - "NatAbudance": 8.3, + "NatAbundance": 8.3, "Gamma": -0.898, "QMoment": -33 }, "143": { "Spin": "7/2", - "NatAbudance": 12.2, + "NatAbundance": 12.2, "Gamma": -1.457, "QMoment": -63 } @@ -132,13 +132,13 @@ "Dy": { "161": { "Spin": "5/2", - "NatAbudance": 18.91, + "NatAbundance": 18.91, "Gamma": -0.9201, "QMoment": 250.7 }, "163": { "Spin": "5/2", - "NatAbudance": 24.9, + "NatAbundance": 24.9, "Gamma": 1.289, "QMoment": 264.8 } @@ -146,13 +146,13 @@ "Sm": { "149": { "Spin": "7/2", - "NatAbudance": 13.82, + "NatAbundance": 13.82, "Gamma": -0.9192, "QMoment": 7.4 }, "147": { "Spin": "7/2", - "NatAbudance": 14.99, + "NatAbundance": 14.99, "Gamma": -1.115, "QMoment": -25.9 } @@ -160,7 +160,7 @@ "Ge": { "73": { "Spin": "9/2", - "NatAbudance": 7.73, + "NatAbundance": 7.73, "Gamma": -0.93603, "QMoment": -19.6 } @@ -168,7 +168,7 @@ "Kr": { "83": { "Spin": "9/2", - "NatAbudance": 11.49, + "NatAbundance": 11.49, "Gamma": -1.0331, "QMoment": 25.9 } @@ -176,13 +176,13 @@ "Ag": { "107": { "Spin": "1/2", - "NatAbudance": 51.839, + "NatAbundance": 51.839, "Gamma": -1.08892, "QMoment": 0 }, "109": { "Spin": "1/2", - "NatAbudance": 48.161, + "NatAbundance": 48.161, "Gamma": -1.25186, "QMoment": 0 } @@ -190,7 +190,7 @@ "W": { "183": { "Spin": "1/2", - "NatAbudance": 14.31, + "NatAbundance": 14.31, "Gamma": 1.12824, "QMoment": 0 } @@ -198,7 +198,7 @@ "Sr": { "87": { "Spin": "9/2", - "NatAbudance": 7, + "NatAbundance": 7, "Gamma": -1.16394, "QMoment": 33.5 } @@ -206,7 +206,7 @@ "Pd": { "105": { "Spin": "5/2", - "NatAbudance": 22.33, + "NatAbundance": 22.33, "Gamma": -1.23, "QMoment": 66 } @@ -214,13 +214,13 @@ "Ru": { "99": { "Spin": "5/2", - "NatAbudance": 12.76, + "NatAbundance": 12.76, "Gamma": -1.229, "QMoment": 7.9 }, "101": { "Spin": "5/2", - "NatAbudance": 17.06, + "NatAbundance": 17.06, "Gamma": -1.377, "QMoment": 45.7 } @@ -228,13 +228,13 @@ "Yb": { "173": { "Spin": "5/2", - "NatAbudance": 16.13, + "NatAbundance": 16.13, "Gamma": -1.3025, "QMoment": 280 }, "171": { "Spin": "1/2", - "NatAbudance": 14.28, + "NatAbundance": 14.28, "Gamma": 4.7288, "QMoment": 0 } @@ -242,7 +242,7 @@ "Y": { "89": { "Spin": "1/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": -1.31628, "QMoment": 0 } @@ -250,13 +250,13 @@ "Ti": { "47": { "Spin": "5/2", - "NatAbudance": 7.44, + "NatAbundance": 7.44, "Gamma": -1.5105, "QMoment": 30.2 }, "49": { "Spin": "7/2", - "NatAbudance": 5.41, + "NatAbundance": 5.41, "Gamma": -1.51095, "QMoment": 24.7 } @@ -264,7 +264,7 @@ "Cr": { "53": { "Spin": "3/2", - "NatAbudance": 9.501, + "NatAbundance": 9.501, "Gamma": -1.5152, "QMoment": -15 } @@ -272,7 +272,7 @@ "Mg": { "25": { "Spin": "5/2", - "NatAbudance": 10, + "NatAbundance": 10, "Gamma": -1.63887, "QMoment": 19.94 } @@ -280,7 +280,7 @@ "Zn": { "67": { "Spin": "5/2", - "NatAbudance": 4.1, + "NatAbundance": 4.1, "Gamma": 1.67669, "QMoment": 15 } @@ -288,13 +288,13 @@ "Mo": { "95": { "Spin": "5/2", - "NatAbudance": 15.92, + "NatAbundance": 15.92, "Gamma": -1.751, "QMoment": -2.2 }, "97": { "Spin": "5/2", - "NatAbudance": 9.55, + "NatAbundance": 9.55, "Gamma": -1.788, "QMoment": 25.5 } @@ -302,13 +302,13 @@ "Hg": { "201": { "Spin": "3/2", - "NatAbudance": 13.18, + "NatAbundance": 13.18, "Gamma": -1.78877, "QMoment": 38.6 }, "199": { "Spin": "1/2", - "NatAbudance": 16.87, + "NatAbundance": 16.87, "Gamma": 4.84579, "QMoment": 0 } @@ -316,7 +316,7 @@ "Ca": { "43": { "Spin": "7/2", - "NatAbudance": 0.135, + "NatAbundance": 0.135, "Gamma": -1.80307, "QMoment": -4.08 } @@ -324,13 +324,13 @@ "N": { "14": { "Spin": "1", - "NatAbudance": 99.632, + "NatAbundance": 99.632, "Gamma": 1.93378, "QMoment": 2.044 }, "15": { "Spin": "1/2", - "NatAbudance": 0.368, + "NatAbundance": 0.368, "Gamma": -2.71262, "QMoment": 0 } @@ -338,7 +338,7 @@ "S": { "33": { "Spin": "3/2", - "NatAbudance": 0.76, + "NatAbundance": 0.76, "Gamma": 2.05568, "QMoment": -6.78 } @@ -346,7 +346,7 @@ "Ne": { "21": { "Spin": "3/2", - "NatAbudance": 0.27, + "NatAbundance": 0.27, "Gamma": -2.11308, "QMoment": 10.155 } @@ -354,13 +354,13 @@ "Lu": { "176": { "Spin": "7", - "NatAbudance": 2.59, + "NatAbundance": 2.59, "Gamma": 2.1684, "QMoment": 497 }, "175": { "Spin": "7/2", - "NatAbudance": 97.41, + "NatAbundance": 97.41, "Gamma": 3.0552, "QMoment": 349 } @@ -368,13 +368,13 @@ "Cl": { "37": { "Spin": "3/2", - "NatAbudance": 24.22, + "NatAbundance": 24.22, "Gamma": 2.18437, "QMoment": -6.435 }, "35": { "Spin": "3/2", - "NatAbudance": 75.78, + "NatAbundance": 75.78, "Gamma": 2.6242, "QMoment": -8.165 } @@ -382,13 +382,13 @@ "Xe": { "131": { "Spin": "3/2", - "NatAbudance": 21.18, + "NatAbundance": 21.18, "Gamma": 2.20908, "QMoment": -11.4 }, "129": { "Spin": "1/2", - "NatAbudance": 26.44, + "NatAbundance": 26.44, "Gamma": -7.4521, "QMoment": 0 } @@ -396,7 +396,7 @@ "Tm": { "169": { "Spin": "1/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": -2.218, "QMoment": 0 } @@ -404,7 +404,7 @@ "Ni": { "61": { "Spin": "3/2", - "NatAbudance": 1.1399, + "NatAbundance": 1.1399, "Gamma": -2.3948, "QMoment": 16.2 } @@ -412,7 +412,7 @@ "Zr": { "91": { "Spin": "5/2", - "NatAbudance": 11.22, + "NatAbundance": 11.22, "Gamma": -2.49743, "QMoment": -17.6 } @@ -420,13 +420,13 @@ "Rb": { "85": { "Spin": "5/2", - "NatAbudance": 72.17, + "NatAbundance": 72.17, "Gamma": 2.59271, "QMoment": 27.6 }, "87": { "Spin": "3/2", - "NatAbudance": 27.83, + "NatAbundance": 27.83, "Gamma": 8.7864, "QMoment": 13.35 } @@ -434,13 +434,13 @@ "Ba": { "135": { "Spin": "3/2", - "NatAbudance": 6.592, + "NatAbundance": 6.592, "Gamma": 2.6755, "QMoment": 16 }, "137": { "Spin": "3/2", - "NatAbudance": 11.232, + "NatAbundance": 11.232, "Gamma": 2.99295, "QMoment": 24.5 } @@ -448,13 +448,13 @@ "V": { "50": { "Spin": 6, - "NatAbudance": 0.25, + "NatAbundance": 0.25, "Gamma": 2.67065, "QMoment": 21 }, "51": { "Spin": "7/2", - "NatAbudance": 99.75, + "NatAbundance": 99.75, "Gamma": 7.04551, "QMoment": -5.2 } @@ -462,13 +462,13 @@ "B": { "10": { "Spin": "3", - "NatAbudance": 19.9, + "NatAbundance": 19.9, "Gamma": 2.87468, "QMoment": 8.459 }, "11": { "Spin": "3/2", - "NatAbudance": 80.1, + "NatAbundance": 80.1, "Gamma": 8.5847, "QMoment": 4.059 } @@ -476,13 +476,13 @@ "Eu": { "153": { "Spin": "5/2", - "NatAbudance": 52.19, + "NatAbundance": 52.19, "Gamma": 2.9369, "QMoment": 241.2 }, "151": { "Spin": "5/2", - "NatAbudance": 47.81, + "NatAbundance": 47.81, "Gamma": 6.651, "QMoment": 90.3 } @@ -490,7 +490,7 @@ "Ta": { "181": { "Spin": "7/2", - "NatAbudance": 99.988, + "NatAbundance": 99.988, "Gamma": 3.2438, "QMoment": 317 } @@ -498,13 +498,13 @@ "Sb": { "123": { "Spin": "7/2", - "NatAbudance": 42.79, + "NatAbundance": 42.79, "Gamma": 3.4892, "QMoment": -49 }, "121": { "Spin": "5/2", - "NatAbudance": 57.21, + "NatAbundance": 57.21, "Gamma": 6.4435, "QMoment": -36 } @@ -512,7 +512,7 @@ "Cs": { "133": { "Spin": "7/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 3.53325, "QMoment": -0.343 } @@ -520,13 +520,13 @@ "La": { "138": { "Spin": "5", - "NatAbudance": 0.09, + "NatAbundance": 0.09, "Gamma": 3.55724, "QMoment": 45 }, "139": { "Spin": "7/2", - "NatAbudance": 99.91, + "NatAbundance": 99.91, "Gamma": 3.80833, "QMoment": 20 } @@ -534,7 +534,7 @@ "O": { "17": { "Spin": "5/2", - "NatAbudance": 0.038, + "NatAbundance": 0.038, "Gamma": -3.62808, "QMoment": -2.558 } @@ -542,7 +542,7 @@ "Be": { "9": { "Spin": "3/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": -3.75967, "QMoment": 5.288 } @@ -550,13 +550,13 @@ "Li": { "6": { "Spin": "1", - "NatAbudance": 7.59, + "NatAbundance": 7.59, "Gamma": 3.93717, "QMoment": -0.0808 }, "7": { "Spin": "3/2", - "NatAbudance": 92.41, + "NatAbundance": 92.41, "Gamma": 10.3977, "QMoment": -4.01 } @@ -564,19 +564,19 @@ "H": { "2": { "Spin": "1", - "NatAbudance": 0.0115, + "NatAbundance": 0.0115, "Gamma": 4.10663, "QMoment": 0.286 }, "1": { "Spin": "1/2", - "NatAbudance": 99.9885, + "NatAbundance": 99.9885, "Gamma": 26.75221, "QMoment": 0 }, "3": { "Spin": "1/2", - "NatAbudance": 0, + "NatAbundance": 0, "Gamma": 28.53498, "QMoment": 0 } @@ -584,7 +584,7 @@ "Bi": { "209": { "Spin": "9/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 4.375, "QMoment": -51.6 } @@ -592,7 +592,7 @@ "As": { "75": { "Spin": "3/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 4.59616, "QMoment": 31.4 } @@ -600,7 +600,7 @@ "Se": { "77": { "Spin": "1/2", - "NatAbudance": 7.63, + "NatAbundance": 7.63, "Gamma": 5.12539, "QMoment": 0 } @@ -608,7 +608,7 @@ "Si": { "29": { "Spin": "1/2", - "NatAbudance": 4.6832, + "NatAbundance": 4.6832, "Gamma": -5.319, "QMoment": 0 } @@ -616,7 +616,7 @@ "I": { "127": { "Spin": "5/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 5.38957, "QMoment": -71 } @@ -624,7 +624,7 @@ "Pb": { "207": { "Spin": "1/2", - "NatAbudance": 22.1, + "NatAbundance": 22.1, "Gamma": 5.58046, "QMoment": 0 } @@ -632,13 +632,13 @@ "Cd": { "111": { "Spin": "1/2", - "NatAbudance": 12.8, + "NatAbundance": 12.8, "Gamma": -5.69831, "QMoment": 0 }, "113": { "Spin": "1/2", - "NatAbudance": 12.22, + "NatAbundance": 12.22, "Gamma": -5.96092, "QMoment": 0 } @@ -646,7 +646,7 @@ "Ho": { "165": { "Spin": "7/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 5.71, "QMoment": 358 } @@ -654,7 +654,7 @@ "Pt": { "195": { "Spin": "1/2", - "NatAbudance": 33.832, + "NatAbundance": 33.832, "Gamma": 5.8385, "QMoment": 0 } @@ -662,13 +662,13 @@ "In": { "113": { "Spin": "9/2", - "NatAbudance": 4.29, + "NatAbundance": 4.29, "Gamma": 5.8845, "QMoment": 79.9 }, "115": { "Spin": "9/2", - "NatAbudance": 95.71, + "NatAbundance": 95.71, "Gamma": 5.8972, "QMoment": 81 } @@ -676,7 +676,7 @@ "Tc": { "99": { "Spin": "9/2", - "NatAbudance": 0, + "NatAbundance": 0, "Gamma": 6.046, "QMoment": -12.9 } @@ -684,13 +684,13 @@ "Re": { "185": { "Spin": "5/2", - "NatAbudance": 37.4, + "NatAbundance": 37.4, "Gamma": 6.1057, "QMoment": 218 }, "187": { "Spin": "5/2", - "NatAbudance": 62.6, + "NatAbundance": 62.6, "Gamma": 6.1682, "QMoment": 207 } @@ -698,7 +698,7 @@ "Co": { "59": { "Spin": "7/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 6.332, "QMoment": 42 } @@ -706,13 +706,13 @@ "Ga": { "69": { "Spin": "3/2", - "NatAbudance": 60.108, + "NatAbundance": 60.108, "Gamma": 6.43886, "QMoment": 17.1 }, "71": { "Spin": "3/2", - "NatAbudance": 39.892, + "NatAbundance": 39.892, "Gamma": 8.18117, "QMoment": 10.7 } @@ -720,7 +720,7 @@ "Tb": { "159": { "Spin": "3/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 6.431, "QMoment": 143.2 } @@ -728,7 +728,7 @@ "Sc": { "45": { "Spin": "7/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 6.5088, "QMoment": -22 } @@ -736,7 +736,7 @@ "Nb": { "93": { "Spin": "9/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 6.5674, "QMoment": -32 } @@ -744,7 +744,7 @@ "Mn": { "55": { "Spin": "5/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 6.64525, "QMoment": 33 } @@ -752,13 +752,13 @@ "Br": { "79": { "Spin": "3/2", - "NatAbudance": 50.69, + "NatAbundance": 50.69, "Gamma": 6.72562, "QMoment": 31.3 }, "81": { "Spin": "3/2", - "NatAbudance": 49.31, + "NatAbundance": 49.31, "Gamma": 7.24978, "QMoment": 26.2 } @@ -766,7 +766,7 @@ "C": { "13": { "Spin": "1/2", - "NatAbudance": 1.07, + "NatAbundance": 1.07, "Gamma": 6.72828, "QMoment": 0 } @@ -774,7 +774,7 @@ "Al": { "27": { "Spin": "5/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 6.97627, "QMoment": 14.66 } @@ -782,13 +782,13 @@ "Te": { "123": { "Spin": "1/2", - "NatAbudance": 0.89, + "NatAbundance": 0.89, "Gamma": -7.0591, "QMoment": 0 }, "125": { "Spin": "1/2", - "NatAbudance": 7.07, + "NatAbundance": 7.07, "Gamma": -8.51084, "QMoment": 0 } @@ -796,7 +796,7 @@ "Na": { "23": { "Spin": "3/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 7.08085, "QMoment": 10.4 } @@ -804,13 +804,13 @@ "Cu": { "63": { "Spin": "3/2", - "NatAbudance": 69.17, + "NatAbundance": 69.17, "Gamma": 7.11179, "QMoment": -22 }, "65": { "Spin": "3/2", - "NatAbudance": 30.83, + "NatAbundance": 30.83, "Gamma": 7.60435, "QMoment": -20.4 } @@ -818,7 +818,7 @@ "Pr": { "141": { "Spin": "5/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 8.1907, "QMoment": -5.89 } @@ -826,19 +826,19 @@ "Sn": { "115": { "Spin": "1/2", - "NatAbudance": 0.34, + "NatAbundance": 0.34, "Gamma": -8.8013, "QMoment": 0 }, "117": { "Spin": "1/2", - "NatAbudance": 7.68, + "NatAbundance": 7.68, "Gamma": -9.58879, "QMoment": 0 }, "119": { "Spin": "1/2", - "NatAbudance": 8.59, + "NatAbundance": 8.59, "Gamma": -10.0317, "QMoment": 0 } @@ -846,7 +846,7 @@ "P": { "31": { "Spin": "1/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 10.8394, "QMoment": 0 } @@ -854,13 +854,13 @@ "Tl": { "203": { "Spin": "1/2", - "NatAbudance": 29.524, + "NatAbundance": 29.524, "Gamma": 15.53933, "QMoment": 0 }, "205": { "Spin": "1/2", - "NatAbudance": 70.476, + "NatAbundance": 70.476, "Gamma": 15.69218, "QMoment": 0 } @@ -868,7 +868,7 @@ "He": { "3": { "Spin": "1/2", - "NatAbudance": 0.00014, + "NatAbundance": 0.00014, "Gamma": -20.38016, "QMoment": 0 } @@ -876,7 +876,7 @@ "F": { "19": { "Spin": "1/2", - "NatAbudance": 100, + "NatAbundance": 100, "Gamma": 25.18148, "QMoment": 0 } diff --git a/src/simpyson/simpy.py b/src/simpyson/simpy.py new file mode 100644 index 0000000..6e221a9 --- /dev/null +++ b/src/simpyson/simpy.py @@ -0,0 +1,540 @@ +from __future__ import annotations + +import copy as cp +import logging +import warnings +from pathlib import Path + +import numpy as np + +from simpyson.converter import hz2ppm + +logger = logging.getLogger("simpyson") + + +class Simpy: + """ + Unified container for SIMPSON NMR data with automatic format conversions. + + Stores and manages SIMPSON data in multiple representations (FID, spectrum + in Hz, spectrum in ppm) and converts between them lazily on access. + + Parameters + ---------- + b0 : str or None + Magnetic field strength (e.g., ``'9.4T'``, ``'400MHz'``). + Required for ppm conversion. + nucleus : str or None + Nucleus type (e.g., ``'1H'``, ``'13C'``). + Required for ppm conversion. + + Examples + -------- + >>> from simpyson.io import read_simp + >>> data = read_simp("spectrum.spe", b0="400MHz", nucleus="13C") + >>> data.spe['hz'] # frequency axis in Hz + >>> data.ppm['ppm'] # chemical shift axis in ppm + """ + + def __init__(self, b0: str | None = None, nucleus: str | None = None) -> None: + self._b0 = b0 + self._nucleus = nucleus + self._fid_data: dict | None = None + self._spe_data: dict | None = None + self._xreim_data: dict | None = None + self._metadata: dict = {} + + def __repr__(self) -> str: + meta = [] + if self._b0: + meta.append(f"b0={self._b0!r}") + if self._nucleus: + meta.append(f"nucleus={self._nucleus!r}") + + data = [] + if self._fid_data is not None: + n, sw = int(self._fid_data['np']), self._fid_data['sw'] + data.append(f"fid(np={n}, sw={sw:.0f} Hz)") + if self._spe_data is not None: + n, sw = int(self._spe_data['np']), self._spe_data['sw'] + ppm_flag = " +ppm" if 'ppm' in self._spe_data else "" + data.append(f"spe(np={n}, sw={sw:.0f} Hz{ppm_flag})") + if self._xreim_data is not None: + data.append(f"xreim(n={len(self._xreim_data['time'])})") + + payload = ", ".join(data) if data else "empty" + prefix = (", ".join(meta) + ", ") if meta else "" + return f"Simpy({prefix}{payload})" + + @property + def b0(self) -> str | None: + """Magnetic field strength.""" + return self._b0 + + @b0.setter + def b0(self, value: str | None) -> None: + self._b0 = value + # Invalidate cached ppm data when b0 changes + if self._spe_data and 'ppm' in self._spe_data: + del self._spe_data['ppm'] + + @property + def nucleus(self) -> str | None: + """Nucleus type.""" + return self._nucleus + + @nucleus.setter + def nucleus(self, value: str | None) -> None: + self._nucleus = value + # Invalidate cached ppm data if nucleus changes + if self._spe_data and 'ppm' in self._spe_data: + del self._spe_data['ppm'] + + @property + def fid(self) -> dict | None: + """Access time-domain data, converting from spectrum if needed. + + Returns + ------- + dict or None + Dictionary with keys ``'real'``, ``'imag'``, ``'np'``, ``'sw'``, + ``'time'`` (in ms), or None if no data is available. + """ + if self._fid_data is None and self._spe_data is not None: + self._compute_fid() + return self._fid_data + + @property + def spe(self) -> dict | None: + """Access frequency-domain data, converting from FID if needed. + + Returns + ------- + dict or None + Dictionary with keys ``'real'``, ``'imag'``, ``'np'``, ``'sw'``, + ``'hz'`` (and optionally ``'ppm'``), or None if no data is + available. + """ + if self._spe_data is None and self._fid_data is not None: + self._compute_spectrum() + return self._spe_data + + @property + def ppm(self) -> dict | None: + """Access chemical shift data, computing from Hz if needed. + + Requires both ``b0`` and ``nucleus`` to be set. + + Returns + ------- + dict or None + Dictionary with keys ``'ppm'``, ``'real'``, ``'imag'``, or None + if conversion is not possible. + """ + if self.spe and 'ppm' not in self.spe and self._b0 and self._nucleus: + self._compute_ppm() + + if self.spe and 'ppm' in self.spe: + return { + 'ppm': self.spe['ppm'], + 'real': self.spe['real'], + 'imag': self.spe['imag'] + } + return None + + @property + def xreim(self) -> dict | None: + """Access xreim data. + + Returns + ------- + dict or None + Dictionary with keys ``'time'``, ``'real'``, ``'imag'``, or None. + """ + return self._xreim_data + + def _compute_spectrum(self) -> None: + """Convert FID to spectrum via FFT.""" + if not self._fid_data: + return + + npoints = self._fid_data['np'] + sw = self._fid_data['sw'] + signal = self._fid_data['real'] + 1j * self._fid_data['imag'] + spectrum = np.fft.fftshift(np.fft.fft(signal)) + + self._spe_data = { + 'real': np.real(spectrum), + 'imag': np.imag(spectrum), + 'np': npoints, + 'sw': sw, + 'hz': sw * (np.arange(int(npoints)) / int(npoints) - 0.5) + } + + def _compute_fid(self) -> None: + """Convert spectrum to FID via inverse FFT.""" + if not self._spe_data: + return + + npoints = self._spe_data['np'] + sw = self._spe_data['sw'] + signal = self._spe_data['real'] + 1j * self._spe_data['imag'] + time_signal = np.fft.ifft(np.fft.ifftshift(signal)) + dt = 1.0 / sw + + self._fid_data = { + 'real': np.real(time_signal), + 'imag': np.imag(time_signal), + 'np': npoints, + 'sw': sw, + 'time': np.arange(int(npoints)) * dt * 1e3 # seconds to milliseconds + } + + def _compute_ppm(self) -> None: + """Calculate ppm scale from Hz using b0 and nucleus.""" + if not (self._spe_data and 'hz' in self._spe_data): + return + + if not (self._b0 and self._nucleus): + return + + try: + self._spe_data['ppm'] = hz2ppm(self._spe_data['hz'], self._b0, self._nucleus) + except ValueError as e: + warnings.warn(f"Could not convert to ppm: {e}", stacklevel=2) + + def from_fid( + self, + real: np.ndarray | list, + imag: np.ndarray | list, + np_value: int | float, + sw: float, + time: np.ndarray | list | None = None, + ) -> Simpy: + """ + Populate this object with FID (time-domain) data. + + Parameters + ---------- + real : array_like + Real part of the FID signal. + imag : array_like + Imaginary part of the FID signal. + np_value : int or float + Number of data points. + sw : float + Spectral width in Hz. + time : array_like or None + Time axis in milliseconds. If None, calculated from ``sw`` and + ``np_value``. + + Returns + ------- + Simpy + Self, for method chaining. + """ + if time is None: + dt = 1.0 / sw + time = np.arange(int(np_value)) * dt * 1e3 # seconds to milliseconds + + self._fid_data = { + 'real': np.array(real), + 'imag': np.array(imag), + 'np': np_value, + 'sw': sw, + 'time': np.array(time) + } + + # Clear cached spectrum and xreim data + self._spe_data = None + self._xreim_data = None + return self + + def from_spe( + self, + real: np.ndarray | list, + imag: np.ndarray | list, + np_value: int | float, + sw: float, + hz: np.ndarray | list | None = None, + ) -> Simpy: + """ + Populate this object with spectrum (frequency-domain) data. + + Parameters + ---------- + real : array_like + Real part of the spectrum. + imag : array_like + Imaginary part of the spectrum. + np_value : int or float + Number of data points. + sw : float + Spectral width in Hz. + hz : array_like or None + Frequency axis in Hz. If None, calculated as a symmetric range + around zero based on ``sw``. + + Returns + ------- + Simpy + Self, for method chaining. + """ + if hz is None: + hz = sw * (np.arange(int(np_value)) / int(np_value) - 0.5) + + self._spe_data = { + 'real': np.array(real), + 'imag': np.array(imag), + 'np': np_value, + 'sw': sw, + 'hz': np.array(hz) + } + + # Calculate ppm if possible + if self._b0 and self._nucleus: + self._compute_ppm() + + # Clear cached FID and xreim data + self._fid_data = None + self._xreim_data = None + return self + + def from_xreim( + self, + time: np.ndarray | list, + real: np.ndarray | list, + imag: np.ndarray | list, + ) -> Simpy: + """ + Populate this object with xreim data. + + Parameters + ---------- + time : array_like + Time axis. + real : array_like + Real part of the signal. + imag : array_like + Imaginary part of the signal. + + Returns + ------- + Simpy + Self, for method chaining. + """ + self._xreim_data = { + 'time': np.array(time), + 'real': np.array(real), + 'imag': np.array(imag) + } + + # Clear cached FID and spectrum data + self._fid_data = None + self._spe_data = None + return self + + def from_csdf( + self, + real: np.ndarray | list, + imag: np.ndarray | list, + hz: np.ndarray | list, + np_value: int | float, + sw: float, + ) -> Simpy: + """ + Populate this object from CSDF (csdmpy) data. + + Parameters + ---------- + real : array_like + Real part of the spectrum. + imag : array_like + Imaginary part of the spectrum. + hz : array_like + Frequency axis in Hz. + np_value : int or float + Number of data points. + sw : float + Spectral width in Hz. + + Returns + ------- + Simpy + Self, for method chaining. + """ + self._spe_data = { + 'real': np.array(real), + 'imag': np.array(imag), + 'np': np_value, + 'sw': sw, + 'hz': np.array(hz) + } + + if self._b0 and self._nucleus: + self._compute_ppm() + + self._fid_data = None + return self + + def copy(self) -> Simpy: + """ + Create a deep copy of this Simpy object. + + Returns + ------- + Simpy + Independent copy with all data arrays duplicated. + """ + new_obj = Simpy(b0=self._b0, nucleus=self._nucleus) + + if self._fid_data is not None: + new_obj._fid_data = cp.deepcopy(self._fid_data) + + if self._spe_data is not None: + new_obj._spe_data = cp.deepcopy(self._spe_data) + + if self._xreim_data is not None: + new_obj._xreim_data = cp.deepcopy(self._xreim_data) + + new_obj._metadata = cp.deepcopy(self._metadata) + + return new_obj + + def write(self, filename: str, format: str = 'csv') -> Simpy: + """ + Write data to file in the specified format. + + Parameters + ---------- + filename : str + Output file path. + format : str + Output format. One of ``'csv'``, ``'spe'``, ``'fid'``, + ``'xreim'``, ``'csdf'``. + + Returns + ------- + Simpy + Self, for method chaining. + + Raises + ------ + ValueError + If the format is unsupported or no data is available. + """ + # CSV format + if format == 'csv': + if self.spe: + if 'ppm' in self.spe and self._b0 and self._nucleus: + x_data, x_label = self.spe['ppm'], 'ppm' + else: + x_data, x_label = self.spe['hz'], 'Hz' + y_data = self.spe['real'] + elif self.fid: + x_data, x_label = self.fid['time'], 'Time (ms)' + y_data = self.fid['real'] + elif self.xreim: + x_data, x_label = self.xreim['time'], 'Time (ms)' + y_data = self.xreim['real'] + else: + raise ValueError("No data to save") + + np.savetxt( + filename, + np.column_stack((x_data, y_data)), + delimiter=",", + header=f"{x_label},Real", + comments="" + ) + return self + + # xreim: plain 3-column "time real imag" text, matching what + # SIMPSON's `fsave -xreim` produces (and what read_xreim expects). + if format == 'xreim': + data_dict = self.xreim + if data_dict is None and self.fid is not None: + # Fall back to FID data, which carries an equivalent time axis + data_dict = self.fid + if not data_dict: + raise ValueError("No data available to save in xreim format") + + with Path(filename).open('w') as f: + for t_val, re_val, im_val in zip( + data_dict['time'], data_dict['real'], data_dict['imag'], + strict=True, + ): + f.write(f'{t_val} {re_val} {im_val}\n') + return self + + # CSDF (CSDM) format via the optional csdmpy dependency + if format == 'csdf': + self._write_csdf(filename) + return self + + # SIMPSON SPE/FID formats + if format == 'spe': + data_dict = self.spe + data_type = 'SPE' + elif format == 'fid': + data_dict = self.fid + data_type = 'FID' + else: + raise ValueError(f"Unsupported save format: {format}") + + if not data_dict: + raise ValueError(f"No data available to save in {format} format") + + # For spectra, preserve the frequency axis: read_spe() reconstructs + # hz = sw*(i/np - 0.5) - REF, so derive REF from the actual axis. + ref = 0.0 + if format == 'spe' and 'hz' in data_dict: + sw = data_dict['sw'] + ref = -sw / 2 - data_dict['hz'][0] + + # Write SIMPSON format file + with Path(filename).open('w') as f: + f.write('SIMP\n') + if 'np' in data_dict: + f.write(f'NP={int(data_dict["np"])}\n') + if 'sw' in data_dict: + f.write(f'SW={data_dict["sw"]}\n') + if abs(ref) > 1e-9: + f.write(f'REF={ref}\n') + f.write(f'TYPE={data_type}\n') + f.write('DATA\n') + + for re_val, im_val in zip(data_dict['real'], data_dict['imag'], strict=True): + f.write(f'{re_val} {im_val}\n') + + f.write('END') + + return self + + def _write_csdf(self, filename: str) -> None: + """Write frequency-domain data to a CSDF (CSDM) file. + + Requires the optional ``csdmpy`` dependency. + """ + import csdmpy as csdm # noqa: PLC0415 + + spe = self.spe + if not spe: + raise ValueError("No frequency-domain data to save in csdf format") + + hz = np.asarray(spe['hz'], dtype=float) + if len(hz) < 2: + raise ValueError("Need at least two points to save in csdf format") + + dimension = csdm.LinearDimension( + count=len(hz), + increment=f"{hz[1] - hz[0]} Hz", + coordinates_offset=f"{hz[0]} Hz", + ) + signal = np.asarray(spe['real']) + 1j * np.asarray(spe['imag']) + dependent_variable = csdm.as_dependent_variable(signal.astype(np.complex128)) + + csdm.CSDM( + dimensions=[dimension], + dependent_variables=[dependent_variable], + ).save(filename) diff --git a/src/simpyson/templates.py b/src/simpyson/templates.py index c269fbc..b4f9823 100644 --- a/src/simpyson/templates.py +++ b/src/simpyson/templates.py @@ -1,170 +1,273 @@ -class SimpSim: +from __future__ import annotations + +import re +from abc import ABC, abstractmethod +from typing import Any + + +class PulseSequenceTemplate(ABC): + """Base class for pulse sequence templates""" + + def __init__(self, **kwargs): + """ + Initialize pulse sequence template. + + Args: + **kwargs: Parameters to override defaults (without variable_ prefix) + """ + + self.parameters = self.get_default_parameters() + + prefixed_params = {} + for key, value in kwargs.items(): + prefixed_key = f"variable_{key}" if not key.startswith('variable_') else key + prefixed_params[prefixed_key] = value + + self.parameters.update(prefixed_params) + + # Validate parameters + self.validate_parameters() + + @abstractmethod + def get_default_parameters(self) -> dict[str, Any]: + """Return default parameters for this pulse sequence (with variable_ prefix)""" + + @abstractmethod + def get_required_parameters(self) -> set[str]: + """Return set of required parameter names (with variable_ prefix)""" + + def validate_parameters(self): + """Validate that all required parameters are present""" + missing = self.get_required_parameters() - set(self.parameters.keys()) + if missing: + missing_clean = {param.replace('variable_', '') for param in missing} + raise ValueError(f"Missing required parameters: {', '.join(missing_clean)}") + + def update_parameters(self, **kwargs): + """ + Update parameters and re-validate. + + Args: + **kwargs: Parameters to update (without variable_ prefix) + """ + + prefixed_params = {} + for key, value in kwargs.items(): + prefixed_key = f"variable_{key}" if not key.startswith('variable_') else key + prefixed_params[prefixed_key] = value + + self.parameters.update(prefixed_params) + self.validate_parameters() + +class NoPulse(PulseSequenceTemplate): """ - Class to create a SIMPSON simulation input. - - Attributes: - spinsys (str): Spin system from Soprano or a custom string. - out_name (str): Output file name. - out_format (str): Output format (fid, spe, xreim). - spin_rate (float): Spin rate in Hz. - np (int): Number of points. - proton_freq (float): Proton frequency in Hz. - start_op (str): Start operator. - detect_op (str): Detect operator. - crystal_file (str): Crystal file. - gamma_angles (str): Gamma angles. - sw (float): Spectral width. - verbose (bool): Verbose output. - lb (float): Line broadening. - zerofill (int): Zero filling. - method (str): Method of simulation (direct, indirect, ...). - tsw (str, optional): Spectral width in time domain. - pulse_sequence (str, optional): Pulse sequence from templates or a custom string. - pH (float, optional): pulse for H in us. - pX (float, optional): pulse for X in us. - pY (float, optional): pulse for Y in us. - plH (float, optional): power level for H in Hz. - plX (float, optional): power level for X in Hz. - plY (float, optional): power level for Y in Hz. - phH (float, optional): phase for H pH. - phX (float, optional): phase for X pH. - phY (float, optional): phase for Y pH. - - Example: - sim = SimpSim(spinsys=spinsys, out_name='output', out_format='spe', spin_rate=15e3, np=2048, proton_freq=400e6, start_op='Inx', detect_op='Inp', crystal_file='rep100', gamma_angles=4, sw=20e3, verbose=0, lb=20, zerofill=4096) + No pulse sequence - direct acquisition. + + Parameters: + tsw (float): Dwell time in microseconds. Default: '1e6/sw' """ - def __init__(self, spinsys, out_name, out_format, spin_rate, np, proton_freq, start_op, detect_op, crystal_file, gamma_angles, sw, verbose, lb, zerofill, method="direct", tsw=None, pulse_sequence=None, pH=None, pX=None, pY=None, plH=None, plX=None, plY=None, phH=None, phX=None, phY=None): - self.spin_rate = spin_rate - self.spinsys = spinsys - self.out_name = out_name - self.out_format = out_format - self.np = np - self.proton_freq = proton_freq - self.start_op = start_op - self.detect_op = detect_op - self.crystal_file = crystal_file - self.gamma_angles = gamma_angles - self.sw = sw - self.verbose = verbose - self.tsw = tsw if tsw else f"1e6/{sw}" - self.lb = lb - self.zerofill = zerofill - self.method = method - self.pulse_sequence = pulse_sequence - self.pH = pH - self.pX = pX - self.pY = pY - self.plH = plH - self.plX = plX - self.plY = plY - self.phH = phH - self.phX = phX - self.phY = phY - - def par_content(self): - par_block = f""" -par {{ - spin_rate {self.spin_rate} - np {self.np} - proton_frequency {self.proton_freq} - start_operator {self.start_op} - detect_operator {self.detect_op} - method {self.method} - crystal_file {self.crystal_file} - gamma_angles {self.gamma_angles} - variable sw {self.sw} - verbose {self.verbose} - variable tsw {self.tsw} -""" - if self.pH is not None: - if self.plH is None or self.phH is None: - raise ValueError("plH and phH must be defined if pH is defined") - par_block += f" pH {self.pH}\n" - par_block += f" plH {self.plH}\n" - par_block += f" phH {self.phH}\n" - - if self.pX is not None: - if self.plX is None or self.phX is None: - raise ValueError("plX and phX must be defined if pX is defined") - par_block += f" pX {self.pX}\n" - par_block += f" plX {self.plX}\n" - par_block += f" phX {self.phX}\n" - - if self.pY is not None: - if self.plY is None or self.phY is None: - raise ValueError("plY and phY must be defined if pY is defined") - par_block += f" pY {self.pY}\n" - par_block += f" plY {self.plY}\n" - par_block += f" phY {self.phY}\n" - - par_block += "}\n" - return par_block - - def pulseq_content(self): - if self.pulse_sequence: - return self.pulse_sequence - else: - return no_pulse - def main_content(self): - if self.out_format == "fid": - return f""" -proc main {{}} {{ - global par - set f [fsimpson] - faddlb $f {self.lb} 0 - fzerofill $f {self.zerofill} - fsave $f {self.out_name}.fid -}} -""" - elif self.out_format == "spe": - return f""" -proc main {{}} {{ + def get_default_parameters(self) -> dict[str, Any]: + return { + 'variable_tsw': '1e6/sw', + 'variable_offset': 0.0, + 'variable_num_channels': 1, + } + + def get_required_parameters(self) -> set[str]: + return {'variable_tsw'} + + @property + def description(self) -> str: + return "No pulse, direct acquisition" + + def generate_code(self) -> str: + offset_val = self.parameters.get('variable_offset', 0.0) + n_chan = int(self.parameters.get('variable_num_channels', 1)) + if offset_val == 0: + offset_line = "" + elif n_chan <= 1: + offset_line = " offset $par(offset)\n" + else: + extra = " 0" * (n_chan - 1) + offset_line = f" offset $par(offset){extra}\n" + return f""" +proc pulseq {{}} {{ global par - set f [fsimpson] - faddlb $f {self.lb} 0 - fzerofill $f {self.zerofill} - fft $f - fsave $f {self.out_name}.spe +{offset_line} acq_block {{ + delay $par(tsw) + }} }} """ - elif self.out_format == "xreim": - return f""" -proc main {{}} {{ + +class Pulse90(PulseSequenceTemplate): + """ + Single 90° pulse on 1H. + + On multi-channel spin systems, SIMPSON's ``pulse`` command requires an + rf/phase pair per channel; extra channels are padded with ``0 0``. + + Parameters: + pH (float): Pulse length in microseconds. Default: 5.0 + plH (float): Pulse power in Hz. Default: 50000 + phH (str): Pulse phase. Default: '90' + tsw (float): Dwell time in microseconds. Default: '1e6/sw' + """ + + def get_default_parameters(self) -> dict[str, Any]: + return { + 'variable_pH': 5.0, + 'variable_plH': 50000, + 'variable_phH': '90', + 'variable_tsw': '1e6/sw', + 'variable_num_channels': 1, + } + + def get_required_parameters(self) -> set[str]: + return {'variable_pH', 'variable_plH', 'variable_phH', 'variable_tsw'} + + @property + def description(self) -> str: + return "Single 90° pulse on 1H" + + def generate_code(self) -> str: + # SIMPSON requires one "rf phase" pair per channel on the pulse line + n_chan = int(self.parameters.get('variable_num_channels', 1)) + extra = " 0 0" * (n_chan - 1) + return f""" +proc pulseq {{}} {{ global par - set f [fsimpson] - fsave $f {self.out_name}.xreim -xreim + pulse $par(pH) $par(plH) $par(phH){extra} + acq_block {{ + delay $par(tsw) + }} }} """ - else: - raise ValueError(f"Unknown out_format {self.out_format}") - def __str__(self): - return f"{self.spinsys}\n{self.par_content()}{self.pulseq_content()}{self.main_content()}" - - def save(self, filepath): - with open(filepath, 'w') as file: - file.write(str(self)) +class CPMAS(PulseSequenceTemplate): + """ + Cross-polarization magic angle spinning sequence. + The initial 1H magnetization is set via ``start_operator`` (e.g. ``I1x``) + in the SIMPSON par block, so no explicit 90° pulse is needed here. -# Predefined pulse sequences -# No pulse sequence -no_pulse = """ -proc pulseq {} { - global par - acq_block { - delay $par(tsw) - } + Note: ``sw`` does not need to be commensurate with + ``spin_rate * gamma_angles``; SIMPSON samples ``acq_block`` at ``1/sw`` + independently of the block duration (verified empirically). + + Parameters: + pcp (float): Contact pulse length in μs. Default: 1000 + plHcp (float): 1H contact pulse power in Hz. Default: 70000 + phHcp (str): 1H contact pulse phase. Default: '0' + plCcp (float): 13C contact pulse power in Hz. Default: 69000 + phCcp (str): 13C contact pulse phase. Default: '0' + dw (str): Dwell time expression. Default: '1e6/spin_rate/gamma_angles' + """ + + def __init__(self, **kwargs): + # Populated by SimpCalc from the actual spinsys before generate_code() is called. + self.turnoff_interactions: list[str] = [] + super().__init__(**kwargs) + + def get_default_parameters(self) -> dict[str, Any]: + return { + 'variable_pcp': 1000, + 'variable_plHcp': 70000, + 'variable_phHcp': '0', + 'variable_plCcp': 69000, + 'variable_phCcp': '0', + 'variable_dw': '1e6/spin_rate/gamma_angles' + } + + def get_required_parameters(self) -> set[str]: + return { + 'variable_pcp', 'variable_plHcp', 'variable_phHcp', + 'variable_plCcp', 'variable_phCcp', 'variable_dw' + } + + @property + def description(self) -> str: + return "Cross-polarization magic angle spinning" + + def generate_code(self) -> str: + turnoff_line = ( + f" turnoff {' '.join(self.turnoff_interactions)}\n" + if self.turnoff_interactions else "" + ) + return ( + "\nproc pulseq {} {\n" + " global par\n" + " reset\n" + " pulse $par(pcp) $par(plHcp) $par(phHcp) $par(plCcp) $par(phCcp)\n" + + turnoff_line + + " acq_block {\n" + " delay $par(dw)\n" + " }\n" + "}\n" + ) + +pulseq_templates = { + 'no_pulse': NoPulse, + 'pulse_90': Pulse90, + 'cp_mas': CPMAS, } -""" -# 90 degree pulse -pulse_90 = """ -proc pulseq {} { +def get_template(name: str, **kwargs) -> PulseSequenceTemplate: + """ + Get a pulse sequence template by name. + + Args: + name: Template name ('no_pulse', 'pulse_90', 'cp_mas') + **kwargs: Parameters to override defaults + + Returns: + PulseSequenceTemplate: Configured template instance + """ + if name not in pulseq_templates: + available = ', '.join(pulseq_templates.keys()) + raise ValueError(f"Unknown template '{name}'. Available: {available}") + + return pulseq_templates[name](**kwargs) + +class CustomPulseSequence(PulseSequenceTemplate): + """Wrapper for custom string pulse sequences""" + + def __init__(self, code: str, **kwargs): + self.code = code + # Filter kwargs to only include parameters that appear in the code + + required = self.get_required_parameters() + filtered_kwargs = {} + for k, v in kwargs.items(): + # Accept both already-prefixed keys and unprefixed keys + if k in required or f"variable_{k}" in required: + filtered_kwargs[k] = v + + super().__init__(**filtered_kwargs) + + def get_default_parameters(self) -> dict[str, Any]: + return {} + + def get_required_parameters(self) -> set[str]: + # Extract parameter names from the code using regex + params = set() + pattern = r'\$par\(([^)]+)\)' + matches = re.findall(pattern, self.code) + for match in matches: + params.add(f"variable_{match}") + return params + + @property + def description(self) -> str: + return "Custom pulse sequence" + + def generate_code(self) -> str: + if self.code.strip().startswith("proc pulseq"): + return self.code + + return f""" +proc pulseq {{}} {{ global par - acq_block { - pulse $par(pH) $par(plH) $par(phH) - delay $par(tsw) - } -} -""" \ No newline at end of file +{self.code} +}} +""" diff --git a/src/simpyson/utils.py b/src/simpyson/utils.py index 4b18ce8..14d9847 100644 --- a/src/simpyson/utils.py +++ b/src/simpyson/utils.py @@ -1,47 +1,382 @@ -import os +from __future__ import annotations + import json +from pathlib import Path + import numpy as np +from soprano.calculate.nmr.simpson import _header_template, _spinsys_template +from soprano.data.nmr import _get_isotope_list +from soprano.properties.nmr.dipolar import DipolarCoupling +from soprano.selection import AtomSelection + + +def _default_isotope_file() -> str: + """Return the path to the bundled isotope data JSON file.""" + return str(Path(__file__).parent / 'isotope_data.json') + -def get_larmor_freq(b0, nucleus, isotope_file=None): - """ - Convert Hz values to ppm values. - - Args: - b0 (str): Magnetic field strength (e.g., '400MHz' or '9.4T') - nucleus (str): Nucleus type (e.g., '1H' or '13C') - isotope_file (str, optional): Path to isotope data file. If None, uses default. - - Returns: - float: Larmor Frequency - - Raises: - ValueError: If B0 unit is invalid or nucleus not found - """ - +def _load_isotope_data(nucleus: str, isotope_file: str | None = None) -> dict: + """ + Parse a nucleus string and load its isotope data row. + + Parameters + ---------- + nucleus : str + Nucleus type (e.g., ``'1H'``, ``'13C'``, ``'23Na'``). + isotope_file : str or None + Path to isotope data JSON file. If None, uses the bundled default. + + Returns + ------- + dict + The isotope data row (contains keys like ``'Gamma'``, ``'Spin'``). + + Raises + ------ + ValueError + If the nucleus is not found in the isotope data. + """ if isotope_file is None: - dir = os.path.dirname(os.path.realpath(__file__)) - isotope_file = os.path.join(dir, 'isotope_data.json') - - isotope = int(''.join(filter(str.isdigit, nucleus))) - element = ''.join(filter(str.isalpha, nucleus)).capitalize() - b0_unit = ''.join(filter(str.isalpha, b0)).lower() - - with open(isotope_file) as f: + isotope_file = _default_isotope_file() + + digits = ''.join(filter(str.isdigit, nucleus)) + letters = ''.join(filter(str.isalpha, nucleus)) + if not digits or not letters: + raise ValueError(f"Invalid nucleus {nucleus!r}. Expected a mass number + element, e.g. '13C'.") + + mass_number = int(digits) + element = letters.capitalize() + + with Path(isotope_file).open() as f: data = json.load(f) - if element in data and str(isotope) in data[element]: - gamma = data[element][str(isotope)]['Gamma'] - else: - raise ValueError(f'Nucleus {nucleus} not found in isotope data.') - + + if element in data and str(mass_number) in data[element]: + return data[element][str(mass_number)] + + raise ValueError(f'Nucleus {nucleus} not found in isotope data.') + + +def get_gamma(nucleus: str, isotope_file: str | None = None) -> float: + """ + Get the gyromagnetic ratio for a given nucleus. + + Parameters + ---------- + nucleus : str + Nucleus type (e.g., ``'1H'``, ``'13C'``). + isotope_file : str or None + Path to isotope data JSON file. If None, uses the bundled default. + + Returns + ------- + float + Gyromagnetic ratio in rad/(s*T) * 1e-7 (the value stored in the + isotope data file). + + Raises + ------ + ValueError + If the nucleus is not found in the isotope data. + """ + return _load_isotope_data(nucleus, isotope_file)['Gamma'] + + +def get_spin(nucleus: str, isotope_file: str | None = None) -> float: + """ + Get the spin quantum number for a given nucleus. + + Parameters + ---------- + nucleus : str + Nucleus type (e.g., ``'1H'``, ``'23Na'``). + isotope_file : str or None + Path to isotope data JSON file. If None, uses the bundled default. + + Returns + ------- + float + Spin quantum number (e.g., 0.5 for spin-1/2, 1.5 for spin-3/2). + + Raises + ------ + ValueError + If the nucleus is not found in the isotope data. + """ + spin_str = _load_isotope_data(nucleus, isotope_file)['Spin'] + if '/' in str(spin_str): + num, den = spin_str.split('/') + return float(num) / float(den) + return float(spin_str) + + +def get_larmor_freq(b0: str, nucleus: str, isotope_file: str | None = None) -> float: + """ + Calculate the Larmor frequency for a given nucleus at a given field strength. + + Parameters + ---------- + b0 : str + Magnetic field strength (e.g., '400MHz' or '9.4T'). + nucleus : str + Nucleus type (e.g., '1H' or '13C'). + isotope_file : str, optional + Path to isotope data file. If None, uses the bundled default. + + Returns + ------- + float + Larmor frequency in MHz. + + Raises + ------ + ValueError + If B0 unit is not 'T' or 'MHz', or if the nucleus is not found. + """ + gamma = get_gamma(nucleus, isotope_file=isotope_file) + b0_unit = ''.join(filter(str.isalpha, b0)).lower() + b0_value = float(''.join(filter(lambda x: x.isdigit() or x == '.', b0))) + + # gamma is stored as gamma / 1e7 in the isotope data file, + # so gamma * 1e7 gives the true value in rad/(s*T). if b0_unit == 't': - b0_value = float(''.join(filter(lambda x: x.isdigit() or x == '.', b0))) larmor_freq = gamma * 1e7 * b0_value / (2 * np.pi * 1e6) elif b0_unit == 'mhz': - b0_value = float(''.join(filter(lambda x: x.isdigit() or x == '.', b0))) - gamma_h = data['H']['1']['Gamma'] - b0_value_T = 2 * np.pi * b0_value * 1e6 / (gamma_h * 1e7) - larmor_freq = gamma * 1e7 * b0_value_T / (2 * np.pi * 1e6) + gamma_h = get_gamma('1H', isotope_file=isotope_file) + b0_tesla = 2 * np.pi * b0_value * 1e6 / (gamma_h * 1e7) + larmor_freq = gamma * 1e7 * b0_tesla / (2 * np.pi * 1e6) else: raise ValueError('B0 unit must be T or MHz.') - + return larmor_freq + +def add_spectra(spectra_list: list, b0: str | None = None, nucleus: str | None = None): + """ + Combine multiple Simpy objects into a single spectrum by summing. + + Parameters + ---------- + spectra_list : list of Simpy + Spectra to combine. All must have compatible frequency-domain data. + b0 : str, optional + Magnetic field override (e.g., '400MHz'). + nucleus : str, optional + Nucleus override (e.g., '1H'). + + Returns + ------- + Simpy or None + Combined spectrum, or None if the input list is empty. + + Raises + ------ + ValueError + If any spectrum in the list has no frequency-domain data. + """ + if not spectra_list: + return None + + # Validate spectra have frequency-domain data + spe_data_list = [] + for i, spectrum in enumerate(spectra_list, start=1): + spe = spectrum.spe + if spe is None: + raise ValueError(f"Spectrum #{i} has no frequency-domain data to combine.") + spe_data_list.append(spe) + + result = spectra_list[0].copy() + + if b0: + result.b0 = b0 + if nucleus: + result.nucleus = nucleus + + if len(spectra_list) == 1: + return result + + # Check whether all spectra share the same Hz axis + ref_hz = spe_data_list[0]['hz'] + axes_match = all( + len(spe['hz']) == len(ref_hz) and np.allclose(spe['hz'], ref_hz) + for spe in spe_data_list[1:] + ) + + if axes_match: + # Fast path: identical Hz axes, just sum element-wise + for spe in spe_data_list[1:]: + result.spe['real'] += spe['real'] + result.spe['imag'] += spe['imag'] + else: + # Interpolate all spectra onto a common Hz grid + hz_min = min(spe['hz'][0] for spe in spe_data_list) + hz_max = max(spe['hz'][-1] for spe in spe_data_list) + + # Use the smallest Hz step among all spectra + steps = [spe['sw'] / spe['np'] for spe in spe_data_list] + finest_step = min(steps) + + n_common = int(np.ceil((hz_max - hz_min) / finest_step)) + 1 + common_hz = np.linspace(hz_min, hz_max, n_common) + + # Interpolate and sum all spectra on common grid + sum_real = np.zeros(n_common) + sum_imag = np.zeros(n_common) + + for spe in spe_data_list: + sum_real += np.interp(common_hz, spe['hz'], spe['real'], + left=0.0, right=0.0) + sum_imag += np.interp(common_hz, spe['hz'], spe['imag'], + left=0.0, right=0.0) + + # Full spectral width is N * step, not the coordinate span (N-1) * step + common_sw = (common_hz[1] - common_hz[0]) * n_common + result.from_spe(sum_real, sum_imag, n_common, common_sw, common_hz) + + if result.b0 and result.nucleus: + result._compute_ppm() + + return result + +def simple_spinsys( + atoms: object, + isotopes: dict, + iso_ms: list | None = None, + aniso_ms: list | None = None, + eta_ms: list | None = None, + euler_ms: list | None = None, + cq: list | None = None, + eta_q: list | None = None, + q_order: list | None = None, + euler_q: list | None = None, + get_dipolar: bool = False, + dip_sel: object | None = None, + obs_nuc: str | None = None, +) -> str: + """ + Build a SIMPSON spinsys string from manually provided NMR parameters. + + Use this when you don't have DFT-derived data and want to construct a + spin system by hand (e.g., for quick tests or educational purposes). + For DFT-derived spin systems, use Soprano instead. + + Parameters + ---------- + atoms : ase.Atoms + Atoms object defining the molecular structure. + isotopes : dict + Mapping of element symbol to mass number (e.g., ``{'H': 1, 'C': 13}``). + iso_ms : list of float or None + Isotropic chemical shifts in ppm, one per atom. + aniso_ms : list of float or None + Shielding anisotropies in ppm. Defaults to zeros. + eta_ms : list of float or None + Shielding asymmetry parameters. Defaults to zeros. + euler_ms : list of array_like or None + Euler angles ``(alpha, beta, gamma)`` in degrees for the shielding + tensor. Defaults to zeros. + cq : list of float or None + Quadrupolar coupling constants in Hz. + eta_q : list of float or None + Quadrupolar asymmetry parameters. Defaults to zeros. + q_order : list of int or None + Quadrupolar perturbation orders (must be <= 2). Defaults to 2. + euler_q : list of array_like or None + Euler angles ``(alpha, beta, gamma)`` in degrees for the EFG tensor. + Defaults to zeros. + get_dipolar : bool + If True, calculate and include dipolar couplings. + dip_sel : AtomSelection or None + Selection of atoms for dipolar couplings. Defaults to all atoms. + obs_nuc : str or None + Observed nucleus (e.g., ``'13C'``). Placed first in the channels list. + + Returns + ------- + str + Complete SIMPSON spinsys block as a string. + + Raises + ------ + ValueError + If a quadrupolar order exceeds 2. + """ + + # Header Block + symbols = atoms.get_chemical_symbols() + isotope_list = _get_isotope_list(symbols, isotopes=isotopes) + nuclei = [f"{iso}{el}" for el, iso in zip(symbols, isotope_list, strict=False)] + + if obs_nuc and obs_nuc in nuclei: + channels = [obs_nuc] + [n for n in sorted(set(nuclei)) if n != obs_nuc] + else: + channels = sorted(set(nuclei)) + + header = _header_template.format( + channels=" ".join(channels), nuclei=" ".join(nuclei) + ) + + # Magnetic shielding Block + ms_block = "" + if iso_ms is not None: + num_atoms = len(atoms) + aniso_ms_vals = aniso_ms if aniso_ms is not None else np.zeros(num_atoms) + eta_ms_vals = eta_ms if eta_ms is not None else np.zeros(num_atoms) + euler_ms_vals = euler_ms if euler_ms is not None else np.zeros((num_atoms, 3)) + + for i in range(num_atoms): + ms_block += "shift {} {}p {}p {} {} {} {}\n".format( + i + 1, + iso_ms[i], + aniso_ms_vals[i], + eta_ms_vals[i], + *euler_ms_vals[i], + ) + + # Quadrupolar Block + efg_block = "" + if cq is not None: + num_atoms = len(atoms) + eta_q_vals = eta_q if eta_q is not None else np.zeros(num_atoms) + euler_q_vals = euler_q if euler_q is not None else np.zeros((num_atoms, 3)) + + for i in range(num_atoms): + if cq[i] != 0: + if q_order is not None: + if q_order[i] > 2: + raise ValueError( + f"Quadrupolar order must be 2 or less, got {q_order[i]} for atom {i+1}" + ) + efg_block += "quadrupole {} {} {} {} {} {} {}\n".format( + i + 1, q_order[i], cq[i], eta_q_vals[i], *euler_q_vals[i] + ) + else: + efg_block += "quadrupole {} 2 {} {} {} {} {}\n".format( + i + 1, cq[i], eta_q_vals[i], *euler_q_vals[i] + ) + + # Dipolar Block + dip_block = "" + if get_dipolar: + if dip_sel is None: + dip_sel = AtomSelection.all(atoms) + + if len(dip_sel) > 1: + dip_couplings = DipolarCoupling.get( + atoms, sel_i=dip_sel, isotope_list=isotope_list + ) + for (i, j), (d, v) in dip_couplings.items(): + # Convert units + d_rad_s = d * 2 * np.pi + + if np.allclose(v, [0, 0, 1]): + beta, alpha = 0.0, 0.0 + elif np.allclose(v, [0, 0, -1]): + beta, alpha = 180.0, 0.0 + else: + beta = np.arccos(v[2]) * 180 / np.pi + alpha = np.arctan2(v[1], v[0]) * 180 / np.pi + + dip_block += f"dipole {i + 1} {j + 1} {d_rad_s} {beta} {alpha} 0.0\n" + + return _spinsys_template.format( + header=header, ms=ms_block, efg=efg_block, dipolar=dip_block + ) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..1d6defd --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,36 @@ +"""Shared pytest fixtures for the simpyson test suite.""" +from __future__ import annotations + +import subprocess +from pathlib import Path + +import pytest + + +def write_fake_spe(path: Path, npoints: int = 32, sw: float = 20000.0) -> None: + lines = ['SIMP', f'NP={npoints}', f'SW={sw}', 'TYPE=SPE', 'DATA'] + lines += [f'{float(i)} 0.0' for i in range(npoints)] + lines.append('END') + path.write_text('\n'.join(lines)) + + +@pytest.fixture +def fake_simpson(monkeypatch): + """Mock the SIMPSON executable. + + Intercepts ``subprocess.run`` so no real SIMPSON binary is needed. + Writes a minimal ``.spe`` file alongside the input and returns a dict + that the test can inspect: ``captured['input']`` holds the generated + ``.in`` text. + """ + captured = {} + + def fake_run(cmd, **kwargs): + infile = Path(cmd[1]) + captured['input'] = infile.read_text() + write_fake_spe(infile.with_suffix('.spe')) + return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='') + + monkeypatch.setattr('simpyson.calculator.shutil.which', lambda _: '/usr/bin/simpson') + monkeypatch.setattr('simpyson.calculator.subprocess.run', fake_run) + return captured diff --git a/tests/test_calculator_improvements.py b/tests/test_calculator_improvements.py new file mode 100644 index 0000000..9946e22 --- /dev/null +++ b/tests/test_calculator_improvements.py @@ -0,0 +1,102 @@ +from __future__ import annotations + +import pytest +from simpyson.calculator import SimpCalc, _extract_nucleus, _proton_freq_to_b0 +from simpyson.converter import ppm2hz +from simpyson.utils import get_larmor_freq + + +def test_validation_spinsys(): + """Test that spinsys cannot be None.""" + with pytest.raises(ValueError): + SimpCalc(spinsys=None) + + +def test_validation_pulse_sequence(): + """Test invalid pulse sequence types.""" + with pytest.raises(ValueError): + SimpCalc(spinsys="spinsys { channels 1H }", pulse_sequence=123) + + +def test_missing_parameters(): + """Test missing required parameters.""" + calc = SimpCalc(spinsys="spinsys { channels 1H }", pulse_sequence="pulse_90") + with pytest.raises(ValueError, match="Missing required parameters"): + calc.generate_par() + + +def test_dry_run(): + """Test dry_run option.""" + calc = SimpCalc( + spinsys="spinsys { channels 1H }", + pulse_sequence="pulse_90", + proton_frequency=400e6, + spin_rate=10000, + start_operator="I1z", + detect_operator="I1p", + np=1024, + sw=20000, + method="direct", + crystal_file="rep100", + gamma_angles=10, + verbose=0, + ) + # Should not raise FileNotFoundError even if simpson is missing + cmd = calc.run(dry_run=True) + assert isinstance(cmd, str) + assert "simpson" in cmd + + +# --------------------------------------------------------------------------- +# _proton_freq_to_b0 — unit strings and scientific notation +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + ('value', 'expected_mhz'), + [ + (400e6, 400.0), + ('400MHz', 400.0), + ('400 mhz', 400.0), + ('400000kHz', 400.0), + ('0.4GHz', 400.0), + ('400000000Hz', 400.0), + ('400', 400.0), + ('8e8', 800.0), + ('8E8', 800.0), + ('4.0e8Hz', 400.0), + ], +) +def test_proton_freq_to_b0(value, expected_mhz): + result = _proton_freq_to_b0(value) + assert result is not None + assert result.endswith('MHz') + assert float(result[:-3]) == pytest.approx(expected_mhz) + + +def test_proton_freq_to_b0_invalid(): + assert _proton_freq_to_b0('not a frequency') is None + assert _proton_freq_to_b0(None) is None + + +# --------------------------------------------------------------------------- +# _extract_nucleus — multiline spinsys must not eat adjacent lines +# --------------------------------------------------------------------------- + + +def test_extract_nucleus_single_channel(): + assert _extract_nucleus("channels 29Si\nnuclei 29Si\nshift 1 50p 0 0 0 0 0") == '29Si' + + +def test_extract_nucleus_multichannel_returns_first(): + assert _extract_nucleus("channels 1H 13C\nnuclei 1H 13C\n") == '1H' + + +def test_nucleus_from_detect_operator_does_not_eat_spinsys_lines(fake_simpson): + """With the old [\\w\\s]+ regex an out-of-range site index could pick up + the *following* spinsys line (e.g. 'shift') as the nucleus name.""" + from simpyson.calculator import simulate_spectrum + spinsys = "channels 1H\nnuclei 1H\nshift 1 5p 0 0 0 0 0" + result = simulate_spectrum(spinsys, proton_frequency=400e6, spin_rate=10000, + detect_operator='I2p') + assert result.nucleus == '1H' diff --git a/tests/test_converter.py b/tests/test_converter.py new file mode 100644 index 0000000..317f0ba --- /dev/null +++ b/tests/test_converter.py @@ -0,0 +1,62 @@ +"""Tests for simpyson.converter — hz2ppm, ppm2hz, Larmor frequency, read_vasp.""" +from __future__ import annotations +from pathlib import Path + +import numpy as np +import pytest + +from simpyson.converter import hz2ppm, ppm2hz, read_vasp +from simpyson.utils import get_larmor_freq + +OUTCAR = Path(__file__).parent.parent / 'examples' / 'write' / 'AlPO-14.OUTCAR' + + +def test_larmor_freq_signed_for_negative_gamma(): + """get_larmor_freq stays signed — it is a physical quantity.""" + assert get_larmor_freq('9.4T', '1H') > 0 + assert get_larmor_freq('9.4T', '29Si') < 0 + + +@pytest.mark.parametrize('nucleus', ['1H', '13C', '29Si', '15N']) +def test_hz2ppm_positive_hz_gives_positive_ppm(nucleus): + """Positive Hz must map to positive ppm regardless of the sign of gamma. + + SIMPSON places a +delta shift at +delta*|nu_L| Hz on its output axis + (verified empirically with 29Si at 400 MHz — see PR #24 review notes). + """ + assert hz2ppm(1000.0, '400MHz', nucleus) > 0 + assert ppm2hz(50.0, '400MHz', nucleus) > 0 + + +@pytest.mark.parametrize('nucleus', ['13C', '29Si']) +def test_hz_ppm_roundtrip(nucleus): + hz = np.array([-5000.0, 0.0, 5000.0]) + back = ppm2hz(hz2ppm(hz, '400MHz', nucleus), '400MHz', nucleus) + np.testing.assert_allclose(back, hz) + +# Test read_vasp and convertion to magres style +@pytest.mark.skipif( + not OUTCAR.exists(), + reason=f'OUTCAR not present at {OUTCAR}', +) +def test_read_vasp_alpo14_structure(): + """read_vasp returns an ASE Atoms object with 48 atoms (8Al + 32O + 8P).""" + atoms = read_vasp(str(OUTCAR), format='vasp-out') + syms = atoms.get_chemical_symbols() + assert len(atoms) == 48 + assert syms.count('Al') == 8 + assert syms.count('O') == 32 + assert syms.count('P') == 8 + + +@pytest.mark.skipif( + not OUTCAR.exists(), + reason=f'OUTCAR not present at {OUTCAR}', +) +def test_read_vasp_alpo14_tensor_shapes(): + """ms and efg arrays have shape (n_atoms, 3, 3).""" + atoms = read_vasp(str(OUTCAR), format='vasp-out') + ms = atoms.get_array('ms') + efg = atoms.get_array('efg') + assert ms.shape == (48, 3, 3) + assert efg.shape == (48, 3, 3) diff --git a/tests/test_custom_pulse.py b/tests/test_custom_pulse.py new file mode 100644 index 0000000..60b8dfd --- /dev/null +++ b/tests/test_custom_pulse.py @@ -0,0 +1,104 @@ +from __future__ import annotations + +import re + +from simpyson.calculator import SimpCalc +from simpyson.templates import Pulse90 + + +def test_custom_pulse_sequence_params(): + """Test that custom pulse sequence receives parameters from SimpCalc.""" + code = """ + pulse $par(my_param) 0 0 0 0 + """ + + calc = SimpCalc( + spinsys="spinsys { channels 1H }", + pulse_sequence=code, + proton_frequency=400e6, + spin_rate=10000, + start_operator="I1z", + detect_operator="I1p", + np=1024, + sw=20000, + method="direct", + crystal_file="rep100", + gamma_angles=10, + verbose=0, + my_param=10.0, # This must pass to CustomPulseSequence + unused_param=20.0, # This should not + ) + + assert 'variable_my_param' in calc.pulse_sequence.parameters + assert calc.pulse_sequence.parameters['variable_my_param'] == 10.0 + assert 'variable_unused_param' not in calc.pulse_sequence.parameters + + # Verify generation + par_block = calc.generate_par() + assert re.search(r"variable\s+my_param\s+10\.0", par_block) + + +def test_standard_params_in_custom_code(): + """Test using standard parameters in custom code.""" + code = """ + delay $par(np) + """ + + calc = SimpCalc( + spinsys="spinsys { channels 1H }", + pulse_sequence=code, + proton_frequency=400e6, + spin_rate=10000, + start_operator="I1z", + detect_operator="I1p", + np=1024, + sw=20000, + method="direct", + crystal_file="rep100", + gamma_angles=10, + verbose=0, + ) + + # np is required by code + assert 'variable_np' in calc.pulse_sequence.parameters + + # It should appear in par block as a standard parameter + par_block = calc.generate_par() + assert "np 1024" in par_block + + # It should not appear as "variable np" + assert "variable np" not in par_block + + +# --------------------------------------------------------------------------- +# Pulse90 — multi-channel padding +# --------------------------------------------------------------------------- + + +def test_pulse90_single_channel_unpadded(): + """Single-channel Pulse90 must emit exactly one (rf, phase) pair.""" + code = Pulse90().generate_code() + assert 'pulse $par(pH) $par(plH) $par(phH)\n' in code + + +def test_pulse90_two_channels_padded(): + """Two-channel Pulse90 must pad the second channel with 0 0.""" + code = Pulse90(num_channels=2).generate_code() + assert 'pulse $par(pH) $par(plH) $par(phH) 0 0\n' in code + + +def test_pulse90_three_channels_padded(): + code = Pulse90(num_channels=3).generate_code() + assert 'pulse $par(pH) $par(plH) $par(phH) 0 0 0 0\n' in code + + +def test_pulse90_multichannel_via_simpcalc(): + """SimpCalc must pass num_channels to Pulse90 automatically.""" + calc = SimpCalc( + spinsys="channels 1H 13C\nnuclei 1H 13C\nshift 1 5p 0 0 0 0 0\nshift 2 50p 0 0 0 0 0", + pulse_sequence='pulse_90', + proton_frequency=400e6, spin_rate=10000, sw=20000, np=1024, + start_operator='I1x', detect_operator='I2p', method='direct', + crystal_file='rep100', gamma_angles=10, verbose=0, + ) + assert 'pulse $par(pH) $par(plH) $par(phH) 0 0' in str(calc) diff --git a/tests/test_io.py b/tests/test_io.py new file mode 100644 index 0000000..913cd3e --- /dev/null +++ b/tests/test_io.py @@ -0,0 +1,145 @@ +"""Tests for simpyson.io — reading and writing SIMPSON files.""" +from __future__ import annotations + +import os + +import numpy as np +import pytest + +from simpyson.io import read_fid, read_simp, read_spe, read_xreim +from simpyson.simpy import Simpy + +EXAMPLES_DIR = os.path.join(os.path.dirname(__file__), '..', 'examples', 'read') + + +# --------------------------------------------------------------------------- +# read_simp (format dispatch) +# --------------------------------------------------------------------------- + +class TestReadSimp: + def test_read_spe_file(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.spe') + data = read_simp(path) + assert data.spe is not None + assert data.spe['np'] == 4096 + assert data.spe['sw'] == 10000 + + def test_read_fid_file(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.fid') + data = read_simp(path) + assert data.fid is not None + assert data.fid['np'] == 4096 + assert data.fid['sw'] == 10000 + + def test_read_spe_with_b0_nucleus(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.spe') + data = read_simp(path, b0="400MHz", nucleus="1H") + assert data.b0 == "400MHz" + assert data.nucleus == "1H" + assert data.ppm is not None + + def test_unknown_extension_raises(self, tmp_path): + dummy = tmp_path / "test.xyz" + dummy.write_text("dummy") + with pytest.raises(ValueError, match="Cannot determine file format"): + read_simp(str(dummy)) + + def test_missing_file_raises(self): + with pytest.raises((OSError, FileNotFoundError)): + read_simp("nonexistent_file.spe") + + +# --------------------------------------------------------------------------- +# read_spe +# --------------------------------------------------------------------------- + +class TestReadSpe: + def test_basic_read(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.spe') + data = Simpy() + read_spe(path, data) + assert data.spe is not None + assert len(data.spe['real']) == 4096 + assert data.spe['sw'] == 10000 + + def test_hz_axis_centered(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.spe') + data = Simpy() + read_spe(path, data) + hz = data.spe['hz'] + # Hz axis should be roughly centered around zero (no REF in this file) + assert hz[0] < 0 + assert hz[-1] > 0 + + def test_missing_header_raises(self, tmp_path): + # File with DATA but missing NP/SW + bad_file = tmp_path / "bad.spe" + bad_file.write_text("SIMP\nDATA\n1.0 2.0\nEND") + data = Simpy() + with pytest.raises(ValueError, match="Missing required header"): + read_spe(str(bad_file), data) + + +# --------------------------------------------------------------------------- +# read_fid +# --------------------------------------------------------------------------- + +class TestReadFid: + def test_basic_read(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.fid') + data = Simpy() + read_fid(path, data) + assert data.fid is not None + assert len(data.fid['real']) == 4096 + + def test_time_axis_starts_at_zero(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.fid') + data = Simpy() + read_fid(path, data) + assert data.fid['time'][0] == pytest.approx(0.0) + + def test_time_axis_is_ms(self): + path = os.path.join(EXAMPLES_DIR, 'ethanol.fid') + data = Simpy() + read_fid(path, data) + fid = data.fid + expected_max_ms = (fid['np'] - 1) / fid['sw'] * 1e3 + assert fid['time'][-1] == pytest.approx(expected_max_ms, rel=0.01) + + +# --------------------------------------------------------------------------- +# Write round-trip +# --------------------------------------------------------------------------- + +class TestWriteRoundTrip: + def test_spe_roundtrip(self, tmp_path): + """Write a .spe and read it back — data should match.""" + original = Simpy() + npoints = 32 + sw = 5000.0 + real = np.random.default_rng(1).standard_normal(npoints) + imag = np.random.default_rng(2).standard_normal(npoints) + original.from_spe(real, imag, npoints, sw) + + outfile = str(tmp_path / "roundtrip.spe") + original.write(outfile, format='spe') + + loaded = read_simp(outfile) + np.testing.assert_allclose(loaded.spe['real'], real, atol=1e-6) + np.testing.assert_allclose(loaded.spe['imag'], imag, atol=1e-6) + + def test_fid_roundtrip(self, tmp_path): + """Write a .fid and read it back — data should match.""" + original = Simpy() + npoints = 32 + sw = 5000.0 + real = np.random.default_rng(3).standard_normal(npoints) + imag = np.random.default_rng(4).standard_normal(npoints) + original.from_fid(real, imag, npoints, sw) + + outfile = str(tmp_path / "roundtrip.fid") + original.write(outfile, format='fid') + + loaded = read_simp(outfile) + np.testing.assert_allclose(loaded.fid['real'], real, atol=1e-6) + np.testing.assert_allclose(loaded.fid['imag'], imag, atol=1e-6) diff --git a/tests/test_quadrupolar.py b/tests/test_quadrupolar.py new file mode 100644 index 0000000..eb916f7 --- /dev/null +++ b/tests/test_quadrupolar.py @@ -0,0 +1,60 @@ +from __future__ import annotations + +from simpyson.calculator import SimpCalc, simulate_spectrum +from simpyson.utils import get_spin + + +def test_get_spin(): + """Test get_spin function for various nuclei.""" + assert get_spin('1H') == 0.5 + assert get_spin('13C') == 0.5 + assert get_spin('23Na') == 1.5 # 3/2 + assert get_spin('27Al') == 2.5 # 5/2 + assert get_spin('14N') == 1.0 + + +def test_simulate_spectrum_quadrupolar(): + """Test that simulate_spectrum sets Inc for quadrupolar nuclei.""" + spinsys_23na = """ + channels 23Na + nuclei 23Na + shift 1 0 0 0 0 0 0 + """ + + original_SimpCalc = SimpCalc + captured_params = {} + + class MockSimpCalc: + def __init__(self, spinsys, **kwargs): + captured_params.update(kwargs) + self.spinsys = spinsys + self.parameters = kwargs + + def run(self, **kwargs): + return "Mock Result" + + import simpyson.calculator + simpyson.calculator.SimpCalc = MockSimpCalc + + try: + # Quadrupolar nucleus should get Inc + simulate_spectrum(spinsys_23na) + assert captured_params.get('detect_operator') == 'Inc' + + # Explicit override should be respected + captured_params.clear() + simulate_spectrum(spinsys_23na, detect_operator='Inp') + assert captured_params.get('detect_operator') == 'Inp' + + # Spin-1/2 nucleus should keep Inp + captured_params.clear() + spinsys_1h = """ + channels 1H + nuclei 1H + shift 1 0 0 0 0 0 0 + """ + simulate_spectrum(spinsys_1h) + assert captured_params.get('detect_operator') == 'Inp' + + finally: + simpyson.calculator.SimpCalc = original_SimpCalc diff --git a/tests/test_run_readback.py b/tests/test_run_readback.py new file mode 100755 index 0000000..65fe6e1 --- /dev/null +++ b/tests/test_run_readback.py @@ -0,0 +1,179 @@ +"""Regression tests for SimpCalc.run()'s output-reading path and file round-trips. + +These tests mock the SIMPSON executable so the seam between ``calculator`` +and ``io`` (where a ``read_simp()`` keyword mismatch previously crashed every +successful run) is exercised in CI without SIMPSON installed. +""" +from __future__ import annotations + +import subprocess +from pathlib import Path + +import numpy as np +import pytest +from simpyson.calculator import SimpCalc, _proton_freq_to_b0 +from simpyson.io import read_simp +from simpyson.simpy import Simpy + +SPINSYS_1H = """ +channels 1H +nuclei 1H +shift 1 5p 0 0 0 0 0 +""" + + +def _make_calc(**overrides): + params = dict( + spinsys=SPINSYS_1H, + pulse_sequence='no_pulse', + proton_frequency=400e6, + spin_rate=10000, + start_operator='Inx', + detect_operator='Inp', + np=8, + sw=20000, + method='direct', + crystal_file='rep100', + gamma_angles=10, + verbose=0, + ) + params.update(overrides) + return SimpCalc(**params) + + +def _write_fake_spe(path: Path, npoints: int = 8, sw: float = 20000.0) -> None: + lines = ['SIMP', f'NP={npoints}', f'SW={sw}', 'TYPE=SPE', 'DATA'] + lines += [f'{float(i)} {0.0}' for i in range(npoints)] + lines.append('END') + path.write_text('\n'.join(lines)) + + +def test_run_reads_output(tmp_path, monkeypatch): + """run(read_output=True) must return a Simpy object (regression for + the read_simp(format=...) keyword crash).""" + infile = tmp_path / 'sim.in' + + def fake_run(cmd, **kwargs): + # Simulate SIMPSON writing its output next to the input file + _write_fake_spe(Path(cmd[1]).with_suffix('.spe')) + return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='') + + monkeypatch.setattr('simpyson.calculator.shutil.which', lambda _: '/usr/bin/simpson') + monkeypatch.setattr('simpyson.calculator.subprocess.run', fake_run) + + calc = _make_calc() + result = calc.run(filepath=str(infile), read_output=True, delete_files=True) + + assert isinstance(result, Simpy) + assert result.spe is not None + assert int(result.spe['np']) == 8 + # b0/nucleus auto-derived, so ppm conversion must be available + assert result.ppm is not None + # Cleanup must have removed input and output files + assert not infile.exists() + assert not infile.with_suffix('.spe').exists() + + +def test_run_cleanup_keeps_preexisting_files(tmp_path, monkeypatch): + """delete_files=True must not delete a pre-existing file in cwd that + happens to share the output file's name.""" + infile = tmp_path / 'sim.in' + bystander = Path.cwd() / 'sim.spe' + bystander.write_text('precious user data') + + def fake_run(cmd, **kwargs): + _write_fake_spe(Path(cmd[1]).with_suffix('.spe')) + return subprocess.CompletedProcess(cmd, 0, stdout='', stderr='') + + monkeypatch.setattr('simpyson.calculator.shutil.which', lambda _: '/usr/bin/simpson') + monkeypatch.setattr('simpyson.calculator.subprocess.run', fake_run) + + try: + calc = _make_calc() + calc.run(filepath=str(infile), read_output=True, delete_files=True) + assert bystander.exists() + assert bystander.read_text() == 'precious user data' + finally: + bystander.unlink(missing_ok=True) + + +def test_xreim_write_read_roundtrip(tmp_path): + """xreim files must round-trip through write() and read_simp().""" + time = np.array([0.0, 1.0, 2.0]) + real = np.array([1.0, 2.0, 3.0]) + imag = np.array([0.1, 0.2, 0.3]) + + outfile = tmp_path / 'test.xreim' + Simpy().from_xreim(time, real, imag).write(str(outfile), format='xreim') + + loaded = read_simp(str(outfile)) + assert loaded.xreim is not None + np.testing.assert_allclose(loaded.xreim['time'], time) + np.testing.assert_allclose(loaded.xreim['real'], real) + np.testing.assert_allclose(loaded.xreim['imag'], imag) + + +def test_spe_write_preserves_shifted_axis(tmp_path): + """A non-symmetric Hz axis (e.g. after add_spectra interpolation) must + survive a write/read round-trip via the REF header.""" + npoints = 16 + sw = 8000.0 + hz = sw * (np.arange(npoints) / npoints - 0.5) + 1234.5 # shifted axis + real = np.random.default_rng(0).normal(size=npoints) + imag = np.zeros(npoints) + + outfile = tmp_path / 'shifted.spe' + Simpy().from_spe(real, imag, npoints, sw, hz).write(str(outfile), format='spe') + + header = outfile.read_text().splitlines() + assert any(line.startswith('NP=16') for line in header) # integer NP + + loaded = read_simp(str(outfile)) + np.testing.assert_allclose(loaded.spe['hz'], hz) + np.testing.assert_allclose(loaded.spe['real'], real) + + +def test_csdf_write_read_roundtrip(tmp_path): + """csdf files must round-trip through write() and read_simp().""" + pytest.importorskip('csdmpy') + + npoints = 16 + sw = 8000.0 + hz = sw * (np.arange(npoints) / npoints - 0.5) + real = np.random.default_rng(1).normal(size=npoints) + imag = np.random.default_rng(2).normal(size=npoints) + + outfile = tmp_path / 'test.csdf' + Simpy().from_spe(real, imag, npoints, sw, hz).write(str(outfile), format='csdf') + + loaded = read_simp(str(outfile)) + assert loaded.spe is not None + np.testing.assert_allclose(loaded.spe['hz'], hz) + np.testing.assert_allclose(loaded.spe['real'], real) + np.testing.assert_allclose(loaded.spe['imag'], imag) + np.testing.assert_allclose(loaded.spe['sw'], sw) + + +@pytest.mark.parametrize( + ("value", "expected"), + [ + (400e6, '400.0MHz'), + ('400MHz', '400.0MHz'), + ('400 mhz', '400.0MHz'), + ('400000kHz', '400.0MHz'), + ('0.4GHz', '400.0MHz'), + ('400000000Hz', '400.0MHz'), + ('400', '400.0MHz'), + ], +) +def test_proton_freq_to_b0_units(value, expected): + """All Hz-based unit strings must be normalised to MHz.""" + result = _proton_freq_to_b0(value) + assert result is not None + assert float(result.replace('MHz', '')) == pytest.approx(float(expected.replace('MHz', ''))) + assert result.endswith('MHz') + + +def test_proton_freq_to_b0_invalid(): + assert _proton_freq_to_b0('not a frequency') is None + assert _proton_freq_to_b0(None) is None diff --git a/tests/test_simpson_e2e.py b/tests/test_simpson_e2e.py new file mode 100644 index 0000000..45467a7 --- /dev/null +++ b/tests/test_simpson_e2e.py @@ -0,0 +1,111 @@ +"""End-to-end tests against a real SIMPSON installation. + +Skipped automatically when the ``simpson`` executable is not on PATH, so +they are CI-safe but exercise the full generate -> run -> read pipeline on +developer machines. The expected values were established empirically (see +the PR #24 review): SIMPSON places +delta at +delta*|nu_L| regardless of +the sign of gamma, and the carrier offset follows the sign of gamma. +""" +from __future__ import annotations + +import shutil + +import numpy as np +import pytest +from simpyson import simulate_spectrum +from simpyson.utils import get_larmor_freq + +requires_simpson = pytest.mark.skipif( + shutil.which('simpson') is None, + reason='SIMPSON executable not found in PATH', +) + + +def _peak_ppm(result) -> float: + ppm = result.ppm + assert ppm is not None + return float(ppm['ppm'][np.argmax(ppm['real'])]) + + +@requires_simpson +def test_t1_smoke_13c_single_peak(): + """A single 13C 50p site must read back at 50 ppm.""" + spinsys = """ +channels 13C +nuclei 13C +shift 1 50p 0 0 0 0 0 +""" + result = simulate_spectrum(spinsys, proton_frequency=400e6, spin_rate=10000) + assert _peak_ppm(result) == pytest.approx(50.0, abs=0.5) + + +@requires_simpson +@pytest.mark.parametrize('nucleus', ['13C', '29Si']) +def test_t2_axis_convention_both_gamma_signs(nucleus): + """+50p/-100p must read back at +50/-100 ppm for both gamma signs.""" + spinsys = f""" +channels {nucleus} +nuclei {nucleus} {nucleus} +shift 1 50p 0 0 0 0 0 +shift 2 -100p 0 0 0 0 0 +""" + result = simulate_spectrum(spinsys, proton_frequency=400e6, spin_rate=10000) + ppm_axis = result.ppm['ppm'] + real = result.ppm['real'] + + # Find the two largest peaks + order = np.argsort(real)[::-1] + found = [] + for idx in order: + p = ppm_axis[idx] + if all(abs(p - f) > 5.0 for f in found): + found.append(float(p)) + if len(found) == 2: + break + + assert sorted(found) == pytest.approx([-100.0, 50.0], abs=0.5) + + +@requires_simpson +def test_t3_17o_ct_width_no_wraparound(): + """17O CT MAS: sw must cover the second-order pattern; the peak must not + sit at the spectrum edge (which would indicate wrap-around).""" + cq = 3.0e6 + spinsys = f""" +channels 17O +nuclei 17O +shift 1 100p 0 0 0 0 0 +quadrupole 1 2 {cq} 0.5 0 0 0 +""" + result = simulate_spectrum(spinsys, proton_frequency=800e6, spin_rate=30000) + spe = result.spe + nu_l_hz = abs(get_larmor_freq('800.0MHz', '17O')) * 1e6 + assert spe['sw'] >= cq**2 / nu_l_hz + + # Peak must be inside the central 80% of the window + peak_idx = int(np.argmax(spe['real'])) + n = int(spe['np']) + assert 0.1 * n < peak_idx < 0.9 * n + + +@requires_simpson +def test_t6_33s_second_order_shift_field_scaling(): + """The CT displacement below delta_iso must scale as 1/nu_L^2: the + displacement ratio between 400 and 800 MHz is (800/400)^2 = 4.""" + delta_iso = 335.7 + spinsys = f""" +channels 33S +nuclei 33S +shift 1 {delta_iso}p 0 0 0 0 0 +quadrupole 1 2 0.959e6 1.0 0 0 0 +""" + displacements = {} + for freq in (400e6, 800e6): + result = simulate_spectrum(spinsys, proton_frequency=freq, spin_rate=20000) + displacements[freq] = _peak_ppm(result) - delta_iso + + # Second-order shift is negative (peak below delta_iso) at both fields + assert displacements[400e6] < 0 + assert displacements[800e6] < 0 + ratio = displacements[400e6] / displacements[800e6] + assert ratio == pytest.approx(4.0, rel=0.25) diff --git a/tests/test_simpy.py b/tests/test_simpy.py new file mode 100644 index 0000000..bf545d8 --- /dev/null +++ b/tests/test_simpy.py @@ -0,0 +1,232 @@ +"""Tests for simpyson.simpy — the Simpy data container.""" +from __future__ import annotations + +import numpy as np +import pytest + +from simpyson.simpy import Simpy + + +# --------------------------------------------------------------------------- +# Construction and basic properties +# --------------------------------------------------------------------------- + +def test_empty_simpy(): + s = Simpy() + assert s.b0 is None + assert s.nucleus is None + assert s.fid is None + assert s.spe is None + assert s.ppm is None + assert s.xreim is None + + +def test_b0_and_nucleus(): + s = Simpy(b0="400MHz", nucleus="13C") + assert s.b0 == "400MHz" + assert s.nucleus == "13C" + + +# --------------------------------------------------------------------------- +# from_spe / from_fid / from_xreim round-trips +# --------------------------------------------------------------------------- + +@pytest.fixture +def simple_spectrum(): + """A Simpy with synthetic spectrum data.""" + s = Simpy() + npoints = 64 + sw = 10000.0 + hz = np.linspace(-sw / 2, sw / 2, npoints) + real = np.sin(hz / 100) + imag = np.cos(hz / 100) + s.from_spe(real, imag, npoints, sw, hz) + return s + + +@pytest.fixture +def simple_fid(): + """A Simpy with synthetic FID data.""" + s = Simpy() + npoints = 64 + sw = 10000.0 + real = np.random.default_rng(42).standard_normal(npoints) + imag = np.random.default_rng(43).standard_normal(npoints) + s.from_fid(real, imag, npoints, sw) + return s + + +def test_from_spe_stores_data(simple_spectrum): + spe = simple_spectrum.spe + assert spe is not None + assert len(spe['real']) == 64 + assert spe['sw'] == 10000.0 + assert 'hz' in spe + + +def test_from_fid_stores_data(simple_fid): + fid = simple_fid.fid + assert fid is not None + assert len(fid['real']) == 64 + assert fid['sw'] == 10000.0 + assert 'time' in fid + + +def test_from_fid_time_axis_is_ms(simple_fid): + """Time axis should be in milliseconds (seconds * 1e3).""" + fid = simple_fid.fid + npoints = fid['np'] + sw = fid['sw'] + dt = 1.0 / sw + expected_max_ms = (npoints - 1) * dt * 1e3 + assert fid['time'][-1] == pytest.approx(expected_max_ms, rel=0.01) + + +def test_from_fid_default_time_matches_explicit(): + """Passing time=None should give the same result as computing manually.""" + npoints = 128 + sw = 20000.0 + real = np.ones(npoints) + imag = np.zeros(npoints) + + s1 = Simpy() + s1.from_fid(real, imag, npoints, sw) # time computed internally + + dt = 1.0 / sw + time_manual = np.arange(npoints) * dt * 1e3 + s2 = Simpy() + s2.from_fid(real, imag, npoints, sw, time=time_manual) + + np.testing.assert_allclose(s1.fid['time'], s2.fid['time']) + + +def test_from_xreim(): + s = Simpy() + time = np.linspace(0, 1, 32) + real = np.sin(time) + imag = np.cos(time) + s.from_xreim(time, real, imag) + assert s.xreim is not None + assert len(s.xreim['time']) == 32 + + +# --------------------------------------------------------------------------- +# Lazy conversions (FID <-> spectrum) +# --------------------------------------------------------------------------- + +def test_fid_to_spe_conversion(simple_fid): + """Accessing .spe on FID-only data should trigger FFT.""" + spe = simple_fid.spe + assert spe is not None + assert 'hz' in spe + assert len(spe['real']) == 64 + + +def test_spe_to_fid_conversion(simple_spectrum): + """Accessing .fid on spectrum-only data should trigger iFFT.""" + fid = simple_spectrum.fid + assert fid is not None + assert 'time' in fid + assert len(fid['real']) == 64 + + +def test_fid_spe_roundtrip(simple_fid): + """FID -> SPE -> FID should approximately recover the original.""" + original_real = simple_fid.fid['real'].copy() + spe = simple_fid.spe # triggers FFT + # Access FID through a fresh conversion + s2 = Simpy() + s2.from_spe(spe['real'], spe['imag'], spe['np'], spe['sw'], spe['hz']) + recovered = s2.fid + np.testing.assert_allclose(recovered['real'], original_real, atol=1e-10) + + +# --------------------------------------------------------------------------- +# PPM conversion +# --------------------------------------------------------------------------- + +def test_ppm_requires_b0_and_nucleus(simple_spectrum): + """ppm should be None when b0/nucleus are not set.""" + assert simple_spectrum.ppm is None + + +def test_ppm_computed_when_b0_nucleus_set(): + s = Simpy(b0="400MHz", nucleus="1H") + npoints = 32 + sw = 5000.0 + hz = np.linspace(-sw / 2, sw / 2, npoints) + s.from_spe(np.ones(npoints), np.zeros(npoints), npoints, sw, hz) + ppm = s.ppm + assert ppm is not None + assert 'ppm' in ppm + assert len(ppm['ppm']) == npoints + + +def test_ppm_invalidated_on_b0_change(): + s = Simpy(b0="400MHz", nucleus="1H") + s.from_spe(np.ones(8), np.zeros(8), 8, 1000.0) + _ = s.ppm # trigger ppm calculation + assert 'ppm' in s.spe + s.b0 = "800MHz" + assert 'ppm' not in s.spe # should be invalidated + + +# --------------------------------------------------------------------------- +# Copy +# --------------------------------------------------------------------------- + +def test_copy_is_independent(simple_spectrum): + clone = simple_spectrum.copy() + assert clone.spe is not None + # Mutating clone should not affect original + clone.spe['real'][0] = 999999 + assert simple_spectrum.spe['real'][0] != 999999 + + +# --------------------------------------------------------------------------- +# Write (SIMPSON format) +# --------------------------------------------------------------------------- + +def test_write_spe(simple_spectrum, tmp_path): + outfile = str(tmp_path / "test.spe") + simple_spectrum.write(outfile, format='spe') + with open(outfile) as f: + content = f.read() + assert content.startswith('SIMP') + assert 'NP=64' in content + assert 'SW=10000' in content + assert 'TYPE=SPE' in content + assert 'DATA' in content + assert 'END' in content + + +def test_write_csv(simple_spectrum, tmp_path): + outfile = str(tmp_path / "test.csv") + simple_spectrum.write(outfile, format='csv') + data = np.loadtxt(outfile, delimiter=',', skiprows=1) + assert data.shape == (64, 2) + + +def test_write_unsupported_format(simple_spectrum, tmp_path): + with pytest.raises(ValueError, match="Unsupported save format"): + simple_spectrum.write(str(tmp_path / "test.xyz"), format='xyz') + + +def test_write_no_data(tmp_path): + s = Simpy() + with pytest.raises(ValueError, match="No data"): + s.write(str(tmp_path / "test.csv"), format='csv') + + +# --------------------------------------------------------------------------- +# Method chaining +# --------------------------------------------------------------------------- + +def test_method_chaining(): + s = Simpy() + result = s.from_spe([1, 2], [0, 0], 2, 100.0) + assert result is s + result2 = s.write.__wrapped__(s, "dummy") if hasattr(s.write, '__wrapped__') else None + # Just verify from_fid also chains + s2 = Simpy() + assert s2.from_fid([1, 2], [0, 0], 2, 100.0) is s2 diff --git a/tests/test_simulate_spectrum.py b/tests/test_simulate_spectrum.py new file mode 100644 index 0000000..9a29c1c --- /dev/null +++ b/tests/test_simulate_spectrum.py @@ -0,0 +1,292 @@ +from __future__ import annotations + +import math +import re + +import pytest +from simpyson.calculator import SimpCalc, simulate_spectrum +from simpyson.converter import ppm2hz +from simpyson.utils import get_larmor_freq + + +def _par_value(text: str, name: str) -> float: + m = re.search(rf'^\s*{name}\s+(\S+)', text, re.MULTILINE) + assert m, f"par entry {name!r} not found in generated input" + return float(m.group(1)) + + +def _par_variable(text: str, name: str) -> float: + m = re.search(rf'^\s*variable\s+{name}\s+(\S+)', text, re.MULTILINE) + assert m, f"par variable {name!r} not found in generated input" + return float(m.group(1)) + + +SPINSYS_1H = """ +channels 1H +nuclei 1H 1H +shift 1 5p 0 0 0 0 0 +shift 2 10p 0 0 0 0 0 +""" + + +def test_simulate_spectrum_defaults(): + """Test simulate_spectrum with minimal arguments does not raise.""" + # Should generate the input file without error even if SIMPSON is not installed + calc = SimpCalc( + spinsys=SPINSYS_1H, + pulse_sequence='no_pulse', + proton_frequency=800e6, + spin_rate=30e3, + start_operator='Inx', + detect_operator='Inp', + crystal_file='rep168', + gamma_angles=8, + np=4096, + sw=30e3, + method='direct', + verbose=0, + ) + output = str(calc) + assert "spinsys" in output + assert "proc pulseq" in output + assert "proc main" in output + + +def test_parameter_calculation(): + """Test that SW, offset, and ref are placed in the correct blocks.""" + b0 = '800.0MHz' + nucleus = '1H' + center_ppm = 7.5 + center_hz = ppm2hz(center_ppm, b0, nucleus) + + calc = SimpCalc( + spinsys=SPINSYS_1H, + proton_frequency=800e6, + sw=30e3, + variable_offset=center_hz, + variable_ref=center_hz, + pulse_sequence='no_pulse', + spin_rate=30e3, + start_operator='Inx', + detect_operator='Inp', + crystal_file='rep168', + gamma_angles=8, + np=4096, + method='direct', + verbose=0, + ) + + # ref should appear as a variable in the par block + par_block = calc.generate_par() + assert "variable ref" in par_block + assert str(center_hz) in par_block + + # offset should appear as a variable in the par block + assert "variable offset" in par_block + + # main block should reference $par(ref) + main_block = calc.generate_main() + assert "fset $f -ref $par(ref)" in main_block + + # pulseq block should reference $par(offset) + pulseq_block = calc.generate_pulseq() + assert "offset $par(offset)" in pulseq_block + + +# 27Al quadrupolar-only spin system (no shift line) +SPINSYS_27AL_QUAD_ONLY = """ +channels 27Al +nuclei 27Al +quadrupole 1 2 -4391507.0 0.13 118.0 107.0 -62.0 +""" + + +def test_simulate_spectrum_quadrupolar_only_mas(): + """quadrupolar-only spinsys: sw estimated from Cq²/ν_L, detect_operator set to Inc.""" + b0 = '800.0MHz' + nucleus = '27Al' + spin_rate = 40000.0 + nu_l_hz = get_larmor_freq(b0, nucleus) * 1e6 + cq = 4391507.0 + expected_required_sw = cq ** 2 / nu_l_hz + expected_n = max(1, math.ceil(expected_required_sw / spin_rate)) + expected_sw = expected_n * spin_rate + + calc = SimpCalc( + spinsys=SPINSYS_27AL_QUAD_ONLY, + pulse_sequence='no_pulse', + proton_frequency=800e6, + spin_rate=spin_rate, + start_operator='Inx', + detect_operator='Inc', + crystal_file='rep168', + gamma_angles=6, + np=2048, + sw=expected_sw, + method='direct', + verbose=0, + ) + par_block = calc.generate_par() + assert f"sw {expected_sw}" in par_block or str(expected_sw) in par_block + assert "Inc" in str(calc) + + +def test_simulate_spectrum_quadrupolar_only_sw_auto(): + """simulate_spectrum auto-estimates sw from Cq and sets detect_operator=Inc.""" + b0 = '800.0MHz' + nucleus = '27Al' + spin_rate = 40000.0 + nu_l_hz = get_larmor_freq(b0, nucleus) * 1e6 + cq = 4391507.0 + expected_required_sw = cq ** 2 / nu_l_hz + expected_n = max(1, math.ceil(expected_required_sw / spin_rate)) + expected_sw = expected_n * spin_rate + + # Use SimpCalc directly to mimic what simulate_spectrum does internally + calc = SimpCalc( + spinsys=SPINSYS_27AL_QUAD_ONLY, + pulse_sequence='no_pulse', + proton_frequency=800e6, + spin_rate=spin_rate, + start_operator='Inx', + detect_operator='Inc', + crystal_file='rep168', + gamma_angles=6, + np=2048, + sw=expected_sw, + method='direct', + verbose=0, + ) + in_file = str(calc) + assert "Inc" in in_file + assert str(expected_sw) in in_file + + +def test_simulate_spectrum_no_interactions_raises(): + """spinsys with no shift or quadrupole raises ValueError when sw is not given.""" + spinsys = "channels 1H\nnuclei 1H\n" + with pytest.raises(ValueError, match="Cannot auto-estimate"): + # Pass sw=None is not how you'd do it; instead don't pass sw at all. + # We call simulate_spectrum but it will fail before running SIMPSON. + simulate_spectrum(spinsys) + + +def test_simulate_spectrum_static_no_infinite_loop(): + """spin_rate=0 with shift-based SW must not loop forever (regression).""" + spinsys = """ +channels 27Al +nuclei 27Al +shift 1 10p 5p 0.3 0 0 0 +quadrupole 1 2 -4391507.0 0.13 118.0 107.0 -62.0 +""" + # Should complete immediately (not loop) and produce a SimpCalc with sw set + calc = SimpCalc( + spinsys=spinsys, + pulse_sequence='no_pulse', + proton_frequency=800e6, + spin_rate=0, + start_operator='Inx', + detect_operator='Inc', + crystal_file='zcw986', + gamma_angles=1, + np=2048, + sw=50000.0, + method='direct', + verbose=0, + ) + par_block = calc.generate_par() + assert "spin_rate" in par_block + assert "sw" in par_block + + +# --------------------------------------------------------------------------- +# Offset/ref sign convention for negative-gamma nuclei +# --------------------------------------------------------------------------- + +SPINSYS_13C_SHIFTS = """ +channels 13C +nuclei 13C 13C +shift 1 10p 0 0 0 0 0 +shift 2 50p 0 0 0 0 0 +""" + +SPINSYS_29SI_SHIFTS = """ +channels 29Si +nuclei 29Si 29Si +shift 1 50p 0 0 0 0 0 +shift 2 -100p 0 0 0 0 0 +""" + + +def test_offset_ref_signs_positive_gamma(fake_simpson): + """Positive-gamma: offset == +center_hz, ref == -center_hz.""" + simulate_spectrum(SPINSYS_13C_SHIFTS, proton_frequency=400e6, spin_rate=10000) + text = fake_simpson['input'] + center_hz = ppm2hz(30.0, '400.0MHz', '13C') # (10+50)/2 + assert _par_variable(text, 'offset') == pytest.approx(center_hz) + assert _par_variable(text, 'ref') == pytest.approx(-center_hz) + + +def test_offset_ref_signs_negative_gamma(fake_simpson): + """Negative-gamma: offset follows sign(gamma), ref always -center_hz. + + SIMPSON applies the carrier offset with the sign of gamma (rotating-frame + convention), so for 29Si the offset must be flipped relative to 13C. + Verified empirically — see PR #24 review notes. + """ + simulate_spectrum(SPINSYS_29SI_SHIFTS, proton_frequency=400e6, spin_rate=10000) + text = fake_simpson['input'] + center_hz = ppm2hz(-25.0, '400.0MHz', '29Si') # (50-100)/2, negative + assert center_hz < 0 + assert _par_variable(text, 'offset') == pytest.approx(-center_hz) + assert _par_variable(text, 'ref') == pytest.approx(-center_hz) + + +# --------------------------------------------------------------------------- +# Spectral-width estimation uses |nu_L| for negative-gamma nuclei +# --------------------------------------------------------------------------- + + +def test_sw_positive_for_negative_gamma_shifts(fake_simpson): + """SW must be positive and >= twice the shift range for 29Si.""" + simulate_spectrum(SPINSYS_29SI_SHIFTS, proton_frequency=400e6, spin_rate=10000) + sw = _par_value(fake_simpson['input'], 'sw') + width_hz = abs(ppm2hz(50.0, '400.0MHz', '29Si') - ppm2hz(-100.0, '400.0MHz', '29Si')) + assert sw > 0 + assert sw >= 2 * width_hz + assert sw % 10000 == 0 + + +def test_sw_floor_static_15n(fake_simpson): + """Single-peak static 15N: SW must hit the 10-ppm floor at |nu_L|.""" + spinsys = "channels 15N\nnuclei 15N\nshift 1 20p 0 0 0 0 0" + simulate_spectrum(spinsys, proton_frequency=800e6, spin_rate=0) + sw = _par_value(fake_simpson['input'], 'sw') + nu_l_hz = abs(get_larmor_freq('800.0MHz', '15N')) * 1e6 + assert sw == pytest.approx(nu_l_hz * 10e-6) + assert sw > 0 + + +def test_sw_quadrupolar_ct_mas_17o(fake_simpson): + """17O CT MAS: width dominated by Cq^2/|nu_L| second-order broadening.""" + cq = 3.0e6 + spinsys = f"channels 17O\nnuclei 17O\nshift 1 100p 0 0 0 0 0\nquadrupole 1 2 {cq} 0.5 0 0 0" + simulate_spectrum(spinsys, proton_frequency=800e6, spin_rate=30000) + text = fake_simpson['input'] + assert 'Inc' in text + sw = _par_value(text, 'sw') + nu_l_hz = abs(get_larmor_freq('800.0MHz', '17O')) * 1e6 + assert sw > 0 + assert sw >= cq ** 2 / nu_l_hz + assert sw % 30000 == 0 + + +def test_sw_quadrupolar_static_17o(fake_simpson): + """Quad-only static 17O: sw == Cq^2/|nu_L| (was negative before the fix).""" + cq = 3.0e6 + spinsys = f"channels 17O\nnuclei 17O\nquadrupole 1 2 {cq} 0.5 0 0 0" + simulate_spectrum(spinsys, proton_frequency=800e6, spin_rate=0) + sw = _par_value(fake_simpson['input'], 'sw') + nu_l_hz = abs(get_larmor_freq('800.0MHz', '17O')) * 1e6 + assert sw == pytest.approx(max(cq ** 2 / nu_l_hz, nu_l_hz * 10e-6)) + assert sw > 0 diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..da4e7fa --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,187 @@ +"""Tests for simpyson.utils — isotope lookups, add_spectra, simple_spinsys.""" +from __future__ import annotations + +import numpy as np +import pytest + +from simpyson.simpy import Simpy +from simpyson.utils import ( + _load_isotope_data, + add_spectra, + get_gamma, + get_larmor_freq, + get_spin, +) + + +# --------------------------------------------------------------------------- +# Isotope data helpers +# --------------------------------------------------------------------------- + +class TestIsotopeData: + def test_load_isotope_data_hydrogen(self): + row = _load_isotope_data("1H") + assert "Gamma" in row + assert "Spin" in row + + def test_load_isotope_data_carbon(self): + row = _load_isotope_data("13C") + assert row["Gamma"] != 0 + + def test_load_isotope_data_invalid(self): + with pytest.raises(ValueError, match="not found"): + _load_isotope_data("999Xx") + + def test_get_gamma_hydrogen(self): + gamma = get_gamma("1H") + assert isinstance(gamma, float) + assert gamma > 0 + + def test_get_gamma_carbon(self): + gamma_c = get_gamma("13C") + gamma_h = get_gamma("1H") + # Carbon gamma should be smaller than hydrogen + assert gamma_c < gamma_h + + def test_get_spin_hydrogen(self): + assert get_spin("1H") == 0.5 + + def test_get_spin_sodium(self): + assert get_spin("23Na") == 1.5 + + def test_get_spin_invalid(self): + with pytest.raises(ValueError, match="not found"): + get_spin("999Xx") + + +# --------------------------------------------------------------------------- +# Larmor frequency +# --------------------------------------------------------------------------- + +class TestLarmorFreq: + def test_larmor_freq_tesla(self): + freq = get_larmor_freq("9.4T", "1H") + # At 9.4T, proton Larmor should be ~400 MHz + assert 390 < freq < 410 + + def test_larmor_freq_mhz(self): + freq = get_larmor_freq("400MHz", "1H") + assert freq == pytest.approx(400.0, rel=0.01) + + def test_larmor_freq_carbon_at_400mhz(self): + freq_h = get_larmor_freq("400MHz", "1H") + freq_c = get_larmor_freq("400MHz", "13C") + # Carbon freq should be ~1/4 of proton + assert 0.20 < freq_c / freq_h < 0.30 + + def test_larmor_freq_invalid_unit(self): + with pytest.raises(ValueError, match="T or MHz"): + get_larmor_freq("400kHz", "1H") + + def test_larmor_freq_invalid_nucleus(self): + with pytest.raises(ValueError, match="not found"): + get_larmor_freq("400MHz", "999Xx") + + +# --------------------------------------------------------------------------- +# add_spectra +# --------------------------------------------------------------------------- + +def _make_spe(real_values, sw=1000.0, hz=None): + """Helper to create a Simpy with spectrum data.""" + s = Simpy() + n = len(real_values) + s.from_spe(real_values, np.zeros(n), n, sw, hz=hz) + return s + + +class TestAddSpectra: + def test_empty_list(self): + assert add_spectra([]) is None + + def test_single_spectrum(self): + s = _make_spe([1, 2, 3]) + result = add_spectra([s]) + assert result is not None + np.testing.assert_array_equal(result.spe['real'], [1, 2, 3]) + + def test_two_spectra_sum(self): + s1 = _make_spe([1, 2, 3]) + s2 = _make_spe([4, 5, 6]) + result = add_spectra([s1, s2]) + np.testing.assert_array_equal(result.spe['real'], [5, 7, 9]) + + def test_add_spectra_does_not_mutate_original(self): + s1 = _make_spe([1, 2, 3]) + original = s1.spe['real'].copy() + s2 = _make_spe([10, 20, 30]) + _ = add_spectra([s1, s2]) + np.testing.assert_array_equal(s1.spe['real'], original) + + def test_add_spectra_with_b0_override(self): + s1 = _make_spe([1, 1]) + s2 = _make_spe([2, 2]) + result = add_spectra([s1, s2], b0="400MHz", nucleus="1H") + assert result.b0 == "400MHz" + assert result.nucleus == "1H" + + def test_add_spectra_no_spe_raises(self): + s = Simpy() # no data at all + with pytest.raises(ValueError, match="no frequency-domain data"): + add_spectra([s]) + + def test_add_spectra_different_hz_axes(self): + """Spectra with different Hz ranges are interpolated onto a common grid.""" + # s1: peak at 100 Hz, covering 0–200 Hz + hz1 = np.linspace(0, 200, 201) + real1 = np.zeros(201) + real1[100] = 1.0 # peak at 100 Hz + s1 = _make_spe(real1, sw=200.0, hz=hz1) + + # s2: peak at 300 Hz, covering 200–400 Hz (no overlap) + hz2 = np.linspace(200, 400, 201) + real2 = np.zeros(201) + real2[100] = 1.0 # peak at 300 Hz + s2 = _make_spe(real2, sw=200.0, hz=hz2) + + result = add_spectra([s1, s2]) + # Common grid covers 0–400 Hz + assert result.spe['hz'][0] == pytest.approx(0.0) + assert result.spe['hz'][-1] == pytest.approx(400.0) + # Both peaks should be present; find max positions + real_combined = result.spe['real'] + hz_combined = result.spe['hz'] + peak_indices = np.where(real_combined > 0.5)[0] + peak_hz = hz_combined[peak_indices] + assert any(abs(p - 100.0) < 2.0 for p in peak_hz), "Peak near 100 Hz missing" + assert any(abs(p - 300.0) < 2.0 for p in peak_hz), "Peak near 300 Hz missing" + + def test_add_spectra_different_hz_does_not_mutate(self): + """Interpolation path should not mutate originals.""" + hz1 = np.linspace(0, 100, 101) + real1 = np.ones(101) + s1 = _make_spe(real1, sw=100.0, hz=hz1) + original1 = s1.spe['real'].copy() + + hz2 = np.linspace(50, 150, 101) + real2 = np.ones(101) * 2 + s2 = _make_spe(real2, sw=100.0, hz=hz2) + + _ = add_spectra([s1, s2]) + np.testing.assert_array_equal(s1.spe['real'], original1) + + +def test_add_spectra_common_sw_is_increment_times_np(): + """sw must equal increment * np, not end-minus-start (one-bin difference).""" + npoints = 64 + sw = 8000.0 + hz_a = sw * (np.arange(npoints) / npoints - 0.5) + hz_b = hz_a + 2000.0 # shifted axis forces interpolation path + rng = np.random.default_rng(0) + a = _make_spe(rng.normal(size=npoints), sw=sw, hz=hz_a) + b = _make_spe(rng.normal(size=npoints), sw=sw, hz=hz_b) + + combined = add_spectra([a, b]) + spe = combined.spe + step = spe['hz'][1] - spe['hz'][0] + assert spe['sw'] == pytest.approx(step * spe['np'])