diff --git a/examples/adaptive_grid.ipynb b/examples/adaptive_grid.ipynb new file mode 100644 index 00000000..1911d7d0 --- /dev/null +++ b/examples/adaptive_grid.ipynb @@ -0,0 +1,616 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "42715628-b062-441f-a4da-79c369bd54db", + "metadata": {}, + "source": "![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)" + }, + { + "cell_type": "markdown", + "id": "1a8a48b4-8d0c-4d1e-8839-2f4189b3546f", + "metadata": {}, + "source": [ + "# Adaptive Uniform Grid\n", + "The goal of this project is to compare and evaluate grid methods used for numerical integration in quantum chemistry and to demonstrate the construction of `AdaptiveUniformGrid`." + ] + }, + { + "cell_type": "markdown", + "id": "1067ec22-ccc7-4d6f-9ad6-965aaf18df11", + "metadata": {}, + "source": [ + "## Environment Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8b06f16e-f19d-4b7a-b862-65301fa23726", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All dependencies loaded successfully\n" + ] + } + ], + "source": [ + "import sys\n", + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "import time\n", + "from collections import deque\n", + "from typing import Callable, Optional\n", + "sys.path.insert(0, os.path.abspath('../src'))\n", + "sys.path.insert(0, os.path.abspath('../src/grid/tests'))\n", + "from grid.basegrid import Grid\n", + "from grid.cubic import UniformGrid, AdaptiveUniformGrid\n", + "from test_CubicProTransform import (setup_environment, System, run_uniform_grid_method,run_transform_grid_method, test_grid_sizes, load_molecular_data)\n", + "deps = setup_environment()\n", + "deps['AdaptiveUniformGrid'] = AdaptiveUniformGrid\n", + "\n", + "h2o_fchk_file = 'h2o.fchk'\n", + "h2_fchk_file = 'H2.fchk' \n", + "h2o_system = System(h2o_fchk_file, deps)\n", + "h2_system = System(h2_fchk_file, deps)\n", + "bfit_data_file = 'result_kl_fpi_stype_only.npz'" + ] + }, + { + "cell_type": "markdown", + "id": "23a0f425-9a60-4c75-9191-617a807e7a10", + "metadata": {}, + "source": [ + "### Part 1: Tests for `CubicProTransform`" + ] + }, + { + "cell_type": "markdown", + "id": "278ebb06-bdbb-42c7-81e7-c28181644906", + "metadata": {}, + "source": [ + "#### 1. `UniformGrid` vs. `CubicProTransform` electron density integration H₂O\n", + "\n", + "Compare the performance of `UniformGrid` against the `CubicProTransform` grid on a water molecule. We will evaluate the following metrics:\n", + "\n", + "* **Integrated Electrons**: The result should be close to the total number of electrons in water (10).\n", + "* **Relative Error**: A measure of the integration accuracy.\n", + "* **Total Time**: The combined time for grid generation and integration.\n", + "* **Number of Grid Points**: A measure of computational cost." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7c866aa2-4fe8-46a9-a7b1-edfcff5c5395", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Integration Performance Comparison for Water Molecule
 Grid MethodIntegrated ElectronsRelative Error (%)Total Time (s)Grid Points
0UniformGrid9.3649996.3500071.1040185,640
1CubicProTransform10.0175030.1750345.53218,000
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if h2o_system and bfit_data_file and deps:\n", + " uniform_result, _ = run_uniform_grid_method(h2o_system, deps)\n", + " transform_result, _ = run_transform_grid_method(h2o_system, bfit_data_file, deps, grid_size=20)\n", + " results_data = [\n", + " {\n", + " \"Grid Method\": \"UniformGrid\",\n", + " \"Integrated Electrons\": uniform_result['electrons'],\n", + " \"Relative Error (%)\": uniform_result['rel_error'] * 100,\n", + " \"Total Time (s)\": uniform_result['time'],\n", + " \"Grid Points\": uniform_result['points']\n", + " },\n", + " {\n", + " \"Grid Method\": \"CubicProTransform\",\n", + " \"Integrated Electrons\": transform_result['electrons'],\n", + " \"Relative Error (%)\": transform_result['rel_error'] * 100,\n", + " \"Total Time (s)\": transform_result['time'],\n", + " \"Grid Points\": transform_result['points']\n", + " }\n", + " ]\n", + "\n", + " df_comparison = pd.DataFrame(results_data)\n", + " display(df_comparison.style.format({\n", + " 'Integrated Electrons': '{:.6f}',\n", + " 'Relative Error (%)': '{:.6f}',\n", + " 'Total Time (s)': '{:.4f}',\n", + " 'Grid Points': '{:,}'\n", + " }).set_caption(\"Integration Performance Comparison for Water Molecule\"))" + ] + }, + { + "cell_type": "markdown", + "id": "43bfc448-b89f-4b7d-98fa-d977d685dc5b", + "metadata": {}, + "source": [ + "### 2. CubicProTransform performance changes with differs of grid sizes" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b8d59627-5d59-4a61-adc9-f0576075d38d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Performance of CubicProTransform of different Grid Size (Water Molecule)
 Grid SizeGrid PointsIntegrated ElectronsRelative Error (%)Total Time (s)
08351210.1604001.6040000.5486
11031,00010.0872790.8727860.7807
21231,72810.0600620.6006231.3595
31533,37510.0329420.3294162.5912
41835,83210.0217310.2173144.1041
52038,00010.0175030.1750345.7487
625315,62510.0113480.11348311.0458
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if h2o_system and bfit_data_file and deps:\n", + " grid_size_results = test_grid_sizes(h2o_system, bfit_data_file, deps)\n", + " gs_data = []\n", + " for size, result in grid_size_results.items():\n", + " gs_data.append({\n", + " \"Grid Size\": f\"{size}3\",\n", + " \"Grid Points\": result['points'],\n", + " \"Integrated Electrons\": result['electrons'],\n", + " \"Relative Error (%)\": result['rel_error'] * 100,\n", + " \"Total Time (s)\": result['time']\n", + " })\n", + "\n", + " df_grid_size = pd.DataFrame(gs_data)\n", + " display(df_grid_size.style.format({\n", + " 'Integrated Electrons': '{:.6f}',\n", + " 'Relative Error (%)': '{:.6f}',\n", + " 'Total Time (s)': '{:.4f}',\n", + " 'Grid Points': '{:,}'\n", + " }).set_caption(\"Performance of CubicProTransform of different Grid Size (Water Molecule)\"))" + ] + }, + { + "cell_type": "markdown", + "id": "cf098615-b2c6-4aec-99d3-739aeba6dab7", + "metadata": {}, + "source": [ + "## Part 2: Construct `AdaptiveUniformGrid`\n", + "\n", + "While CubicProTransform is very efficient, its accuracy is indirectly controlled by `grid_size`. To provide a solution with direct control over accuracy, I try to implemented a dynamic adaptive uniform grid.\n", + "\n", + "Core Algorithm:\n", + "1. Start: Start with a very coarse UniformGrid.\n", + "2. Evaluate: Evaluate the integral error at each grid cell.\n", + "3. Decide: If the error of a cell exceeds a user-defined threshold, tolerance , it is marked as \"refinement.\"\n", + "4. Refine: Split the marked cell into smaller subcells and add them to a queue for processing.\n", + "5. Loop: Repeat steps 2-4 until the queue is empty, meaning all cells meet the required accuracy." + ] + }, + { + "cell_type": "markdown", + "id": "aa919508-2e3c-471e-8092-dcd3435ee68e", + "metadata": {}, + "source": [ + "#### 1. Algorithm Visualization: Intelligent Refinement on a 2D Gaussian Function." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9c411d4a-6cae-4c7d-8073-cfecc11aac97", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "class AdaptiveGridVisualizer:\n", + " def run_refinement(self, uniform_grid, func, tolerance, max_depth=10):\n", + " adaptive = AdaptiveUniformGrid(uniform_grid, error_estimate=\"quadrature\")\n", + " result = adaptive.refinement(\n", + " func=func, tolerance=tolerance, max_depth=max_depth\n", + " )\n", + " return result\n", + " def visualize_before_after(self, uniform_grid, func, tolerance, zoom_box=None, max_depth=10):\n", + " result = self.run_refinement(uniform_grid, func, tolerance, max_depth=max_depth)\n", + " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5.5), facecolor='white')\n", + " \n", + " initial_points = uniform_grid.points\n", + " ax1.scatter(initial_points[:, 0], initial_points[:, 1], s=50, c='blue', alpha=0.6, edgecolors='black')\n", + " ax1.set_title(f'Initial Uniform Grid\\n({len(initial_points)} points)', fontweight='bold')\n", + " ax1.set_aspect('equal'); ax1.grid(True, alpha=0.3)\n", + " ax1.set_xlabel('X'); ax1.set_ylabel('Y')\n", + " \n", + " final_points = result['final_grid'].points\n", + " final_weights = result['final_grid'].weights\n", + " sizes = 500 * final_weights / final_weights.max() if final_weights.max() > 0 else 50\n", + " scatter = ax2.scatter(final_points[:, 0], final_points[:, 1], s=sizes, c=final_weights, \n", + " cmap='viridis', alpha=0.7, edgecolors='black', linewidth=0.3)\n", + " ax2.set_title(f'Refined Grid\\n({len(final_points)} points)', fontweight='bold')\n", + " ax2.set_aspect('equal'); ax2.grid(True, alpha=0.3)\n", + " ax2.set_xlabel('X'); ax2.set_ylabel('Y')\n", + " if zoom_box:\n", + " ax2.set_xlim(zoom_box[0]); ax2.set_ylim(zoom_box[1])\n", + " \n", + " divider = make_axes_locatable(ax2)\n", + " cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n", + " fig.colorbar(scatter, cax=cax, label='Weight')\n", + " \n", + " fig.suptitle(f'Adaptive Grid Refinement (Tolerance = {tolerance:.1e})', fontsize=16, fontweight='bold')\n", + " fig.tight_layout(rect=[0, 0, 1, 0.95])\n", + " return fig\n", + "def gaussian_2d_moderate(points):\n", + " return np.exp(-2 * np.sum(points**2, axis=1))\n", + "initial_grid_2d = UniformGrid(\n", + " origin=np.array([-5.0, -5.0]),\n", + " axes=np.diag([1.0, 1.0]),\n", + " shape=np.array([11, 11]),\n", + " weight=\"Rectangle\"\n", + ")\n", + "visualizer = AdaptiveGridVisualizer()\n", + "fig = visualizer.visualize_before_after(\n", + " uniform_grid=initial_grid_2d,\n", + " func=gaussian_2d_moderate,\n", + " tolerance=1e-5,\n", + " zoom_box=[[-3.5, 3.5], [-3.5, 3.5]],\n", + " max_depth=8\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c6f5562c-3448-46cc-aa90-ca01d25b4b89", + "metadata": {}, + "source": [ + "#### 2. Application to a Real Molecule: Hydrogen (H₂)\n", + "Integrate the electron density of a Hydrogen molecule based on the adptive uniform grid." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2fcdc0de-715c-44e2-ba06-7ed8f079f160", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Creating initial coarse grid for H₂...\n", + "Starting adaptive refinement for H₂...\n", + "Adaptive refinement finished in 2.41 seconds.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Comparison of Grid Methods for Hydrogen (H₂)
 MethodGrid PointsIntegrated ElectronsRelative Error (%)Time (s)
0Initial Coarse Grid2,5351.9642321.788396N/A
1AdaptiveUniformGrid7,5271.9862030.6898312.4071
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if 'h2_system' in locals() and h2_system and deps:\n", + " mol_data = load_molecular_data(h2_system.fchk_file, deps)\n", + " if mol_data:\n", + " real_density_function = lambda points: deps[\"evaluate_density\"](mol_data[\"rdm\"], mol_data[\"ao_basis\"],points) if points.shape[0] > 0 else np.array([])\n", + " print(\"Creating initial coarse grid for H₂...\")\n", + " coarse_grid = deps[\"UniformGrid\"].from_molecule(\n", + " mol_data[\"mol_data\"].atnums, mol_data[\"mol_data\"].atcoords,\n", + " spacing=0.8, extension=5.0, rotate=True, weight=\"Rectangle\"\n", + " )\n", + " initial_integral = coarse_grid.integrate(real_density_function(coarse_grid.points))\n", + " adaptive_grid_wrapper = deps[\"AdaptiveUniformGrid\"](coarse_grid)\n", + " print(\"Starting adaptive refinement for H₂...\")\n", + " start_time = time.time()\n", + " adaptive_result = adaptive_grid_wrapper.refinement(\n", + " func=real_density_function,\n", + " tolerance=1e-4,\n", + " max_depth=8,\n", + " refine_contrib_threshold=1e-5\n", + " )\n", + " adaptive_time = time.time() - start_time\n", + " print(f\"Adaptive refinement finished in {adaptive_time:.2f} seconds.\")\n", + " results_list = [\n", + " {\n", + " \"Method\": \"Initial Coarse Grid\",\n", + " \"Grid Points\": coarse_grid.size,\n", + " \"Integrated Electrons\": initial_integral,\n", + " \"Relative Error (%)\": abs(\n", + " initial_integral - h2_system.expected_electrons) / h2_system.expected_electrons * 100,\n", + " \"Time (s)\": \"N/A\"\n", + " },\n", + " {\n", + " \"Method\": \"AdaptiveUniformGrid\",\n", + " \"Grid Points\": adaptive_result['num_points'],\n", + " \"Integrated Electrons\": adaptive_result['integral'],\n", + " \"Relative Error (%)\": abs(\n", + " adaptive_result['integral'] - h2_system.expected_electrons) / h2_system.expected_electrons * 100,\n", + " \"Time (s)\": f\"{adaptive_time:.4f}\"\n", + " },\n", + " ]\n", + " df_comparison = pd.DataFrame(results_list)\n", + " display(df_comparison.style.format({\n", + " 'Integrated Electrons': '{:.6f}',\n", + " 'Relative Error (%)': '{:.6f}',\n", + " 'Grid Points': '{:,}'\n", + " }).set_caption(\"Comparison of Grid Methods for Hydrogen (H₂)\"))\n", + " final_grid_points = adaptive_result['final_grid'].points" + ] + }, + { + "cell_type": "markdown", + "id": "824d3af7-e8c6-4d9c-a9f2-2437991fe243", + "metadata": {}, + "source": [ + "#### 3.Visualization of the Refined Grid (Hydrogen)\n", + "\n", + "Visualize the resulting grid points together with the hydrogen molecule. To show how the points have clustered around the high-density regions of the atoms and bonds." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "00aa362c-890c-40c5-863a-aa46fa5a0c4f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if 'final_grid_points' in locals() and 'h2_system' in locals() and h2_system:\n", + " fig = plt.figure(figsize=(16, 7))\n", + " ax1 = fig.add_subplot(1, 2, 1, projection='3d')\n", + " coords = h2_system.coords\n", + " ax1.scatter(final_grid_points[:, 0], final_grid_points[:, 1], final_grid_points[:, 2], \n", + " s=2, alpha=0.1, label=\"Adaptive Grid Points\")\n", + " ax1.scatter(coords[:, 0], coords[:, 1], coords[:, 2], \n", + " s=100, c='gray', label='Hydrogen Atom (H)', edgecolors='w')\n", + "\n", + " ax1.set_title(\"Grid Distribution (H₂)\")\n", + " ax1.set_xlabel(\"X (Bohr)\"); ax1.set_ylabel(\"Y (Bohr)\"); ax1.set_zlabel(\"Z (Bohr)\")\n", + " ax1.legend()\n", + " ax1.view_init(elev=20., azim=45)\n", + " ax2 = fig.add_subplot(1, 2, 2)\n", + " y_slice_center = 0.0\n", + " slice_thickness = 0.5 \n", + " slice_mask = np.abs(final_grid_points[:, 1] - y_slice_center) < slice_thickness\n", + " slice_points = final_grid_points[slice_mask]\n", + " if len(slice_points) > 0:\n", + " ax2.scatter(slice_points[:, 0], slice_points[:, 2], \n", + " s=10, alpha=0.6, label=f\"Grid Points (y ≈ {y_slice_center})\")\n", + " ax2.scatter(coords[:, 0], coords[:, 2], \n", + " s=200, c='gray', label='Hydrogen Atom (H)', edgecolors='black')\n", + "\n", + " ax2.set_title(f\"View on the XZ Plane (y ≈ {y_slice_center})\")\n", + " ax2.set_xlabel(\"X (Bohr)\"); ax2.set_ylabel(\"Z (Bohr)\")\n", + " ax2.set_aspect('equal')\n", + " ax2.grid(True, linestyle='--', alpha=0.6)\n", + " ax2.legend(loc='upper right')\n", + "\n", + " plt.suptitle(\"Visualization of Adaptive Grid Points for the H₂ Molecule\", fontsize=16, fontweight='bold')\n", + " plt.tight_layout(rect=[0, 0, 1, 0.95])\n", + " plt.show()" + ] + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "def create_promol_params(self, symbols, coords, deps):\n", + " all_coeffs, all_exps, all_coords = [], [], []\n", + "\n", + " for i, symbol in enumerate(symbols):\n", + " element_data = self.element_data[symbol.lower()]\n", + " valid_mask = np.abs(element_data.coeffs_s) > 1e-12\n", + " if np.any(valid_mask):\n", + " all_coeffs.append(element_data.coeffs_s[valid_mask])\n", + " all_exps.append(element_data.exps_s[valid_mask])\n", + " all_coeffs[-1] *= np.sqrt(all_exps[-1] / np.pi) ** 3\n", + " all_coords.append(coords[i])\n", + "\n", + " coeffs_padded, exps_padded = deps[\"_pad_coeffs_exps_with_zeros\"](all_coeffs, all_exps)\n", + " return deps[\"_PromolParams\"](\n", + " c_m=coeffs_padded, e_m=exps_padded, coords=np.array(all_coords), dim=3\n", + " )" + ], + "id": "f7bf0d41-d2ec-4355-8dbd-fda68469be8e" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/result_kl_fpi_stype_only.npz b/examples/result_kl_fpi_stype_only.npz new file mode 100644 index 00000000..b8449913 Binary files /dev/null and b/examples/result_kl_fpi_stype_only.npz differ diff --git a/src/grid/cubic.py b/src/grid/cubic.py index 1c2998f6..d5f77ccf 100644 --- a/src/grid/cubic.py +++ b/src/grid/cubic.py @@ -101,8 +101,10 @@ def get_points_along_axes(self): x = self.points[coords_x, 0] return x, y - def interpolate(self, points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, method="cubic"): - r"""Interpolate function and its derivatives on cubic grid. + def interpolate( + self, points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, method="cubic", grid_pts=None + ): + r"""Interpolate function value at a given point. Only implemented in three-dimensions. @@ -130,10 +132,14 @@ def interpolate(self, points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, met If zero, then the function in z-direction is interpolated. If greater than zero, then the "nu_z"th-order derivative in the z-direction is interpolated. - method : str, optional + method: str, optional The method of interpolation to perform. Supported are "cubic" (most accurate but computationally expensive), "linear", or "nearest" (least accurate but cheap computationally). The last two methods use SciPy's RegularGridInterpolator function. + grid_pts: list[OneDGrids], optional + If provided, then uses `grid_pts` rather than the points of the HyperRectangle class + `self.points` to construct interpolation. Useful when doing a promolecular + transformation. Returns ------- @@ -141,6 +147,18 @@ def interpolate(self, points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, met The interpolation of a function (or of it's derivatives) at a :math:`M` point. """ + # Needed because CubicProTransform is a subclass of this method and has its own + # interpolate function. Since interpolate references itself, it chooses + # CubicProTransform rather than _HyperRectangleGrid class. + return self._interpolate( + points, values, use_log, nu_x, nu_y, nu_z, method, grid_pts + ) + + def _interpolate( + self, points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, method="cubic", grid_pts=None + ): + r"""Core of the Interpolate Algorithm.""" + if method not in ["cubic", "linear", "nearest"]: raise ValueError( f"Argument method should be either cubic, linear, or nearest , got {method}" @@ -154,6 +172,10 @@ def interpolate(self, points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, met f"Number of function values {values.shape[0]} does not match number of " f"grid points {np.prod(self.shape)}." ) + if grid_pts is not None and not isinstance(grid_pts, np.ndarray): + raise TypeError( + f"The grid points {type(grid_pts)} should have type None or numpy array." + ) if use_log: values = np.log(values) @@ -165,6 +187,10 @@ def interpolate(self, points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, met interpolate = RegularGridInterpolator((x, y, z), values, method=method) return interpolate(points) + # If grid_pts isn't specified, then use the grid stored as the class attribute. + if grid_pts is None: + grid_pts = self.points + # Interpolate the Z-Axis. def z_spline(z, x_index, y_index, nu_z=nu_z): # x_index, y_index is assumed to be in the grid while z is not assumed. @@ -173,7 +199,7 @@ def z_spline(z, x_index, y_index, nu_z=nu_z): small_index = self.coordinates_to_index((x_index, y_index, 1)) large_index = self.coordinates_to_index((x_index, y_index, self.shape[2] - 2)) val = CubicSpline( - self.points[small_index:large_index, 2], + grid_pts[small_index:large_index, 2], values[small_index:large_index], )(z, nu_z) return val @@ -183,7 +209,7 @@ def y_splines(y, x_index, z, nu_y=nu_y): # The `1` and `self.num_puts[1] - 2` is needed because I don't want the boundary. # Assumes x_index is in the grid while y, z may not be. val = CubicSpline( - self.points[np.arange(1, self.shape[1] - 2) * self.shape[2], 1], + grid_pts[np.arange(1, self.shape[1] - 2) * self.shape[2], 1], [z_spline(z, x_index, y_index, nu_z) for y_index in range(1, self.shape[1] - 2)], )(y, nu_y) # Trying to vectorize over z-axis and y-axis, this computes the interpolation for every @@ -195,7 +221,7 @@ def y_splines(y, x_index, z, nu_y=nu_y): # Interpolate the point (x, y, z) from a list of interpolated points on x,y-axis. def x_spline(x, y, z, nu_x): val = CubicSpline( - self.points[np.arange(1, self.shape[0] - 2) * self.shape[1] * self.shape[2], 0], + grid_pts[np.arange(1, self.shape[0] - 2) * self.shape[1] * self.shape[2], 0], [y_splines(y, x_index, z, nu_y) for x_index in range(1, self.shape[0] - 2)], )(x, nu_x) # Trying to vectorize over x-axis, this computes the interpolation for every @@ -207,7 +233,9 @@ def x_spline(x, y, z, nu_x): if use_log: # All derivatives require the interpolation of f at (x,y,z) interpolated = np.exp( - self.interpolate(points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0) + self._interpolate( + points, values, use_log=False, nu_x=0, nu_y=0, nu_z=0, grid_pts=grid_pts + ) ) # Only consider taking the derivative in only one direction one_var_deriv = sum([nu_x == 0, nu_y == 0, nu_z == 0]) == 2 @@ -218,21 +246,28 @@ def x_spline(x, y, z, nu_x): elif one_var_deriv: # Taking the k-th derivative wrt to only one variable (x, y, z) # Interpolate d^k ln(f) d"deriv_var" for all k from 1 to "deriv_var" + # Each entry of `derivs` is the interpolation of the derivative eval on points. if nu_x > 0: derivs = [ - self.interpolate(points, values, use_log=False, nu_x=i, nu_y=0, nu_z=0) + self._interpolate( + points, values, use_log=False, nu_x=i, nu_y=0, nu_z=0, grid_pts=grid_pts + ) for i in range(1, nu_x + 1) ] deriv_var = nu_x elif nu_y > 0: derivs = [ - self.interpolate(points, values, use_log=False, nu_x=0, nu_y=i, nu_z=0) + self._interpolate( + points, values, use_log=False, nu_x=0, nu_y=i, nu_z=0, grid_pts=grid_pts + ) for i in range(1, nu_y + 1) ] deriv_var = nu_y else: derivs = [ - self.interpolate(points, values, use_log=False, nu_x=0, nu_y=0, nu_z=i) + self._interpolate( + points, values, use_log=False, nu_x=0, nu_y=0, nu_z=i, grid_pts=grid_pts + ) for i in range(1, nu_z + 1) ] deriv_var = nu_z diff --git a/src/grid/protransform.py b/src/grid/protransform.py new file mode 100644 index 00000000..58df8abb --- /dev/null +++ b/src/grid/protransform.py @@ -0,0 +1,1141 @@ +# GRID is a numerical integration module for quantum chemistry. +# +# Copyright (C) 2011-2019 The GRID Development Team +# +# This file is part of GRID. +# +# GRID is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 3 +# of the License, or (at your option) any later version. +# +# GRID is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see +# -- +r"""Promolecular Grid Transformation.""" + +from dataclasses import astuple, dataclass, field + +from grid.basegrid import Grid, OneDGrid +from grid.cubic import _HyperRectangleGrid + +import numpy as np + +from scipy.interpolate import CubicSpline +from scipy.linalg import solve_triangular +from scipy.optimize import root_scalar +from scipy.special import erf + +__all__ = ["CubicProTransform", "PromolMolecule"] + + +class CubicProTransform(_HyperRectangleGrid): + r""" + Promolecular Grid Transformation of a Cubic Grid in :math:`[-1, 1]^3`. + + Grid is three-dimensional and modeled as Tensor Product of Three, one dimensional grids. + Theta space is defined to be :math:`[-1, 1]^3`. + Real space is defined to be :math:`\mathbb{R}^3.` + + Attributes + ---------- + shape : (int, int, int) + The number of points, including both of the end/boundary points, in x, y, and z direction. + prointegral : float + The integration value of the promolecular density over Euclidean space. + promol : namedTuple + Data about the Promolecular density. + points : np.ndarray(N, 3) + The transformed points in real space. + weights : np.ndarray(N,) + The weights multiplied by `prointegral`. + + Methods + ------- + integrate(trick=False) + Integral of a real-valued function over Euclidean space. Can use promolecular trick. + jacobian() + Jacobian of the transformation from Real space to Theta space :math:`[-1, 1]^3`. + hessian() + Hessian of the transformation from Real space to Theta space :math:`[-1, 1]^3`. + steepest_ascent_theta() + Direction of steepest-ascent of a function in theta space from gradient in real space. + transform(): + Transform Real point to Theta space :math:`[-1, 1]^3`. + inverse(bracket=(-10, 10)) + Transform Theta point to Real space :math:`\mathbb{R}^3`. + interpolate(use_log=False, nu=0) + Interpolate a function (or its logarithm) at a real point. Can interpolate its derivative. + + Examples + -------- + Define information of the Promolecular Density. + >> c = np.array([[5.], [10.]]) + >> e = np.array([[2.], [3.]]) + >> coord = np.array([[0., 0., 0.], [2., 2., 2.]]) + + Define information of the grid and its weights. + >> from grid.onedgrid import GaussChebyshev + + >> numb_x = 50 + This is a grid in :math:`[-1, 1]`. + >> oned = GaussChebyshev(numb_x) + One dimensional grid is the same in all x, y, z directions. + >> promol = CubicProTransform([oned, oned, oned], params.c_m, params.e_m, params.coords) + + To integrate some function f. + >> def f(pt): + >> return np.exp(-0.1 * np.linalg.norm(pt, axis=1)**2.) + >> func_values = f(promol.points) + >> print("The integral is %.4f" % promol.integrate(func_values, trick=False) + + References + ---------- + .. [1] J. I. Rodríguez, D. C. Thompson, P. W. Ayers, and A. M. Koster, "Numerical integration + of exchange-correlation energies and potentials using transformed sparse grids." + + Notes + ----- + Let :math:`\rho^o(x, y, z) = \sum_{i=1}^M \sum_{j=1}^D e^{}` be the Promolecular density of a \ + linear combination of Gaussian functions. + + The conditional distribution transformation from :math:`\mathbb{R}^3` to :math:`[-1, 1]^3` + transfers the (x, y, z) coordinates in :math:`\mathbb{R}^3` to a set of coordinates, + denoted as :math:`(\theta_x, \theta_y, \theta_z)`, in :math:`[-1,1]^3` that are "bunched" + up where :math:`\rho^o` is large. + + Precisely it is, + + .. math:: + \begin{eqnarray} + \theta_x(x) :&= + -1 + 2 \frac{\int_{-\infty}^x \int \int \rho^o(x, y, z)dx dy dz } + {\int \int \int \rho^o(x, y, z)dxdydz}\\ + \theta_y(x, y) :&= + -1 + 2 \frac{\int_{-\infty}^y \int \rho^o(x, y, z)dy dz } + {\int \int \rho^o(x, y, z)dydz} \\ + \theta_z(x, y, z) :&= + -1 + 2 \frac{\int_{-\infty}^z \rho^o(x, y, z)dz } + {\int \rho^o(x, y, z)dz}\\ + \end{eqnarray} + + Integration of a integrable function :math:`f : \mathbb{R}^3 \rightarrow \mathbb{R}` can be + done as follows in theta space: + + .. math:: + \int \int \int f(x, y, z)dxdy dz \approx + \frac{1}{8} N \int_{-1}^1 \int_{-1}^1 \int_{-1}^1 \frac{f(\theta_x, \theta_y, \theta_z)} + {\rho^o(\theta_x, \theta_y, \theta_z)} d\theta_x d\theta_y d\theta_z, + + \text{where } N = \int \int \int \rho^o(x, y, z) dx dy dz. + + Note that this class always assumed the boundary of [-1, 1]^3 is always included. + + """ + + def __init__(self, oned_grids, coeffs, exps, coords, cut_off=1e-8): + r""" + Construct CubicProTransform object. + + Parameters + ---------- + oned_grids: List[OneDGrid] + List of three one-dimensional grid representing the grids along x-axis. + coeffs: List[List[float]] + Coefficients of the promolecular transformation over :math:`M` centers. + exps: List[List[float]] + Exponents of the promolecular transformation over :math:`M` centers. + coords: ndarray(M, 3) + The coordinates of the promolecular expansion. + cut_off: float + If the distance between a point in theta-space to the boundary is less than the + cut_off, then the point is considered to be part of the boundary. + + """ + if not isinstance(oned_grids, list): + raise TypeError("oned_grid should be of type list.") + if not np.all([isinstance(grid, OneDGrid) for grid in oned_grids]): + raise TypeError("Grid in oned_grids should be of type `OneDGrid`.") + if not np.all([grid.domain == (-1, 1) for grid in oned_grids]): + raise ValueError("One Dimensional grid domain should be (-1, 1).") + if not len(oned_grids) == 3: + raise ValueError("There should be three One-Dimensional grids in `oned_grids`.") + self._l_bnd = -1.0 + self._u_bnd = 1.0 + self._shape = tuple([grid.size for grid in oned_grids]) + dimension = len(oned_grids) + + # pad coefficients and exponents with zeros to have the same size, easier to use numpy. + coeffs, exps = _pad_coeffs_exps_with_zeros(coeffs, exps) + self._promol = _PromolParams(coeffs, exps, coords, dimension) + self._prointegral = self._promol.integrate_all() + + weights = np.kron( + np.kron(oned_grids[0].weights, oned_grids[1].weights), oned_grids[2].weights + ) + # Transform Cubic Grid in Theta-Space to Real-space. + points = self._transform(oned_grids, cut_off) + # The prointegral is needed because of promolecular integration. + # Divide by 8 needed because the grid is in [-1, 1] rather than [0, 1]. + super().__init__(points, weights * self._prointegral / 2.0**dimension, self._shape) + + @property + def l_bnd(self): + r"""float: Lower bound in theta-space. Any point in theta-space that contains this point + gets mapped to infinity.""" + return self._l_bnd + + @property + def u_bnd(self): + r"""float: Upper bound in theta-space. Any point in theta-space that contains this point + gets mapped to infinity.""" + return self._u_bnd + + @property + def prointegral(self): + r"""Return integration of Promolecular density.""" + return self._prointegral + + @property + def promol(self): + r"""Return `PromolParams` data class.""" + return self._promol + + def transform(self, real_pt): + r""" + Transform a real point in three-dimensional Reals to theta space. + + Parameters + ---------- + real_pt : np.ndarray(3) + Point in :math:`\mathbb{R}^3` + + Returns + ------- + theta_pt : np.ndarray(3) + Point in :math:`[-1, 1]^3`. + + """ + return np.array( + [_transform_coordinate(real_pt, i, self.promol) for i in range(0, self.promol.dim)] + ) + + def inverse(self, theta_pt, bracket=(-10, 10)): + r""" + Transform a theta space point to three-dimensional Real space. + + Parameters + ---------- + theta_pt : np.ndarray(3) + Point in :math:`[-1, 1]^3` + bracket : (float, float), optional + Interval where root is suspected to be in Reals. + Used for "brentq" root-finding method. Default is (-10, 10). + + Returns + ------- + real_pt : np.ndarray(3) + Point in :math:`\mathbb{R}^3` + + Notes + ----- + - If a point is far away from the promolecular density, then it will be mapped + to `np.nan`. + + """ + real_pt = [] + for i in range(0, self.promol.dim): + scalar = _inverse_coordinate(theta_pt[i], i, real_pt[:i], self.promol, bracket) + real_pt.append(scalar) + return np.array(real_pt) + + def integrate(self, *value_arrays, trick=False, tol=1e-10): + r""" + Integrate any real-valued function on Euclidean space. + + Assumes the function decays faster than the promolecular density. + + Parameters + ---------- + *value_arrays : (np.ndarray(N, dtype=float),) + One or multiple value array to integrate. + trick : bool, optional + If true, uses the promolecular trick. + tol : float, optional + Integrand is set to zero whenever promolecular density is less than tolerance. + Default value is 1e-10. + + Returns + ------- + float : + Return the integration of the function. + + Raises + ------ + TypeError + Input integrand is not of type np.ndarray. + ValueError + Input integrand array is given or not of proper shape. + + Notes + ----- + - Formula for the integration of a integrable function + :math:`f : \mathbb{R}^3 \rightarrow \mathbb{R}` is done as follows: + + .. math:: + \int \int \int f(x, y, z)dxdy dz \approx + \frac{1}{8} N \int_{-1}^1 \int_{-1}^1 \int_{-1}^1 \frac{f(\theta_x, \theta_y, \theta_z)} + {\rho^o(\theta_x, \theta_y, \theta_z)} d\theta_x d\theta_y d\theta_z, + + \text{where } N = \int \int \int \rho^o(x, y, z) dx dy dz. + + - This method assumes function f decays faster than the promolecular density. + + """ + promolecular = self.promol.promolecular(self.points) + # Integrand is set to zero when promolecular is less than certain value and, + # When on the boundary (hence when promolecular is nan). + cond = (promolecular <= tol) | (np.isinf(promolecular)) + promolecular = np.ma.masked_where(cond, promolecular, copy=False) + + integrands = [] + for arr in value_arrays: + # This is needed as it gives incorrect results when arr.dtype isn't object. + assert arr.dtype != object, "Array dtype should not be object." + # This may be refactored to fit in the general promolecular trick in `grid`. + # Masked array is needed since division by promolecular contains nan. + if trick: + integrand = np.ma.divide(arr - promolecular, promolecular) + else: + integrand = np.ma.divide(arr, promolecular) + # Function/Integrand evaluated at points on the boundary is set to zero. + np.ma.fix_invalid(integrand, copy=False, fill_value=0) + integrands.append(integrand) + + if trick: + return self.prointegral + super().integrate(*integrands) + return super().integrate(*integrands) + + def derivative(self, real_pt, real_derivative): + r""" + Directional derivative in theta space. + + Parameters + ---------- + real_pt : np.ndarray(3) + Point in :math:`\mathbb{R}^3`. + real_derivative : np.ndarray(3) + Derivative of a function in real space with respect to x, y, z coordinates. + + Returns + ------- + theta_derivative : np.ndarray(3) + Derivative of a function in theta space with respect to theta coordinates. + + Notes + ----- + This does not preserve the direction of steepest-ascent/gradient. + + See Also + -------- + steepest_ascent_theta : Steepest-ascent direction. + + """ + jacobian = self.jacobian(real_pt) + return solve_triangular(jacobian.T, real_derivative) + + def steepest_ascent_theta(self, real_pt, real_grad): + r""" + Steepest ascent direction of a function in theta space. + + Steepest ascent is the gradient ie direction of maximum change of a function. + This guarantees moving in direction of steepest ascent in real-space + corresponds to moving in the direction of the gradient in theta-space. + + Parameters + ---------- + real_pt : np.ndarray(3) + Point in :math:`\mathbb{R}^3` + real_grad : np.ndarray(3) + Gradient of a function in real space. + + Returns + ------- + theta_grad : np.ndarray(3) + Gradient of a function in theta space. + + """ + jacobian = self.jacobian(real_pt) + return jacobian.dot(real_grad) + + def interpolate( + self, + points, + values, + oned_grids, + use_log=False, + nu=0, + ): + r""" + Interpolate function at a point. + + Parameters + ---------- + real_pt : np.ndarray(3,) + Point in :math:`\mathbb{R}^3` that needs to be interpolated. + values : np.ndarray(N,) + Function values at each point of the grid `points`. + oned_grids = list(OneDGrids) + List containing three one-dimensional grid corresponding to x, y, z direction + use_log : bool + If true, then logarithm is applied before interpolating to the function values, + including `func_values`. + nu : int + If zero, then the function is interpolated. + If one, then the derivative is interpolated. + + Returns + ------- + float : + If nu is 0: Returns the interpolated of a function at a real point. + If nu is 1: Returns the interpolated derivative of a function at a real point. + + """ + if nu not in (0, 1): + raise ValueError("The parameter nu %d is either zero or one " % nu) + + grid_pts = ( + np.vstack( + np.meshgrid( + oned_grids[0].points, + oned_grids[1].points, + oned_grids[2].points, + indexing="ij", + ) + ) + .reshape(3, -1) + .T + ) + theta_points = np.array([self.transform(x) for x in points], dtype=float) + + if nu == 0: + interpolation = super()._interpolate( + theta_points, values, use_log, 0, 0, 0, grid_pts=grid_pts + ) + if nu == 1: + # Interpolate in the theta-space and take the derivatives + interpolate_x = super()._interpolate( + theta_points, values, use_log, 1, 0, 0, grid_pts=grid_pts + ) + interpolate_y = super()._interpolate( + theta_points, values, use_log, 0, 1, 0, grid_pts=grid_pts + ) + interpolate_z = super()._interpolate( + theta_points, values, use_log, 0, 0, 1, grid_pts=grid_pts + ) + interpolation = np.vstack((interpolate_x.T, interpolate_y.T, interpolate_z.T)).T + # Transform the derivatives back to real-space. + interpolation = np.array( + [self.jacobian(points[i]).dot(interpolation[i]) for i in range(len(interpolation))] + ) + + return interpolation + + def jacobian(self, real_pt): + r""" + Jacobian of the transformation from real space to theta space. + + Precisely, it is the lower-triangular matrix + + .. math:: + \begin{bmatrix} + \frac{\partial \theta_x}{\partial X} & 0 & 0 \\ + \frac{\partial \theta_y}{\partial X} & \frac{\partial \theta_y}{\partial Y} & 0 \\ + \frac{\partial \theta_z}{\partial X} & \frac{\partial \theta_z}{\partial Y} & + \frac{\partial \theta_z}{\partial Z} + \end{bmatrix}. + + Parameters + ---------- + real_pt : np.ndarray(3,) + Point in :math:`\mathbb{R}^3`. + + Returns + ------- + np.ndarray(3, 3) : + Jacobian of transformation. + + """ + jacobian = np.zeros((3, 3), dtype=np.float64) + + c_m, e_m, coords, pi_over_exps, dim = astuple(self.promol) + + # Distance to centers/nuclei`s and Prefactors. + diff_coords = real_pt - coords + diff_squared = diff_coords**2.0 + # If i_var is zero, then distance is just all zeros. + for i_var in range(0, self.promol.dim): + + # Basic-Level arrays for integration and derivatives. + ( + distance, + single_gauss, + integrate_till_pt_x, + transf_num, + transf_den, + ) = self.promol.helper_for_derivatives(diff_squared, diff_coords, i_var) + + for j_deriv in range(0, i_var + 1): + if i_var == j_deriv: + # Derivative eliminates `integrate_till_pt_x`, and adds a Gaussian. + inner_term = single_gauss * np.exp(-e_m * diff_squared[:, i_var][:, np.newaxis]) + jacobian[i_var, i_var] = np.sum(inner_term) / transf_den + elif j_deriv < i_var: + # Derivative of inside of Gaussian. + deriv_inside = self.promol.derivative_gaussian(diff_coords, j_deriv) + deriv_num = np.sum(single_gauss * integrate_till_pt_x * deriv_inside) + deriv_den = np.sum(single_gauss * deriv_inside * pi_over_exps) + # Quotient Rule + jacobian[i_var, j_deriv] = deriv_num * transf_den - transf_num * deriv_den + jacobian[i_var, j_deriv] /= transf_den**2.0 + + return 2.0 * jacobian + + def hessian(self, real_pt): + r""" + Hessian of the transformation. + + The Hessian :math:`H` is a three-dimensional array with (i, j, k)th entry: + + .. math:: + H_{i, j, k} = \frac{\partial^2 \theta_i(x_0, \cdots, x_{i-1}}{\partial x_i \partial x_j} + + \text{where } (x_0, x_1, x_2) := (x, y, z). + + Parameters + ---------- + real_pt : np.ndarray(3,) + Real point in :math:`\mathbb{R}^3`. + + Returns + ------- + hessian : np.ndarray(3, 3, 3) + The (i, j, k)th entry is the partial derivative of the ith transformation function + with respect to the jth, kth coordinate. e.g. when i = 0, then hessian entry at + (i, j, k) is zero unless j = k = 0. + + """ + hessian = np.zeros((self.ndim, self.ndim, self.ndim), dtype=np.float64) + + c_m, e_m, coords, pi_over_exps, dim = astuple(self.promol) + + # Distance to centers/nuclei`s and Prefactors. + diff_coords = real_pt - coords + diff_squared = diff_coords**2.0 + + # i_var is the transformation to theta-space. + # j_deriv is the first partial derivative wrt x, y, z. + # k_deriv is the second partial derivative wrt x, y, z. + for i_var in range(0, 3): + + # Basic-Level arrays for integration and derivatives. + ( + distance, + single_gauss, + integrate_till_pt_x, + transf_num, + transf_den, + ) = self.promol.helper_for_derivatives(diff_squared, diff_coords, i_var) + + for j_deriv in range(0, i_var + 1): + for k_deriv in range(0, i_var + 1): + # num is the numerator of transformation function. + # den is the denominator of transformation function. + # dnum_dk is the derivative of numerator wrt to k_deriv. + # dnum_dkdj is the derivative of num wrt to j_deriv then k_deriv. + # The derivative will store the result and pass it to the Hessian. + derivative = 0.0 + + if i_var == j_deriv: + gauss_extra = single_gauss * np.exp( + -e_m * diff_squared[:, j_deriv][:, np.newaxis] + ) + if j_deriv == k_deriv: + # Diagonal derivative e.g. d(theta_X)(dx dx) + gauss_extra *= self.promol.derivative_gaussian(diff_coords, j_deriv) + derivative = np.sum(gauss_extra) / transf_den + else: + # Partial derivative of diagonal derivative e.g. d^2(theta_y)(dy dx). + deriv_inside = self.promol.derivative_gaussian(diff_coords, k_deriv) + dnum_dkdj = np.sum(gauss_extra * deriv_inside) + dden_dk = np.sum(single_gauss * deriv_inside * pi_over_exps) + # Numerator is different from `transf_num` since Gaussian is added. + dnum_dj = np.sum(gauss_extra) + # Quotient Rule + derivative = dnum_dkdj * transf_den - dnum_dj * dden_dk + derivative /= transf_den**2.0 + + # Here, quotient rule all the way down. + elif j_deriv < i_var: + if k_deriv == i_var: + gauss_extra = single_gauss * np.exp( + -e_m * diff_squared[:, k_deriv][:, np.newaxis] + ) + deriv_inside = self.promol.derivative_gaussian(diff_coords, j_deriv) + ddnum_djdi = np.sum(gauss_extra * deriv_inside) + dden_dj = np.sum(single_gauss * deriv_inside * pi_over_exps) + # Quotient Rule + dnum_dj = np.sum(gauss_extra) + derivative = ddnum_djdi * transf_den - dnum_dj * dden_dj + derivative /= transf_den**2.0 + + elif k_deriv == j_deriv: + # Double Quotient Rule. + # See wikipedia "Quotient Rules Higher order formulas". + deriv_inside = self.promol.derivative_gaussian(diff_coords, k_deriv) + dnum_dj = np.sum(single_gauss * integrate_till_pt_x * deriv_inside) + dden_dj = np.sum(single_gauss * pi_over_exps * deriv_inside) + + prod_rule = deriv_inside**2.0 - 2.0 * e_m + sec_deriv_num = np.sum(single_gauss * integrate_till_pt_x * prod_rule) + sec_deriv_den = np.sum(single_gauss * pi_over_exps * prod_rule) + + output = sec_deriv_num * transf_den - dnum_dj * dden_dj + output /= transf_den**2.0 + quot = transf_den * (dnum_dj * dden_dj + transf_num * sec_deriv_den) + quot -= 2.0 * transf_num * dden_dj * dden_dj + derivative = output - quot / transf_den**3.0 + + elif k_deriv != j_deriv: + # K is i_Sec_diff and i is i_diff + deriv_inside = self.promol.derivative_gaussian(diff_coords, j_deriv) + deriv_inside_sec = self.promol.derivative_gaussian(diff_coords, k_deriv) + gauss_and_inte_x = single_gauss * integrate_till_pt_x + gauss_and_inte = single_gauss * pi_over_exps + + dnum_di = np.sum(gauss_and_inte_x * deriv_inside) + dden_di = np.sum(gauss_and_inte * deriv_inside) + + dnum_dk = np.sum(gauss_and_inte_x * deriv_inside_sec) + dden_dk = np.sum(gauss_and_inte * deriv_inside_sec) + + ddnum_dkdk = np.sum(gauss_and_inte_x * deriv_inside * deriv_inside_sec) + ddden_dkdk = np.sum(gauss_and_inte * deriv_inside * deriv_inside_sec) + + output = ddnum_dkdk / transf_den + output -= dnum_di * dden_dk / transf_den**2.0 + product = dnum_dk * dden_di + transf_num * ddden_dkdk + derivative = output + derivative -= product / transf_den**2.0 + derivative += 2.0 * transf_num * dden_di * dden_dk / transf_den**3.0 + + # The 2.0 is needed because we're in [-1, 1] rather than [0, 1]. + hessian[i_var, j_deriv, k_deriv] = 2.0 * derivative + + return hessian + + def _transform(self, oned_grids, cut_off=1e-8): + # Transform the entire grid. + # Indices (i, j, k) start from bottom, left-most corner of the [-1, 1]^3 cube. + def _is_boundary_pt(theta_pt): + if np.abs(theta_pt - self.l_bnd) < cut_off or np.abs(theta_pt - self.u_bnd) < cut_off: + return True + return False + + counter = 0 + points = np.empty((np.prod(self.shape), len(oned_grids)), dtype=np.float64) + for ix in range(self.shape[0]): + cart_pt = [None, None, None] + theta_x = oned_grids[0].points[ix] + is_boundary = _is_boundary_pt(theta_x) + brack_x = self._get_bracket((ix,), 0, points, is_boundary) + cart_pt[0] = _inverse_coordinate(theta_x, 0, cart_pt, self.promol, brack_x) + + for iy in range(self.shape[1]): + theta_y = oned_grids[1].points[iy] + is_boundary = _is_boundary_pt(theta_y) + brack_y = self._get_bracket((ix, iy), 1, points, is_boundary) + cart_pt[1] = _inverse_coordinate(theta_y, 1, cart_pt, self.promol, brack_y) + + for iz in range(self.shape[2]): + theta_z = oned_grids[2].points[iz] + is_boundary = _is_boundary_pt(theta_z) + brack_z = self._get_bracket((ix, iy, iz), 2, points, is_boundary) + cart_pt[2] = _inverse_coordinate(theta_z, 2, cart_pt, self.promol, brack_z) + points[counter] = cart_pt.copy() + counter += 1 + return points + + def _get_bracket(self, indices, i_var, prev_points, is_boundary): + r""" + Obtain brackets for root-finder based on the coordinate of the point. + + Parameters + ---------- + indices : tuple(int, int, int) + The indices of a point, where (0, 0, 0) is the bottom, left-most, down point + of the cube. + i_var : int + Index of point being transformed. + prev_points: ndarray(M, 3) + Points that are transformed and empty points that haven't been transformed yet. + The points that are transformed is used to obtain brackets for this current + point that hasn't been transformed yet. + is_boundary: bool + If the current indices is a boundary point, then returns inf, as it maps to infinity. + + Returns + ------- + (float, float) : + The bracket for the root-finder solver. + + """ + # If it is a boundary point, then return nan. Done by indices. + if is_boundary: + return np.inf, np.inf + # If it is a new point, with no nearby point, get a large initial guess. + else: + min = np.min(self.promol.coords[:, i_var]) - 20.0 + max = np.max(self.promol.coords[:, i_var]) + 20.0 + return min, max + # If the previous point has been converted, use that as a initial guess. + # if i_var == 0: + # print(" shape = %s" % str(self.shape)) + # index = (indices[0] - 1) * self.shape[1] * self.shape[2] + # print(" index = %d" % index) + # elif i_var == 1: + # index = indices[0] * self.shape[1] * self.shape[2] + self.shape[2] * (indices[1] - 1) + # elif i_var == 2: + # index = ( + # indices[0] * self.shape[1] * self.shape[2] + # + self.shape[2] * indices[1] + # + indices[2] + # - 1 + # ) + # print(" prev_points = %s" % str(prev_points)) + # print(" shape prev_points = %s" % str(prev_points.shape)) + # print(f" returned {prev_points[index, i_var]}") + + # return prev_points[index, i_var], prev_points[index, i_var] + 10.0 + + +@dataclass +class _PromolParams: + r""" + Private class for Promolecular Density information. + + Contains helper-functions for Promolecular Transformation. + They are coded as pipe-lines for this special purpose and + the reason why "diff_coords" is chosen as a attribute rather + than a generic "[x, y, z]" point. + + """ + + c_m: np.ndarray # Coefficients of Promolecular. + e_m: np.ndarray # Exponents of Promolecular. + coords: np.ndarray # Centers/Coordinates of Each Gaussian. + pi_over_exponents: np.ndarray = field(init=False) + dim: int = 3 + + def __post_init__(self): + r"""Initialize pi_over_exponents.""" + # Rather than computing this repeatedly. It is fixed. + with np.errstate(divide="ignore"): + self.pi_over_exponents = np.sqrt(np.pi / self.e_m) + self.pi_over_exponents[self.e_m == 0.0] = 0.0 + + def integrate_all(self): + r"""Integration of Gaussian over Entire Real space ie :math:`\mathbb{R}^D`.""" + return np.sum(self.c_m * self.pi_over_exponents**self.dim) + + def derivative_gaussian(self, diff_coords, j_deriv): + r"""Return derivative of single Gaussian but without exponential.""" + return -self.e_m * 2.0 * diff_coords[:, j_deriv][:, np.newaxis] + + def integration_gaussian_till_point(self, diff_coords, i_var, with_factor=False): + r"""Integration of Gaussian wrt to `i_var` variable till a point (inside diff_coords).""" + coord_ivar = diff_coords[:, i_var][:, np.newaxis] + integration = (erf(np.sqrt(self.e_m) * coord_ivar) + 1.0) / 2.0 + if with_factor: + # Included the (pi / exponents), this becomes the actual integral. + # Not including the (pi / exponents) increasing computation slightly faster. + return integration * self.pi_over_exponents + return integration + + def single_gaussians(self, distance): + r"""Return matrix with entries a single gaussian evaluated at the float distance.""" + return self.c_m * np.exp(-self.e_m * distance) + + def promolecular(self, points): + r""" + Evaluate the promolecular density over a grid. + + Parameters + ---------- + points : np.ndarray(N, D) + Points in :math:`\mathbb{R}^D`. + + Returns + ------- + np.ndarray(N,) : + Promolecular density evaluated at the points. + + """ + # M is the number of centers/atoms. + # D is the number of dimensions, usually 3. + # K is maximum number of gaussian functions over all M atoms. + cm, em, coords = self.c_m, self.e_m, self.coords + # Shape (N, M, D), then Summing gives (N, M, 1) + distance = np.sum((points - coords[:, np.newaxis]) ** 2.0, axis=2, keepdims=True) + # At each center, multiply Each Distance of a Coordinate, with its exponents. + exponen = np.exp(-np.einsum("MND, MK-> MNK", distance, em)) + # At each center, multiply the exponential with its coefficients. + gaussian = np.einsum("MNK, MK -> MNK", exponen, cm) + # At each point, sum for each center, then sum all centers together. + return np.einsum("MNK -> N", gaussian, dtype=np.float64) + + def helper_for_derivatives(self, diff_squared, diff_coords, i_var): + r""" + Return Arrays for computing the derivative of transformation functions wrt x, y, z. + + Parameters + ---------- + diff_squared : np.ndarray + The squared of difference of position to the center of the Promoleculars. + diff_coords : np.ndarray + The difference of position to the center of the Promoleculars. This is the square + root of `diff_squared`. + i_var : int + Index of one of x, y, z. + + Returns + ------- + distance : np.ndarray + The squared distance from the position to the center of the Promoleculars. + single_gauss : np.ndarray + Array with entries of a single Gaussian e^(-a distance) with factor (pi / a). + integrate_till_pt_x : np.ndarray + Integration of a Gaussian from -inf to x, ie + (pi / a)^0.5 * (erf(a^0.5 (x - center of Gaussian) + 1) / 2 + transf_num : float + The numerator of the transformation. Mostly used for quotient rule. + transf_den : float + The denominator of the transformation. Mostly used for quotient rule. + + """ + distance = np.sum(diff_squared[:, :i_var], axis=1)[:, np.newaxis] + + # Gaussian Integrals Over Entire Space For Numerator and Denomator. + single_gauss = self.single_gaussians(distance) + single_gauss *= self.pi_over_exponents ** (self.dim - i_var - 1) + + # Get integral of Gaussian till a point. + integrate_till_pt_x = self.integration_gaussian_till_point( + diff_coords, i_var, with_factor=True + ) + # Numerator and Denominator of Original Transformation. + transf_num = np.sum(single_gauss * integrate_till_pt_x) + transf_den = np.sum(single_gauss * self.pi_over_exponents) + return distance, single_gauss, integrate_till_pt_x, transf_num, transf_den + + +def _transform_coordinate(real_pt, i_var, promol): + r""" + Transform the `i_var` coordinate of a real point to [-1, 1] using promolecular density. + + Parameters + ---------- + real_pt : np.ndarray(D,) + Real point being transformed. + i_var : int + Index that is being tranformed. Less than D. + promol : _PromolParams + Promolecular Data Class. + + Returns + ------- + theta_pt : float + The transformed point in :math:`[-1, 1]`. + + """ + _, _, coords, pi_over_exps, dim = astuple(promol) + + # Distance to centers/nuclei`s and Prefactors. + diff_coords = real_pt[: i_var + 1] - coords[:, : i_var + 1] + diff_squared = diff_coords**2.0 + distance = np.sum(diff_squared[:, :i_var], axis=1)[:, np.newaxis] + # If i_var is zero, then distance is just all zeros. + + # Single Gaussians Including Integration of Exponential over `(dim - i_var)` variables. + single_gauss = promol.single_gaussians(distance) * pi_over_exps ** (dim - i_var) + + # Get the integral of Gaussian till a point excluding a prefactor. + # prefactor (pi / exponents) is included in `gaussian_integrals`. + cdf_gauss = promol.integration_gaussian_till_point(diff_coords, i_var, with_factor=False) + + # Final Result. + transf_num = np.sum(single_gauss * cdf_gauss) + transf_den = np.sum(single_gauss) + transform_value = transf_num / transf_den + + # -1. + 2. is needed to transform to [-1, 1], rather than [0, 1]. + return -1.0 + 2.0 * transform_value + + +def _root_equation(init_guess, prev_trans_pts, theta_pt, i_var, promol): + r""" + Equation to solve for the root to find inverse coordinate from theta space to Real space. + + Parameters + ---------- + init_guess : float + Initial guess of Real point that transforms to `theta_pt`. + prev_trans_pts : list[`i_var` - 1] + The previous points in real-space that were already transformed. + theta_pt : float + The point in [-1, 1] being transformed to the Real space. + i_var : int + Index of variable being transformed. + promol : _PromolParams + Promolecular Data Class. + + Returns + ------- + float : + The difference between `theta_pt` and the transformed point based on + `init_guess` and `prev_trans_pts`. + + """ + all_points = np.append(prev_trans_pts, init_guess) + transf_pt = _transform_coordinate(all_points, i_var, promol) + return theta_pt - transf_pt + + +def _inverse_coordinate(theta_pt, i_var, transformed, promol, bracket=(-10, 10)): + r""" + Transform a point in [-1, 1] to the real space corresponding to `i_var` variable. + + Parameters + ---------- + theta_pt : float + Point in [-1, 1]. + i_var : int + Index that is being tranformed. Less than D. + transformed : list[`i_var` - 1] + The set of previous points before index `i_var` that were transformed to real space. + promol : _PromolParams + Promolecular Data Class. + bracket : (float, float) + Interval where root is suspected to be in Reals. Used for "brentq" root-finding method. + Default is (-10, 10). + + Returns + ------- + real_pt : float + Return the transformed real point. + + Raises + ------ + AssertionError : If the root did not converge, or brackets did not have opposite sign. + RuntimeError : If dynamic bracketing reached maximum iteration. + + Notes + ----- + - If the theta point is on the boundary or it is itself a nan, then it get's mapped to nan. + Further, if nan is in `transformed[:i_var]` then this function will return nan. + - If Brackets do not have the opposite sign, will change the brackets by adding/subtracting + the value 10 to the lower or upper bound that is closest to zero. + + """ + # Check's if this is a boundary points which is mapped to np.nan + # These two conditions are added for individual point transformation. + if np.abs(theta_pt - -1.0) < 1e-10: + return np.inf + if np.abs(theta_pt - 1.0) < 1e-10: + return np.inf + # This condition is added for transformation of the entire grid. + # The [:i_var] is needed because of the way I've set-up transforming points in _transform. + # Likewise for the bracket, see the function `get_bracket`. + if np.inf in bracket or np.inf in transformed[:i_var]: + return np.inf + + def _dynamic_bracketing(l_bnd, u_bnd, maxiter=5000): + r"""Dynamically changes the lower (or upper bound) to have different sign values.""" + bounds = [l_bnd, u_bnd] + + def is_same_sign(x, y): + return (x >= 0 and y >= 0) or (x < 0 and y < 0) + + f_l_bnd = _root_equation(l_bnd, *args) + f_u_bnd = _root_equation(u_bnd, *args) + + # Get Index of the one that is closest to zero, the one that needs to change. + f_bnds = np.abs([f_l_bnd, f_u_bnd]) + idx = f_bnds.argmin() + # Check if they have the same sign. + same_sign = is_same_sign(*bounds) + counter = 0 + while same_sign and counter < maxiter: + # Add 10 to the upper bound or subtract 10 to the lower bound to the one that + # is closest to zero. This is done based on the sign. + bounds[idx] = np.sign(idx - 0.5) * 10 + bracket[idx] + # Update info for next iteration. + if idx == 0: + f_l_bnd = _root_equation(bracket[0], *args) + else: + f_u_bnd = _root_equation(bracket[1], *args) + same_sign = is_same_sign(f_l_bnd, f_u_bnd) + counter += 1 + + if counter == maxiter: + raise RuntimeError( + f"Couldn't find correct bounds {bracket} for the root-solver " + f"to solve for the inverse." + ) + return tuple(bounds) + + # Set up Arguments for root_equation with dynamic bracketing. + args = (transformed[:i_var], theta_pt, i_var, promol) + bracket = _dynamic_bracketing(bracket[0], bracket[1]) + root_result = root_scalar( + _root_equation, + args=args, + method="brentq", + bracket=[bracket[0], bracket[1]], + maxiter=50, + xtol=2e-15, + ) + assert root_result.converged + return root_result.root + + +def _pad_coeffs_exps_with_zeros(coeffs, exps): + r"""Pad Promolecular coefficients and exponents with zero. Results in same size array.""" + max_numb_of_gauss = max(len(c) for c in coeffs) + coeffs = np.array( + [ + np.pad(a, (0, max_numb_of_gauss - len(a)), "constant", constant_values=0.0) + for a in coeffs + ], + dtype=np.float64, + ) + exps = np.array( + [np.pad(a, (0, max_numb_of_gauss - len(a)), "constant", constant_values=0.0) for a in exps], + dtype=np.float64, + ) + return coeffs, exps + + +class PromolMolecule: + """ + Simplified interface for creating CubicProTransform grids using BFit data. + + Parameters + ---------- + symbols : list of str + Element symbols for the molecular system. + coords : np.ndarray(M, 3) + Atomic coordinates in atomic units. + expected_electrons : int + Expected number of electrons in the system. + bfit_data_file : str or Path + Path to the BFit data file containing promolecular parameters. + + Examples + -------- + >>> symbols = ['h', 'h'] + >>> coords = np.array([[0., 0., -0.5], [0., 0., 0.5]]) + >>> mol = PromolMolecule(symbols, coords, 2, 'data/bfit_data.npz') + >>> transform_grid = mol.create_transform_grid(grid_size=20) + """ + + def __init__(self, symbols, coords, expected_electrons, bfit_data_file): + self.symbols = symbols + self.coords = np.array(coords) + self.expected_electrons = expected_electrons + self.bfit_data_file = bfit_data_file + self._bfit_processor = None + self._normalized_promol = None + + def _initialize_bfit_processor(self): + """Initialize BFit processor if not already done.""" + if self._bfit_processor is None: + from grid.utils_promol import BFitDataProcessor + self._bfit_processor = BFitDataProcessor(self.bfit_data_file) + if not self._bfit_processor.load_bfit_data(): + raise RuntimeError(f"Failed to load BFit data from {self.bfit_data_file}") + self._bfit_processor.parse_element_data() + + def _create_normalized_promol_params(self): + """Create normalized promolecular parameters.""" + if self._normalized_promol is None: + self._initialize_bfit_processor() + + # Check element availability + missing = [s for s in self.symbols if + s.lower() not in self._bfit_processor.element_data] + if missing: + raise ValueError(f"Missing elements in BFit data: {missing}") + + # Create dependencies dict for BFitDataProcessor + deps = { + "_PromolParams": _PromolParams, + "_pad_coeffs_exps_with_zeros": _pad_coeffs_exps_with_zeros, + } + + # Create initial promolecular parameters + promol_params = self._bfit_processor.create_promol_params( + self.symbols, self.coords, deps + ) + + # Normalize to match expected electron count + norm_factor = self.expected_electrons / promol_params.integrate_all() + + self._normalized_promol = _PromolParams( + c_m=promol_params.c_m * norm_factor, + e_m=promol_params.e_m, + coords=promol_params.coords, + dim=promol_params.dim, + ) + + return self._normalized_promol + + def create_transform_grid(self, grid_size=20, oned_grid_type="GaussChebyshev"): + """ + Create a CubicProTransform grid for the molecular system. + + Parameters + ---------- + grid_size : int, optional + Number of points in each dimension. Default is 20. + oned_grid_type : str, optional + Type of one-dimensional grid to use. Default is "GaussChebyshev". + + Returns + ------- + CubicProTransform + The constructed transform grid object. + """ + # Get normalized promolecular parameters + normalized_promol = self._create_normalized_promol_params() + + # Create one-dimensional grids + if oned_grid_type == "GaussChebyshev": + from grid.onedgrid import GaussChebyshev + oned_grid = GaussChebyshev(grid_size) + else: + raise ValueError(f"Unsupported oned_grid_type: {oned_grid_type}") + + # Create and return CubicProTransform + return CubicProTransform( + [oned_grid, oned_grid, oned_grid], + normalized_promol.c_m, + normalized_promol.e_m, + normalized_promol.coords, + ) + diff --git a/src/grid/tests/test_CubicProTransform.py b/src/grid/tests/test_CubicProTransform.py new file mode 100644 index 00000000..610326cf --- /dev/null +++ b/src/grid/tests/test_CubicProTransform.py @@ -0,0 +1,423 @@ +#!/usr/bin/env python3 +""" +Electron Density Integration Test + +Compares two grid integration methods for molecular systems: +1. UniformGrid - Traditional equal-spacing cubic grid +2. CubicProTransform - Adaptive grid guided by promolecular density + +Test systems: He, H2, HCl, CH4, H2O +""" + +import os +import sys +import time +from pathlib import Path +import numpy as np + + +def setup_environment(): + """Setup environment and import all dependencies""" + src_path = Path(__file__).parent.parent / "src" + sys.path.insert(0, str(src_path)) + sys.path.append(str(Path(__file__).parent)) + + try: + from iodata import load_one + from gbasis.wrappers import from_iodata + from gbasis.evals.density import evaluate_density + from grid.onedgrid import GaussChebyshev + from grid.protransform import CubicProTransform, _PromolParams, _pad_coeffs_exps_with_zeros, \ + PromolMolecule + from grid.cubic import UniformGrid + from grid.utils_promol import BFitDataProcessor + from grid.utils_promol import ELEMENT_TO_ATOMIC_NUMBER + + # Create reverse mapping dynamically + ATOMIC_NUMBER_TO_SYMBOL = {v: k for k, v in ELEMENT_TO_ATOMIC_NUMBER.items()} + + deps = { + "load_one": load_one, + "from_iodata": from_iodata, + "evaluate_density": evaluate_density, + "GaussChebyshev": GaussChebyshev, + "CubicProTransform": CubicProTransform, + "_PromolParams": _PromolParams, + "UniformGrid": UniformGrid, + "_pad_coeffs_exps_with_zeros": _pad_coeffs_exps_with_zeros, + "BFitDataProcessor": BFitDataProcessor, + "PromolMolecule": PromolMolecule, + "ATOMIC_NUMBER_TO_SYMBOL": ATOMIC_NUMBER_TO_SYMBOL, + } + print("All dependencies loaded successfully") + return deps + + except ImportError as e: + print(f"Import error: {e}") + return None + + +def get_test_systems(): + """Find all available FCHK test files""" + data_dir = Path(__file__).parent / "data" + + if not data_dir.exists() or not list(data_dir.glob("*.fchk")): + examples_dir = Path(__file__).parent.parent.parent.parent / "examples" + if examples_dir.exists(): + data_dir = examples_dir + else: + alt_examples = Path(__file__).parent.parent.parent / "examples" + if alt_examples.exists(): + data_dir = alt_examples + + if data_dir.exists(): + fchk_files = list(data_dir.glob("*.fchk")) + return [str(f) for f in fchk_files] + + return [] + + +class System: + """Molecular system data container that loads information from FCHK files""" + + def __init__(self, fchk_file, deps): + self.fchk_file = fchk_file + self._load_from_fchk(deps) + + def _load_from_fchk(self, deps): + """Load molecular information from FCHK file using iodata""" + if not os.path.exists(self.fchk_file): + raise FileNotFoundError(f"FCHK file not found: {self.fchk_file}") + + try: + # Load molecular data + mol_data = deps["load_one"](self.fchk_file) + + # Extract information + self.coords = mol_data.atcoords # Atomic coordinates + atnums = mol_data.atnums # Atomic numbers + + # Convert atomic numbers to element symbols using dynamic mapping + atomic_map = deps["ATOMIC_NUMBER_TO_SYMBOL"] + self.symbols = [atomic_map.get(num, f"Z{num}").lower() for num in atnums] + + # Calculate expected number of electrons + self.expected_electrons = int(np.sum(atnums)) + + # Extract system name from title or filename + if hasattr(mol_data, "title") and mol_data.title: + self.name = mol_data.title.strip() + else: + # Use filename without extension as fallback + self.name = Path(self.fchk_file).stem + + except Exception as e: + raise RuntimeError(f"Failed to load FCHK file {self.fchk_file}: {e}") + + def __str__(self): + return f"{self.name}: {len(self.symbols)} atoms, {self.expected_electrons} electrons" + + +def load_molecular_data(fchk_file, deps): + """Load molecular data from FCHK file""" + if not os.path.exists(fchk_file): + return None + + try: + mol_data = deps["load_one"](fchk_file) + ao_basis = deps["from_iodata"](mol_data) + rdm = mol_data.one_rdms.get("scf") if hasattr(mol_data, "one_rdms") else None + + if rdm is None: + return None + + return {"mol_data": mol_data, "ao_basis": ao_basis, "rdm": rdm} + except Exception: + return None + + +def run_uniform_grid_method(system, deps): + """Execute UniformGrid integration method""" + mol_data = load_molecular_data(system.fchk_file, deps) + if not mol_data: + return None, "Failed to load molecular data" + + try: + # Measure grid construction time + grid_start_time = time.time() + grid = deps["UniformGrid"].from_molecule( + mol_data["mol_data"].atnums, + mol_data["mol_data"].atcoords, + spacing=0.2, + extension=5.0, + rotate=True, + weight="Trapezoid", + ) + grid_construction_time = time.time() - grid_start_time + + # Measure electron density evaluation and integration time + eval_start_time = time.time() + rho = deps["evaluate_density"](mol_data["rdm"], mol_data["ao_basis"], grid.points) + electrons = grid.integrate(rho) + eval_integration_time = time.time() - eval_start_time + + total_time = grid_construction_time + eval_integration_time + rel_error = abs(electrons - system.expected_electrons) / system.expected_electrons + + return { + "electrons": electrons, + "rel_error": rel_error, + "time": total_time, + "grid_time": grid_construction_time, + "eval_time": eval_integration_time, + "points": grid.size, + }, "Success" + + except Exception as e: + return None, f"UniformGrid error: {str(e)}" + + +def run_transform_grid_method(system, bfit_data_file, deps, grid_size=20): + """Execute CubicProTransform integration method using PromolMolecule""" + mol_data = load_molecular_data(system.fchk_file, deps) + if not mol_data: + return None, "Failed to load molecular data" + + try: + # Measure grid construction time using PromolMolecule + grid_start_time = time.time() + + # Create PromolMolecule instance + promol_molecule = deps["PromolMolecule"]( + symbols=system.symbols, + coords=system.coords, + expected_electrons=system.expected_electrons, + bfit_data_file=bfit_data_file + ) + + # Create transform grid + transform = promol_molecule.create_transform_grid(grid_size=grid_size) + grid_construction_time = time.time() - grid_start_time + + # Measure electron density evaluation and integration time + eval_start_time = time.time() + rho = deps["evaluate_density"](mol_data["rdm"], mol_data["ao_basis"], transform.points) + electrons = transform.integrate(rho) + eval_integration_time = time.time() - eval_start_time + + total_time = grid_construction_time + eval_integration_time + rel_error = abs(electrons - system.expected_electrons) / system.expected_electrons + + return { + "electrons": electrons, + "rel_error": rel_error, + "time": total_time, + "grid_time": grid_construction_time, + "eval_time": eval_integration_time, + "points": transform.size, + }, "Success" + + except Exception as e: + return None, f"CubicProTransform error: {str(e)}" + + +def initialize_bfit_data_file(): + """Get BFit data file path""" + data_file = Path(__file__).parent / "data" / "result_kl_fpi_stype_only.npz" + + if not data_file.exists(): + examples_dir = Path(__file__).parent.parent.parent.parent / "examples" + if not examples_dir.exists(): + examples_dir = Path(__file__).parent.parent.parent / "examples" + + data_file = examples_dir / "result_kl_fpi_stype_only.npz" + + if not data_file.exists() and examples_dir.exists(): + npz_files = list(examples_dir.glob("*.npz")) + if npz_files: + data_file = npz_files[0] + + if data_file.exists(): + return str(data_file) + + return None + + +def test_basic_functionality(deps): + """Test basic functionality without requiring data files""" + try: + test_system = create_test_system() + return "PromolMolecule" in deps + except Exception: + return False + + +def create_test_system(): + """Create a simple test system for basic functionality testing""" + coords = np.array([[0.0, 0.0, 0.0]]) + symbols = ['h'] + expected_electrons = 1 + + class MockSystem: + def __init__(self): + self.coords = coords + self.symbols = symbols + self.expected_electrons = expected_electrons + self.name = "H_test" + self.fchk_file = None + + return MockSystem() + + +def print_results(systems, results): + """Print comparison results in tabular format""" + print(f"\n{'='*140}") + print("ELECTRON DENSITY INTEGRATION COMPARISON") + print(f"{'='*140}") + print(f"{'System':<8} {'UniformGrid':<65} {'CubicProTransform':<65}") + print( + f"{'':>6} {'Expected':<8} {'Electrons':>10} {'Error%':>8} {'Grid(s)':>8} {'Eval(s)':>8} {'Total(s)':>8} {'Points':>10} " + f"{'Electrons':>10} {'Error%':>8} {'Grid(s)':>8} {'Eval(s)':>8} {'Total(s)':>8} {'Points':>10}" + ) + print("-" * 140) + + for system in systems: + result = results.get(system.name, {}) + uniform = result.get("uniform") + transform = result.get("transform") + + # Format results + if uniform: + u_data = ( + f"{uniform['electrons']:10.3f}{uniform['rel_error']*100:8.4f}" + f"{uniform['grid_time']:8.2f}{uniform['eval_time']:8.2f}{uniform['time']:8.2f}{uniform['points']:10d}" + ) + else: + u_data = f"{'N/A':>61}" + + if transform: + t_data = ( + f"{transform['electrons']:10.3f}{transform['rel_error']*100:8.4f}" + f"{transform['grid_time']:8.2f}{transform['eval_time']:8.2f}{transform['time']:8.2f}{transform['points']:10d}" + ) + else: + t_data = f"{'N/A':>61}" + + print(f"{system.name:<8} {system.expected_electrons:<8} {u_data} {t_data}") + + +def test_grid_sizes(system, bfit_processor, deps, grid_sizes=[8, 10, 12, 15, 18, 20, 25]): + """Test CubicProTransform performance with different grid sizes""" + results = {} + + # Test each grid size by calling the existing run_transform_grid_method + for grid_size in grid_sizes: + result, status = run_transform_grid_method(system, bfit_processor, deps, grid_size) + if result is not None: # Success case + results[grid_size] = result + # Skip failed grid sizes (when result is None) + + return results + + +def print_grid_size_results(system_name, results): + """Print grid size test results in tabular format""" + print(f"\n{system_name} - Transform Grid Size Performance:") + print( + f"{'Grid':<8} {'Points':<10} {'Electrons':<10} {'Error%':<10} {'Total(s)':<8} {'Grid(s)':<8} {'Eval(s)':<8}" + ) + print("-" * 72) + + for grid_size in sorted(results.keys()): + result = results[grid_size] + print( + f"{grid_size}^3{'':<5} {result['points']:<10} {result['electrons']:<10.3f} " + f"{result['rel_error']*100:<10.4f} {result['time']:<8.3f} " + f"{result['grid_time']:<8.3f} {result['eval_time']:<8.3f}" + ) + + +def main(): + """Main function - orchestrates the complete integration comparison workflow""" + print("FIVE SYSTEMS ELECTRON DENSITY INTEGRATION TEST") + print("=" * 50) + + deps = setup_environment() + if not deps: + print("Failed to setup environment") + return + + if not test_basic_functionality(deps): + print("Basic functionality test failed. Stopping.") + return + + bfit_data_file = initialize_bfit_data_file() + if not bfit_data_file: + print("Warning: BFit data file unavailable - CubicProTransform will be skipped") + + systems_data = get_test_systems() + if not systems_data: + print("No FCHK test systems found") + return + + systems = [] + for fchk_file in systems_data: + try: + system = System(fchk_file, deps) + systems.append(system) + print(f"Loaded: {system}") + except (FileNotFoundError, RuntimeError) as e: + print(f"Skipped {fchk_file}: {e}") + + if not systems: + print("No valid systems found. Exiting.") + return + + results = {} + print(f"\nTesting {len(systems)} molecular systems...") + + for i, system in enumerate(systems, 1): + print(f"\n[{i}/{len(systems)}] {system.name}") + system_results = {} + + uniform_result, status = run_uniform_grid_method(system, deps) + if uniform_result: + system_results["uniform"] = uniform_result + print( + f" Uniform: {uniform_result['electrons']:.3f} electrons " + f"({uniform_result['rel_error']*100:.4f}% error, {uniform_result['time']:.3f}s total)" + ) + else: + print(f" Uniform: {status}") + + if bfit_data_file: + transform_result, status = run_transform_grid_method(system, bfit_data_file, deps) + if transform_result: + system_results["transform"] = transform_result + print( + f" Transform: {transform_result['electrons']:.3f} electrons " + f"({transform_result['rel_error']*100:.4f}% error, {transform_result['time']:.3f}s total)" + ) + else: + print(f" Transform: {status}") + + results[system.name] = system_results + + if results: + print_results(systems, results) + + if bfit_data_file: + print(f"\n{'='*60}") + print("TRANSFORM GRID SIZE PERFORMANCE ANALYSIS") + print(f"{'='*60}") + + for i, system in enumerate(systems, 1): + print(f"\n[{i}/{len(systems)}] Testing {system.name} grid size performance...") + grid_size_results = test_grid_sizes(system, bfit_data_file, deps) + + if grid_size_results: + print_grid_size_results(system.name, grid_size_results) + + +if __name__ == "__main__": + main() diff --git a/src/grid/tests/test_cubic.py b/src/grid/tests/test_cubic.py index 42f3f30b..64820c20 100644 --- a/src/grid/tests/test_cubic.py +++ b/src/grid/tests/test_cubic.py @@ -188,7 +188,7 @@ def test_point_and_weights_are_correct(self): assert_allclose(actual_weight, cubic.weights[index]) index += 1 - def test_interpolation_of_gaussian_vertorized(self): + def test_interpolation_of_gaussian_vectorized(self): r"""Test interpolation of a Gaussian function with vectorization.""" oned = MidPoint(50) cubic = Tensor1DGrids(oned, oned, oned) diff --git a/src/grid/tests/test_protransform.py b/src/grid/tests/test_protransform.py new file mode 100644 index 00000000..9a003798 --- /dev/null +++ b/src/grid/tests/test_protransform.py @@ -0,0 +1,744 @@ +# GRID is a numerical integration module for quantum chemistry. +# +# Copyright (C) 2011-2019 The GRID Development Team +# +# This file is part of GRID. +# +# GRID is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 3 +# of the License, or (at your option) any later version. +# +# GRID is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see +# -- +from grid.basegrid import OneDGrid +from grid.onedgrid import GaussChebyshevLobatto +from grid.protransform import ( + CubicProTransform, + _PromolParams, + _pad_coeffs_exps_with_zeros, + _transform_coordinate, +) + +import numpy as np +from numpy.testing import assert_allclose + +import pytest + +from scipy.optimize import approx_fprime +from scipy.special import erf + + +class TestTwoGaussianDiffCenters: + r"""Test a Sum of Two Gaussian function against analytic formulas and numerical procedures.""" + + def setUp(self, ss=0.1, return_obj=False, add_boundary=True): + r"""Set up a two parameter Gaussian function.""" + c = np.array([[5.0], [10.0]]) + e = np.array([[2.0], [3.0]]) + coord = np.array([[1.0, 2.0, 3.0], [2.0, 2.0, 2.0]]) + params = _PromolParams(c, e, coord, dim=3) + if return_obj: + num_pts = int(2 / ss) + 1 + weights = np.array([2.0 / (num_pts - 2)] * num_pts) + if add_boundary: + l_bnd = -1.0 + end_point = True + else: + l_bnd = -0.99 + end_point = False + oned = OneDGrid( + np.linspace(l_bnd, 1, num=num_pts, endpoint=end_point), + weights, + domain=(-1, 1), + ) + + obj = CubicProTransform( + [oned, oned, oned], + params.c_m, + params.e_m, + params.coords, + ) + return params, obj + return params + + def promolecular(self, x, y, z, params): + r"""Hard-Code the promolecular density.""" + # Promolecular in UniformProTransform class uses einsum, this tests it against that. + # Also could be used for integration tests. + cm, em, coords = params.c_m, params.e_m, params.coords + promol = 0.0 + for i, coeffs in enumerate(cm): + xc, yc, zc = coords[i] + for j, coeff in enumerate(coeffs): + distance = (x - xc) ** 2.0 + (y - yc) ** 2.0 + (z - zc) ** 2.0 + promol += np.sum(coeff * np.exp(-em[i, j] * distance)) + return promol + + def test_promolecular_density(self): + r"""Test Promolecular Density function against hard-coded.""" + grid = np.array( + [ + [-1.0, 2.0, 3.0], + [5.0, 10.0, -1.0], + [0.0, 0.0, 0.0], + [3.0, 2.0, 1.0], + [10.0, 20.0, 30.0], + [0.0, 10.0, 0.2], + ] + ) + params = self.setUp() + + true_ans = [] + for pt in grid: + x, y, z = pt + true_ans.append(self.promolecular(x, y, z, params)) + + desired = params.promolecular(grid) + assert np.all(np.abs(np.array(true_ans) - desired) < 1e-8) + + @pytest.mark.parametrize( + "pts, add_boundary", [[np.arange(-5.0, 5.0, 0.5), False], [np.arange(-5.0, 5.0, 0.5), True]] + ) + def test_transforming_x_against_formula(self, pts, add_boundary): + r"""Test transformming the X-transformation against analytic formula.""" + for pt in pts: + true_ans = _transform_coordinate([pt], 0, self.setUp(add_boundary=add_boundary)) + + def formula_transforming_x(x): + r"""Return closed form formula for transforming x coordinate.""" + first_factor = (5.0 * np.pi**1.5 / (4 * 2**0.5)) * (erf(2**0.5 * (x - 1)) + 1.0) + + sec_fac = ((10.0 * np.pi**1.5) / (6.0 * 3**0.5)) * (erf(3.0**0.5 * (x - 2)) + 1.0) + + ans = (first_factor + sec_fac) / ( + 5.0 * (np.pi / 2) ** 1.5 + 10.0 * (np.pi / 3.0) ** 1.5 + ) + return -1.0 + 2.0 * ans + + assert np.abs(true_ans - formula_transforming_x(pt)) < 1e-8 + + @pytest.mark.parametrize( + "pts_xy, add_boundary", + [ + [np.random.uniform(-10.0, 10.0, size=(100, 2)), False], + [np.random.uniform(-10.0, 10.0, size=(100, 2)), True], + ], + ) + def test_transforming_y_against_formula(self, pts_xy, add_boundary): + r"""Test transforming the Y-transformation against analytic formula.""" + for x, y in pts_xy: + true_ans = _transform_coordinate([x, y], 1, self.setUp(add_boundary=add_boundary)) + + def formula_transforming_y(x, y): + r"""Return closed form formula for transforming y coordinate.""" + fac1 = 5.0 * np.sqrt(np.pi / 2.0) * np.exp(-2.0 * (x - 1) ** 2) + fac1 *= np.sqrt(np.pi) * (erf(2.0**0.5 * (y - 2)) + 1.0) / (2.0 * np.sqrt(2.0)) + fac2 = 10.0 * np.sqrt(np.pi / 3.0) * np.exp(-3.0 * (x - 2.0) ** 2.0) + fac2 *= np.sqrt(np.pi) * (erf(3.0**0.5 * (y - 2)) + 1.0) / (2.0 * np.sqrt(3.0)) + num = fac1 + fac2 + + dac1 = 5.0 * (np.pi / 2.0) * np.exp(-2.0 * (x - 1.0) ** 2.0) + dac2 = 10.0 * (np.pi / 3.0) * np.exp(-3.0 * (x - 2.0) ** 2.0) + den = dac1 + dac2 + return -1.0 + 2.0 * (num / den) + + assert np.abs(true_ans - formula_transforming_y(x, y)) < 1e-8 + + @pytest.mark.parametrize( + "pts, add_boundary", + [ + [np.random.uniform(-10.0, 10.0, size=(100, 3)), False], + [np.random.uniform(-10.0, 10.0, size=(100, 3)), True], + ], + ) + def test_transforming_z_against_formula(self, pts, add_boundary): + r"""Test transforming the Z-transformation against analytic formula.""" + params, obj = self.setUp(ss=0.5, return_obj=True, add_boundary=add_boundary) + + def formula_transforming_z(x, y, z): + r"""Return closed form formula for transforming z coordinate.""" + a1, a2, a3 = (x - 1.0), (y - 2.0), (z - 3.0) + erfx = erf(2.0**0.5 * a3) + 1.0 + fac1 = 5.0 * np.exp(-2.0 * (a1**2.0 + a2**2.0)) * erfx * np.pi**0.5 / (2.0 * 2.0**0.5) + b1, b2, b3 = (x - 2.0), (y - 2.0), (z - 2.0) + erfy = erf(3.0**0.5 * b3) + 1.0 + fac2 = 10.0 * np.exp(-3.0 * (b1**2.0 + b2**2.0)) * erfy * np.pi**0.5 / (2.0 * 3.0**0.5) + den = 5.0 * (np.pi / 2.0) ** 0.5 * np.exp(-2.0 * (a1**2.0 + a2**2.0)) + den += 10.0 * (np.pi / 3.0) ** 0.5 * np.exp(-3.0 * (b1**2.0 + b2**2.0)) + return -1.0 + 2.0 * (fac1 + fac2) / den + + for x, y, z in pts: + true_ans = formula_transforming_z(x, y, z) + # Test function + actual = _transform_coordinate([x, y, z], 2, params) + assert np.abs(true_ans - actual) < 1e-8 + + # Test Method + actual = obj.transform(np.array([x, y, z]))[2] + assert np.abs(true_ans - actual) < 1e-8 + + def test_transforming_simple_grid(self): + r"""Test transforming a grid that only contains one non-boundary point.""" + ss = 1.0 + params, obj = self.setUp(ss, return_obj=True) + num_pt = int(2.0 / ss) + 1 # number of points in one-direction. + assert obj.points.shape == (num_pt**3, 3) + non_boundary_pt_index = num_pt**2 + num_pt + 1 + real_pt = obj.points[non_boundary_pt_index] + # Test that this point is not the boundary. + assert real_pt[0] != np.inf + assert real_pt[1] != np.inf + assert real_pt[2] != np.inf + # Test that converting the point back to unit cube gives [0.5, 0.5, 0.5]. + for i_var in range(0, 3): + transf = _transform_coordinate(real_pt, i_var, obj.promol) + assert np.abs(transf) < 1e-5 + # Test that all other points are indeed boundary points. + all_nans = np.delete(obj.points, non_boundary_pt_index, axis=0) + assert np.all(np.any(np.isinf(all_nans), axis=1)) + + def test_transforming_with_inverse_transformation_is_identity(self): + r"""Test transforming with inverse transformation is identity.""" + # Note that for points far away from the promolecular gets mapped to nan. + # So this isn't really the inverse, in the mathematical sense. + param, obj = self.setUp(0.5, return_obj=True) + + pt = np.array([1, 2, 3], dtype=np.float64) + transf = obj.transform(pt) + reverse = obj.inverse(transf) + assert np.all(np.abs(reverse - pt) < 1e-10) + + def test_integrating_itself(self): + r"""Test integrating the very same promolecular density used for transformation.""" + params, obj = self.setUp(ss=0.2, return_obj=True) + promol = [] + for pt in obj.points: + promol.append(self.promolecular(pt[0], pt[1], pt[2], params)) + promol = np.array(promol, dtype=np.float64) + desired = obj.prointegral + actual = obj.integrate(promol) + assert np.abs(actual - desired) < 1e-8 + + actual = obj.integrate(promol, trick=True) + assert np.abs(actual - desired) < 1e-8 + + @pytest.mark.parametrize("pts", [np.arange(-5.0, 5.0, 0.75)]) + def test_derivative_tranformation_x_finite_difference(self, pts): + r"""Test the derivative of X-transformation against finite-difference.""" + params, obj = self.setUp(ss=0.2, return_obj=True) + for pt in pts: + pt = np.array([pt, 2.0, 3.0]) + + actual = obj.jacobian(pt) + + def tranformation_x(pt): + return _transform_coordinate(pt, 0, params) + + grad = approx_fprime([pt[0]], tranformation_x, 1e-6) + assert np.abs(grad - actual[0, 0]) < 1e-4 + + @pytest.mark.parametrize("pts_xy", [np.random.uniform(-5.0, 5.0, size=(100, 2))]) + def test_derivative_tranformation_y_finite_difference(self, pts_xy): + r"""Test the derivative of Y-transformation against finite-difference.""" + params, obj = self.setUp(ss=0.2, return_obj=True) + for x, y in pts_xy: + actual = obj.jacobian(np.array([x, y, 3.0])) + + def tranformation_y(pt): + return _transform_coordinate([x, pt[0]], 1, params) + + grad = approx_fprime([y], tranformation_y, 1e-8) + assert np.abs(grad - actual[1, 1]) < 1e-5 + + def transformation_y_wrt_x(pt): + return _transform_coordinate([pt[0], y], 1, params) + + h = 1e-8 + deriv = np.imag(transformation_y_wrt_x([complex(x, h)])) / h + assert np.abs(deriv - actual[1, 0]) < 1e-4 + + @pytest.mark.parametrize("pts", [np.random.uniform(-3.0, 3.0, size=(100, 3))]) + def test_derivative_tranformation_z_finite_difference(self, pts): + r"""Test the derivative of Z-transformation against finite-difference.""" + params, obj = self.setUp(ss=0.2, return_obj=True) + for x, y, z in pts: + actual = obj.jacobian(np.array([x, y, z])) + + def tranformation_z(pt): + return _transform_coordinate([x, y, pt[0]], 2, params) + + grad = approx_fprime([z], tranformation_z, 1e-8) + assert np.abs(grad - actual[2, 2]) < 1e-5 + + def transformation_z_wrt_y(pt): + return _transform_coordinate([x, pt[0], z], 2, params) + + deriv = approx_fprime([y], transformation_z_wrt_y, 1e-8) + assert np.abs(deriv - actual[2, 1]) < 1e-4 + + def transformation_z_wrt_x(pt): + a = _transform_coordinate([pt[0], y, z], 2, params) + return a + + h = 1e-8 + deriv = np.imag(transformation_z_wrt_x([complex(x, h)])) / h + + assert np.abs(deriv - actual[2, 0]) < 1e-4 + + @pytest.mark.parametrize("pts", [np.random.uniform(-3.0, 3.0, size=(100, 3))]) + def test_steepest_ascent_direction_with_numerics(self, pts): + r"""Test steepest-ascent direction match in real and theta space. + + The function to test is x^2 + y^2 + z^2. + """ + params, obj = self.setUp(ss=0.2, return_obj=True) + + def grad(pt): + # Gradient of x^2 + y^2 + z^2. + return np.array([2.0 * pt[0], 2.0 * pt[1], 2.0 * pt[2]]) + + for x, y, z in pts: + # Take a step in real-space. + pt = np.array([x, y, z]) + grad_pt = grad(pt) + step = 1e-8 + pt_step = pt + grad_pt * step + + # Convert the steps in theta space and calculate finite-difference gradient. + transf = obj.transform(pt) + transf_step = obj.transform(pt_step) + grad_finite = (transf_step - transf) / step + + # Test the actual actual. + actual = obj.steepest_ascent_theta(pt, grad_pt) + assert np.all(np.abs(actual - grad_finite) < 1e-4) + + def test_second_derivative_of_theta_x_dx(self): + r"""Test the second derivative of d(theta_x)/d(x) .""" + params, obj = self.setUp(ss=0.2, return_obj=True) + x, y, z = 0.0, 0.0, 0.0 + actual = obj.hessian(np.array([x, y, z])) + + # test second derivative of theta_x wrt to dx dx. + def tranformation_x(pt): + return obj.jacobian([pt[0], y, z])[0, 0] + + dthetax_dx_dx = approx_fprime([x], tranformation_x, 1e-8) + assert np.abs(dthetax_dx_dx - actual[0, 0, 0]) < 1e-5 + # Since theta_x only depends on x, then all other elements + # are zero. + for i in range(0, 3): + for j in range(0, 3): + if i != j: + assert np.abs(actual[0, i, j]) < 1e-10 + + @pytest.mark.parametrize("pts", [np.random.uniform(-3.0, 3.0, size=(100, 3))]) + def test_second_derivative_of_theta_y(self, pts): + r"""Test the second derivative of d(theta_y).""" + params, obj = self.setUp(ss=0.2, return_obj=True) + for x, y, z in pts: + actual = obj.hessian(np.array([x, y, z])) + + # test second derivative of theta_y wrt to dy dy. + def dtheta_y_dy(pt): + return obj.jacobian([x, pt[0], z])[1, 1] + + dthetay_dy_dy = approx_fprime([y], dtheta_y_dy, 1e-8) + assert np.abs(dthetay_dy_dy - actual[1, 1, 1]) < 1e-5 + + # test second derivative of d(theta_y)/d(y) wrt dx. + def dtheta_y_dy(pt): + return obj.jacobian([pt[0], y, z])[1, 1] + + dthetay_dy_dx = approx_fprime([x], dtheta_y_dy, 1e-8) + assert np.abs(dthetay_dy_dx - actual[1, 1, 0]) < 1e-5 + + # test second derivative of d(theta_y)/(dx) wrt dy + def dtheta_y_dx(pt): + return obj.jacobian([x, pt[0], z])[1, 0] + + dtheta_y_dx_dy = approx_fprime([y], dtheta_y_dx, 1e-8) + assert np.abs(dtheta_y_dx_dy - actual[1, 0, 1]) < 1e-4 + + # test second derivative of d(theta_y)/(dx) wrt dx + def dtheta_y_dx(pt): + return obj.jacobian([pt[0], y, z])[1, 0] + + dtheta_y_dx_dx = approx_fprime([x], dtheta_y_dx, 1e-8) + assert np.abs(dtheta_y_dx_dx - actual[1, 0, 0]) < 1e-5 + + # Test other elements are all zeros. + for i in range(0, 3): + assert np.abs(actual[1, 2, i]) < 1e-10 + assert np.abs(actual[1, 0, 2]) < 1e-10 + assert np.abs(actual[1, 1, 2]) < 1e-10 + + @pytest.mark.parametrize("pts", [np.random.uniform(-3.0, 3.0, size=(100, 3))]) + def test_second_derivative_of_theta_z(self, pts): + r"""Test the second derivative of d(theta_z).""" + params, obj = self.setUp(ss=0.2, return_obj=True) + for x, y, z in pts: + actual = obj.hessian(np.array([x, y, z])) + + # test second derivative of theta_z wrt to dz dz. + def dtheta_z_dz(pt): + return obj.jacobian([x, y, pt[0]])[2, 2] + + dthetaz_dz_dz = approx_fprime([z], dtheta_z_dz, 1e-8) + assert np.abs(dthetaz_dz_dz - actual[2, 2, 2]) < 1e-5 + + # test second derivative of theta_z wrt to dz dy. + def dtheta_z_dz(pt): + return obj.jacobian([x, pt[0], z])[2, 2] + + dthetaz_dz_dy = approx_fprime([y], dtheta_z_dz, 1e-8) + assert np.abs(dthetaz_dz_dy - actual[2, 2, 1]) < 1e-5 + + # test second derivative of theta_z wrt to dz dx. + def dtheta_z_dz(pt): + return obj.jacobian([pt[0], y, z])[2, 2] + + dthetaz_dz_dx = approx_fprime([x], dtheta_z_dz, 1e-8) + assert np.abs(dthetaz_dz_dx - actual[2, 2, 0]) < 1e-5 + + # test second derivative of theta_z wrt to dy dz. + def dtheta_z_dy(pt): + return obj.jacobian([x, y, pt[0]])[2, 1] + + dthetaz_dy_dz = approx_fprime([z], dtheta_z_dy, 1e-8) + assert np.abs(dthetaz_dy_dz - actual[2, 1, 2]) < 1e-5 + + # test second derivative of theta_z wrt to dy dy. + def dtheta_z_dy(pt): + return obj.jacobian([x, pt[0], z])[2, 1] + + dthetaz_dy_dy = approx_fprime([y], dtheta_z_dy, 1e-8) + assert np.abs(dthetaz_dy_dy - actual[2, 1, 1]) < 1e-5 + + # test second derivative of theta_z wrt to dy dx. + def dtheta_z_dy(pt): + return obj.jacobian([pt[0], y, z])[2, 1] + + dthetaz_dy_dx = approx_fprime([x], dtheta_z_dy, 1e-8) + assert np.abs(dthetaz_dy_dx - actual[2, 1, 0]) < 1e-5 + + # test second derivative of theta_z wrt to dx dz. + def dtheta_z_dx(pt): + return obj.jacobian([x, y, pt[0]])[2, 0] + + dthetaz_dx_dz = approx_fprime([z], dtheta_z_dx, 1e-8) + assert np.abs(dthetaz_dx_dz - actual[2, 0, 2]) < 1e-5 + + # test second derivative of theta_z wrt to dx dy. + def dtheta_z_dx(pt): + return obj.jacobian([x, pt[0], z])[2, 0] + + dthetaz_dx_dy = approx_fprime([y], dtheta_z_dx, 1e-8) + assert np.abs(dthetaz_dx_dy - actual[2, 0, 1]) < 1e-5 + + # test second derivative of theta_z wrt to dx dx. + def dtheta_z_dx(pt): + return obj.jacobian([pt[0], y, z])[2, 0] + + dthetaz_dx_dx = approx_fprime([x], dtheta_z_dx, 1e-8) + assert np.abs(dthetaz_dx_dx - actual[2, 0, 0]) < 1e-5 + + +class TestOneGaussianAgainstNumerics: + r"""Tests With Numerical Integration of a One Gaussian function.""" + + def setUp(self, ss=0.1, return_obj=False): + r"""Return a one Gaussian example and its UniformProTransform object.""" + c = np.array([[5.0]]) + e = np.array([[2.0]]) + coord = np.array([[1.0, 2.0, 3.0]]) + params = _PromolParams(c, e, coord, dim=3) + if return_obj: + num_pts = int(1 / ss) + 1 + weights = np.array([2.0 / (num_pts - 2)] * num_pts) + oned_x = OneDGrid( + np.linspace(-1, 1, num=num_pts, endpoint=True), weights, domain=(-1, 1) + ) + + obj = CubicProTransform([oned_x, oned_x, oned_x], params.c_m, params.e_m, params.coords) + return params, obj + return params + + @pytest.mark.parametrize("pts", [np.arange(-5.0, 5.0, 0.5)]) + def test_transforming_x_against_numerics(self, pts): + r"""Test transforming X against numerical algorithms.""" + for pt in pts: + true_ans = _transform_coordinate([pt], 0, self.setUp()) + + def promolecular_in_x(grid, every_grid): + r"""Construct the formula of promolecular for integration.""" + promol_x = 5.0 * np.exp(-2.0 * (grid - 1.0) ** 2.0) + promol_x_all = 5.0 * np.exp(-2.0 * (every_grid - 1.0) ** 2.0) + return promol_x, promol_x_all + + grid = np.arange(-4.0, pt, 0.000005) # Integration till a x point + every_grid = np.arange(-5.0, 10.0, 0.00001) # Full Integration + promol_x, promol_x_all = promolecular_in_x(grid, every_grid) + + # Integration over y and z cancel out from numerator and denominator. + actual = -1.0 + 2.0 * np.trapz(promol_x, grid) / np.trapz(promol_x_all, every_grid) + assert np.abs(true_ans - actual) < 1e-5 + + @pytest.mark.parametrize("pts_xy", [np.random.uniform(-10.0, 10.0, size=(100, 2))]) + def test_transforming_y_against_numerics(self, pts_xy): + r"""Test transformation y against numerical algorithms.""" + + def promolecular_in_y(grid, every_grid): + r"""Construct the formula of promolecular for integration.""" + promol_y = 5.0 * np.exp(-2.0 * (grid - 2.0) ** 2.0) + promol_y_all = 5.0 * np.exp(-2.0 * (every_grid - 2.0) ** 2.0) + return promol_y_all, promol_y + + for x, y in pts_xy: + true_ans = _transform_coordinate([x, y], 1, self.setUp()) + + grid = np.arange(-5.0, y, 0.000001) # Integration till a x point + every_grid = np.arange(-5.0, 10.0, 0.00001) # Full Integration + promol_y_all, promol_y = promolecular_in_y(grid, every_grid) + + # Integration over z cancel out from numerator and denominator. + # Further, gaussian at a point does too. + actual = -1.0 + 2.0 * np.trapz(promol_y, grid) / np.trapz(promol_y_all, every_grid) + assert np.abs(true_ans - actual) < 1e-5 + + @pytest.mark.parametrize("pts", [np.random.uniform(-10.0, 10.0, size=(100, 3))]) + def test_transforming_z_against_numerics(self, pts): + r"""Test transforming Z against numerical algorithms.""" + + def promolecular_in_z(grid, every_grid): + r"""Construct the formula of promolecular for integration.""" + promol_z = 5.0 * np.exp(-2.0 * (grid - 3.0) ** 2.0) + promol_z_all = 5.0 * np.exp(-2.0 * (every_grid - 3.0) ** 2.0) + return promol_z_all, promol_z + + for x, y, z in pts: + grid = np.arange(-5.0, z, 0.00001) # Integration till a x point + + every_grid = np.arange(-5.0, 10.0, 0.00001) # Full Integration + promol_z_all, promol_z = promolecular_in_z(grid, every_grid) + + actual = -1.0 + 2.0 * np.trapz(promol_z, grid) / np.trapz(promol_z_all, every_grid) + true_ans = _transform_coordinate([x, y, z], 2, self.setUp()) + assert np.abs(true_ans - actual) < 1e-4 + + @pytest.mark.parametrize("pts", [np.random.uniform(-3.0, 3.0, size=(100, 3))]) + def test_jacobian(self, pts): + r"""Test that the jacobian of the transformation.""" + params, obj = self.setUp(ss=0.2, return_obj=True) + for x, y, z in pts: + actual = obj.jacobian(np.array([x, y, z])) + + # assert lower-triangular component is zero. + assert np.abs(actual[1, 0]) < 1e-5 + assert np.abs(actual[2, 0]) < 1e-5 + assert np.abs(actual[2, 1]) < 1e-5 + + # test derivative wrt to x + def tranformation_x(pt): + return _transform_coordinate([pt[0], y, z], 0, params) + + grad = approx_fprime([x], tranformation_x, 1e-8) + assert np.abs(grad - actual[0, 0]) < 1e-5 + + # test derivative wrt to y + def tranformation_y(pt): + return _transform_coordinate([x, pt[0]], 1, params) + + grad = approx_fprime([y], tranformation_y, 1e-8) + assert np.abs(grad - actual[1, 1]) < 1e-5 + + # Test derivative wrt to z + def tranformation_z(pt): + return _transform_coordinate([x, y, pt[0]], 2, params) + + grad = approx_fprime([z], tranformation_z, 1e-8) + assert np.abs(grad - actual[2, 2]) < 1e-5 + + +class TestInterpolation: + r"""Test Interpolation Methods and Cubic Grid Utility Functions.""" + + def setUp(self, ss=0.1): + r"""Set up a simple one Gaussian function with uniform cubic grid.""" + c = np.array([[5.0]]) + e = np.array([[2.0]]) + coord = np.array([[1.0, 2.0, 3.0]]) + params = _PromolParams(c, e, coord, dim=3) + + num_pts = int(2 / ss) + 1 + weights = np.array([2.0 / (num_pts - 2)] * num_pts) + oned_x = OneDGrid( + np.linspace(-1.0, 1.0, num=num_pts, endpoint=True), weights, domain=(-1, 1) + ) + + obj = CubicProTransform([oned_x, oned_x, oned_x], params.c_m, params.e_m, params.coords) + return params, obj, [oned_x, oned_x, oned_x] + + def test_interpolate_cubic_function(self): + r"""Interpolate a cubic function.""" + param, obj, oned_grids = self.setUp(ss=0.08) + + # Function to interpolate. + def func(pts): + return (pts[:, 0] - 1.0) ** 3.0 + (pts[:, 1] - 2.0) ** 3.0 + (pts[:, 2] - 3.0) ** 3.0 + + # Test over a grid that is very close to the nucleus. + grid = np.vstack( + ( + np.random.uniform(1.0, 1.5, (100,)).T, + np.random.uniform(1.5, 2.5, (100,)).T, + np.random.uniform(2.5, 3.5, (100,)).T, + ) + ).T + actuals = obj.interpolate(grid, func(obj.points), oned_grids, use_log=False) + desired = func(grid) + assert_allclose(desired, actuals, atol=1e-3, rtol=1e-4) + + def test_interpolate_gaussian(self): + r"""Interpolate a Gaussian function with use_log set to True.""" + param, obj, oned_grids = self.setUp(ss=0.08) + + # Function to interpolate. + def func(pts, alpha=2.0): + return np.exp(-alpha * np.linalg.norm(pts - param.coords[0], axis=1) ** 2.0) + + # Test over a grid. Pytest isn't used for effiency reasons. + # TODO: the grid points need to be close to center to achieve good accuracy. + real_grid = np.vstack( + ( + np.random.uniform(0.75, 1.25, (100,)).T, + np.random.uniform(0.75, 2.25, (100,)).T, + np.random.uniform(3.75, 3.25, (100,)).T, + ) + ).T + actuals = obj.interpolate(real_grid, func(obj.points), oned_grids, use_log=True) + desired = func(real_grid) + assert_allclose(desired, actuals, atol=1e-1) + + def test_interpolate_derivative_cubic_function(self): + r"""Interpolate the derivative of some simple function.""" + param, obj, oned_grids = self.setUp(ss=0.08) + + # Function to interpolate. + def func(pts): + return (pts[:, 0] - 1.0) * (pts[:, 1] - 2.0) * (pts[:, 2] - 3.0) + + def derivative(pts): + return np.vstack( + [ + (pts[:, 1] - 2.0) * (pts[:, 2] - 3.0), + (pts[:, 0] - 1.0) * (pts[:, 2] - 3.0), + (pts[:, 0] - 1.0) * (pts[:, 1] - 2.0), + ] + ).T + + # Test over a grid. Pytest isn't used for effiency reasons. + grid = np.vstack( + ( + np.random.uniform(1.0, 1.5, (100,)).T, + np.random.uniform(1.5, 2.5, (100,)).T, + np.random.uniform(2.5, 3.5, (100,)).T, + ) + ).T + actual = obj.interpolate(grid, func(obj.points), oned_grids, nu=1) + desired = derivative(grid) + assert_allclose(actual, desired, atol=1e-2) + + def test_interpolate_derivative_cubic_function2(self): + r"""Interpolate the derivative of some simple function.""" + param, obj, oned_grids = self.setUp(ss=0.08) + + # Function to interpolate. + def func(pts): + return (pts[:, 0] - 1.0) ** 2.0 * (pts[:, 1] - 2.0) ** 2.0 * (pts[:, 2] - 3.0) ** 2.0 + + def derivative(pts): + x, y, z = pts[:, 0], pts[:, 1], pts[:, 2] + return np.vstack( + [ + 2.0 * (x - 1.0) * (y - 2.0) ** 2.0 * (z - 3.0) ** 2.0, + 2.0 * (x - 1.0) ** 2.0 * (y - 2.0) * (z - 3.0) ** 2.0, + 2.0 * (x - 1.0) ** 2.0 * (y - 2.0) ** 2.0 * (z - 3.0), + ] + ).T + + # Test over a grid. Pytest isn't used for effiency reasons. + grid = np.vstack( + ( + np.random.uniform(1.0, 1.5, (100,)).T, + np.random.uniform(1.5, 2.5, (100,)).T, + np.random.uniform(2.5, 3.5, (100,)).T, + ) + ).T + actual = obj.interpolate(grid, func(obj.points), oned_grids, nu=1, use_log=False) + desired = derivative(grid) + assert_allclose(actual, desired, atol=1e-2) + # Test with logarithm set to True + actual = obj.interpolate(grid, func(obj.points), oned_grids, nu=1, use_log=True) + assert_allclose(actual, desired, atol=1e-2) + + +class TestIntegration: + r""" + Only one integration test as of this moment. + + Choose to make it, it's own seperate class since many choices of oned grid is possible. + + """ + + def setUp_one_gaussian(self, ss=0.03): + r"""Return a one Gaussian example and its UniformProTransform object.""" + c = np.array([[5.0]]) + e = np.array([[2.0]]) + coord = np.array([[1.0, 2.0, 3.0]]) + params = _PromolParams(c, e, coord, dim=3) + num_pts = int(1 / ss) + 1 + oned_x = GaussChebyshevLobatto(num_pts) + obj = CubicProTransform([oned_x, oned_x, oned_x], params.c_m, params.e_m, params.coords) + return params, obj + + def test_integration_perturbed_gaussian_with_promolecular_trick(self): + r"""Test integration of a slightly perturbed function.""" + # Only Measured against one decimal place and very similar exponent. + _, obj = self.setUp_one_gaussian(ss=0.03) + + # Gaussian exponent is slightly perturbed from 2. + exponent = 2.01 + + def gaussian(grid): + return 5.0 * np.exp( + -exponent * np.sum((grid - np.array([1.0, 2.0, 3.0])) ** 2.0, axis=1) + ) + + func_vals = gaussian(obj.points) + desired = 5.0 * np.sqrt(np.pi / exponent) ** 3.0 + actual = obj.integrate(func_vals, trick=True) + + assert np.abs(actual - desired) < 1e-3 + + +def test_padding_arrays(): + r"""Test different array sizes are correctly padded.""" + coeff = np.array([[1.0, 2.0], [1.0, 2.0, 3.0, 4.0], [5.0]], dtype=object) + exps = np.array([[4.0, 5.0], [5.0, 6.0, 7.0, 8.0], [9.0]], dtype=object) + coeff_pad, exps_pad = _pad_coeffs_exps_with_zeros(coeff, exps) + coeff_desired = np.array( + [[1.0, 2.0, 0.0, 0.0], [1.0, 2.0, 3.0, 4.0], [5.0, 0.0, 0.0, 0.0]], dtype=object + ) + np.testing.assert_array_equal(coeff_desired, coeff_pad) + exp_desired = np.array( + [[4.0, 5.0, 0.0, 0.0], [5.0, 6.0, 7.0, 8.0], [9.0, 0.0, 0.0, 0.0]], dtype=object + ) + np.testing.assert_array_equal(exp_desired, exps_pad) diff --git a/src/grid/utils_promol.py b/src/grid/utils_promol.py new file mode 100644 index 00000000..ea3cf00a --- /dev/null +++ b/src/grid/utils_promol.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +""" +BFit Data Processor + +Processes promolecular coefficients and exponents from theochem/BFit +data files for integration with CubicProTransform in Grid library. + +Note: This version handles s-type orbital data. +""" + +import sys +from pathlib import Path +from dataclasses import dataclass +from typing import Dict, Optional + +import numpy as np + +sys.path.insert(0, str(Path(__file__).parent.parent / "src")) + +# Element symbol to atomic number mapping +ELEMENT_TO_ATOMIC_NUMBER = { + "h": 1, + "he": 2, + "li": 3, + "be": 4, + "b": 5, + "c": 6, + "n": 7, + "o": 8, + "f": 9, + "ne": 10, + "na": 11, + "mg": 12, + "al": 13, + "si": 14, + "p": 15, + "s": 16, + "cl": 17, + "ar": 18, + "k": 19, + "ca": 20, + "sc": 21, + "ti": 22, + "v": 23, + "cr": 24, + "mn": 25, + "fe": 26, + "co": 27, + "ni": 28, + "cu": 29, + "zn": 30, + "ga": 31, + "ge": 32, + "as": 33, + "se": 34, + "br": 35, + "kr": 36, + "rb": 37, + "sr": 38, + "y": 39, + "zr": 40, + "nb": 41, + "mo": 42, + "tc": 43, + "ru": 44, + "rh": 45, + "pd": 46, + "ag": 47, + "cd": 48, + "in": 49, + "sn": 50, + "sb": 51, + "te": 52, + "i": 53, + "xe": 54, +} + + +@dataclass +class BFitElementData: + """Store BFit s-type orbital data for a single element""" + + symbol: str + atomic_number: int + coeffs_s: np.ndarray # S-type coefficients + exps_s: np.ndarray # S-type exponents + num_s: int = 0 + # TODO: P-types spherical Gaussians should be supported later. + + +class BFitDataProcessor: + """Process BFit data and convert to Grid library format""" + + def __init__(self, data_file: Path): + self.data_file = data_file + self.raw_data: Optional[np.lib.npyio.NpzFile] = None + self.element_data: Dict[str, BFitElementData] = {} + + def load_bfit_data(self) -> bool: + """Load BFit data file""" + try: + self.raw_data = np.load(self.data_file) + return True + except Exception as e: + print(f"Failed to load data file: {e}") + return False + + def parse_element_data(self) -> Dict[str, BFitElementData]: + """Parse element data from BFit file""" + if self.raw_data is None: + print("Data not loaded, call load_bfit_data() first") + return {} + + # Get all elements with coefficients + element_symbols = set() + for key in self.raw_data.files: + if "_coeffs_s" in key: + symbol = key.replace("_coeffs_s", "") + element_symbols.add(symbol) + + for symbol in element_symbols: + try: + coeffs_key = f"{symbol}_coeffs_s" + exps_key = f"{symbol}_exps_s" + + if coeffs_key not in self.raw_data or exps_key not in self.raw_data: + print(f"Missing coefficient or exponent data for element {symbol}") + continue + + coeffs = self.raw_data[coeffs_key] + exps = self.raw_data[exps_key] + atomic_number = ELEMENT_TO_ATOMIC_NUMBER.get(symbol, 0) + + element_data = BFitElementData( + symbol=symbol, + atomic_number=atomic_number, + coeffs_s=coeffs, + exps_s=exps, + num_s=len(coeffs), + ) + + self.element_data[symbol] = element_data + + except Exception as e: + print(f"Error parsing element {symbol}: {e}") + + return self.element_data + + def create_promol_params(self, symbols, coords, deps): + """Create promolecular parameters from BFit data + + Args: + symbols: List of element symbols + coords: Array of atomic coordinates + deps: Dictionary containing dependencies (_PromolParams, _pad_coeffs_exps_with_zeros) + + Returns: + _PromolParams object + """ + all_coeffs, all_exps, all_coords = [], [], [] + + for i, symbol in enumerate(symbols): + element_data = self.element_data[symbol.lower()] + valid_mask = np.abs(element_data.coeffs_s) > 1e-12 + if np.any(valid_mask): + all_coeffs.append(element_data.coeffs_s[valid_mask]) + all_exps.append(element_data.exps_s[valid_mask]) + all_coeffs[-1] *= np.sqrt(all_exps[-1] / np.pi) ** 3 + all_coords.append(coords[i]) + + coeffs_padded, exps_padded = deps["_pad_coeffs_exps_with_zeros"](all_coeffs, all_exps) + return deps["_PromolParams"]( + c_m=coeffs_padded, e_m=exps_padded, coords=np.array(all_coords), dim=3 + )