diff --git a/examples/Nested_Angluar_Grid.ipynb b/examples/Nested_Angluar_Grid.ipynb new file mode 100644 index 00000000..8ade805f --- /dev/null +++ b/examples/Nested_Angluar_Grid.ipynb @@ -0,0 +1,1149 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Nested Angular Grid Example\n", + "This notebook demonstrates how to create and use a nested angular grid for numerical integration in quantum chemistry calculations.\n" + ], + "id": "c534bb221a9c80a" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:54.943756661Z", + "start_time": "2025-04-08T02:07:36.010361983Z" + } + }, + "cell_type": "code", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/theochem/grid.git\r\n", + " Cloning https://github.com/theochem/grid.git to /tmp/pip-req-build-0h9qe9yu\r\n", + " Running command git clone --filter=blob:none --quiet https://github.com/theochem/grid.git /tmp/pip-req-build-0h9qe9yu\r\n", + " Resolved https://github.com/theochem/grid.git to commit 834ecaa21d49e1ee7fe814a86c9b8aa294bed0cf\r\n", + " Installing build dependencies ... \u001B[?25ldone\r\n", + "\u001B[?25h Getting requirements to build wheel ... \u001B[?25ldone\r\n", + "\u001B[?25h Preparing metadata (pyproject.toml) ... \u001B[?25ldone\r\n", + "\u001B[?25hRequirement already satisfied: numpy>=1.16 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-grid==0.0.10.dev33+g834ecaa) (1.26.3)\r\n", + "Requirement already satisfied: pytest>=8.0.0 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-grid==0.0.10.dev33+g834ecaa) (8.3.5)\r\n", + "Requirement already satisfied: scipy>=1.4 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-grid==0.0.10.dev33+g834ecaa) (1.12.0)\r\n", + "Requirement already satisfied: importlib_resources in $HOME/miniconda3/lib/python3.11/site-packages (from qc-grid==0.0.10.dev33+g834ecaa) (6.5.2)\r\n", + "Requirement already satisfied: sympy in $HOME/miniconda3/lib/python3.11/site-packages (from qc-grid==0.0.10.dev33+g834ecaa) (1.12)\r\n", + "Requirement already satisfied: iniconfig in $HOME/miniconda3/lib/python3.11/site-packages (from pytest>=8.0.0->qc-grid==0.0.10.dev33+g834ecaa) (2.1.0)\r\n", + "Requirement already satisfied: packaging in $HOME/miniconda3/lib/python3.11/site-packages (from pytest>=8.0.0->qc-grid==0.0.10.dev33+g834ecaa) (23.1)\r\n", + "Requirement already satisfied: pluggy<2,>=1.5 in $HOME/miniconda3/lib/python3.11/site-packages (from pytest>=8.0.0->qc-grid==0.0.10.dev33+g834ecaa) (1.5.0)\r\n", + "Requirement already satisfied: mpmath>=0.19 in $HOME/miniconda3/lib/python3.11/site-packages (from sympy->qc-grid==0.0.10.dev33+g834ecaa) (1.3.0)\r\n", + "Requirement already satisfied: qc-AtomDB in $HOME/miniconda3/lib/python3.11/site-packages (0.0.2.post5)\r\n", + "Requirement already satisfied: numpy>=1.16 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-AtomDB) (1.26.3)\r\n", + "Requirement already satisfied: scipy>=1.4 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-AtomDB) (1.12.0)\r\n", + "Requirement already satisfied: msgpack>=1.0.0 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-AtomDB) (1.1.0)\r\n", + "Requirement already satisfied: msgpack-numpy>=0.4.8 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-AtomDB) (0.4.8)\r\n", + "Requirement already satisfied: h5py>=3.6.0 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-AtomDB) (3.10.0)\r\n", + "Requirement already satisfied: importlib-resources>=3.0.0 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-AtomDB) (6.5.2)\r\n", + "Requirement already satisfied: pooch>=1.8.1 in $HOME/miniconda3/lib/python3.11/site-packages (from qc-AtomDB) (1.8.2)\r\n", + "Requirement already satisfied: platformdirs>=2.5.0 in $HOME/miniconda3/lib/python3.11/site-packages (from pooch>=1.8.1->qc-AtomDB) (4.1.0)\r\n", + "Requirement already satisfied: packaging>=20.0 in $HOME/miniconda3/lib/python3.11/site-packages (from pooch>=1.8.1->qc-AtomDB) (23.1)\r\n", + "Requirement already satisfied: requests>=2.19.0 in $HOME/miniconda3/lib/python3.11/site-packages (from pooch>=1.8.1->qc-AtomDB) (2.31.0)\r\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in $HOME/miniconda3/lib/python3.11/site-packages (from requests>=2.19.0->pooch>=1.8.1->qc-AtomDB) (2.0.4)\r\n", + "Requirement already satisfied: idna<4,>=2.5 in $HOME/miniconda3/lib/python3.11/site-packages (from requests>=2.19.0->pooch>=1.8.1->qc-AtomDB) (3.4)\r\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in $HOME/miniconda3/lib/python3.11/site-packages (from requests>=2.19.0->pooch>=1.8.1->qc-AtomDB) (1.26.18)\r\n", + "Requirement already satisfied: certifi>=2017.4.17 in $HOME/miniconda3/lib/python3.11/site-packages (from requests>=2.19.0->pooch>=1.8.1->qc-AtomDB) (2024.8.30)\r\n" + ] + } + ], + "execution_count": 2, + "source": [ + "# Install required packages\n", + "!pip install git+https://github.com/theochem/grid.git\n", + "!pip install qc-AtomDB" + ], + "id": "c2ef4d2cdf884dc0" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Importing Libraries\n", + "We import necessary libraries for numerical calculations, grid generation, and molecular modeling:\n", + "- NumPy for numerical operations\n", + "- grid package for creating and manipulating integration grids\n", + "- atomdb for creating molecular models\n" + ], + "id": "7da4aa7a7a73a0ae" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.331263755Z", + "start_time": "2025-04-08T02:07:54.945818423Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 3, + "source": [ + "# Import required libraries\n", + "import numpy as np\n", + "from functools import lru_cache\n", + "\n", + "from grid.onedgrid import Trapezoidal\n", + "from grid.rtransform import LinearFiniteRTransform\n", + "from grid.utils import convert_cart_to_sph, generate_real_spherical_harmonics\n", + "from grid.becke import BeckeWeights\n", + "from grid import AtomGrid\n", + "from atomdb import make_promolecule" + ], + "id": "6d9bd60cc1d3845b" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Icosahedron Grid Generation\n", + "The following functions create an icosphere grid by starting with a regular icosahedron and subdividing its faces.\n", + "This approach provides an evenly distributed set of points on a sphere, which is ideal for angular integration.\n" + ], + "id": "d70f088e0ccd92b4" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.334475484Z", + "start_time": "2025-04-08T02:07:55.332740261Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 4, + "source": [ + "# Function to generate the vertices of a regular icosahedron\n", + "def icosahedron_vertices():\n", + " # Golden ratio\n", + " phi = (1 + np.sqrt(5)) / 2\n", + "\n", + " # Normalize the length to 1\n", + " a = 1 / np.sqrt(1 + phi ** 2)\n", + " b = phi * a\n", + "\n", + " # Vertices of an icosahedron\n", + " vertices = [\n", + " (-a, b, 0), (a, b, 0), (-a, -b, 0), (a, -b, 0),\n", + " (0, -a, b), (0, a, b), (0, -a, -b), (0, a, -b),\n", + " (b, 0, -a), (b, 0, a), (-b, 0, -a), (-b, 0, a)\n", + " ]\n", + " return np.array(vertices)" + ], + "id": "1020af5f90c5194f" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Subdivision and Icosphere Generation\n", + "The following functions refine the icosahedron by subdividing its faces to create a more detailed icosphere.\n", + "This process increases the number of points on the sphere, improving the accuracy of our integration.\n" + ], + "id": "e1d820a6406fc78c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.339560642Z", + "start_time": "2025-04-08T02:07:55.337237694Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 5, + "source": [ + "# Function to subdivide the faces of an icosahedron\n", + "def subdivide(vertices, faces):\n", + " # New vertex set, including old vertices\n", + " new_vertices = vertices.tolist()\n", + " vertex_map = {}\n", + "\n", + " # Helper function to find the midpoint and index\n", + " def midpoint_index(v1, v2):\n", + " # Check if we have already calculated this\n", + " edge = tuple(sorted([v1, v2]))\n", + " if edge in vertex_map:\n", + " return vertex_map[edge]\n", + "\n", + " # Calculate midpoint and normalize it to the sphere\n", + " midpoint = (vertices[v1] + vertices[v2]) / 2\n", + " midpoint /= np.linalg.norm(midpoint)\n", + "\n", + " # Store the new vertex index\n", + " index = len(new_vertices)\n", + " new_vertices.append(midpoint)\n", + " vertex_map[edge] = index\n", + " return index\n", + "\n", + " new_faces = []\n", + "\n", + " for v1, v2, v3 in faces:\n", + " # Get the midpoints\n", + " a = midpoint_index(v1, v2)\n", + " b = midpoint_index(v2, v3)\n", + " c = midpoint_index(v3, v1)\n", + "\n", + " # Create four new faces\n", + " new_faces.extend([\n", + " [v1, a, c],\n", + " [v2, b, a],\n", + " [v3, c, b],\n", + " [a, b, c]\n", + " ])\n", + "\n", + " return np.array(new_vertices), np.array(new_faces)\n", + "\n", + "\n", + "# Function to generate an icosphere with a specified number of subdivisions\n", + "def generate_icosphere(subdivisions):\n", + " # Initial icosahedron vertices and faces\n", + " vertices = icosahedron_vertices()\n", + " faces = [\n", + " [0, 11, 5], [0, 5, 1], [0, 1, 7], [0, 7, 10], [0, 10, 11],\n", + " [1, 5, 9], [5, 11, 4], [11, 10, 2], [10, 7, 6], [7, 1, 8],\n", + " [3, 9, 4], [3, 4, 2], [3, 2, 6], [3, 6, 8], [3, 8, 9],\n", + " [4, 9, 5], [2, 4, 11], [6, 2, 10], [8, 6, 7], [9, 8, 1]\n", + " ]\n", + "\n", + " # Subdivide the triangles the number of times specified\n", + " for _ in range(subdivisions):\n", + " vertices, faces = subdivide(vertices, faces)\n", + "\n", + " return vertices" + ], + "id": "eb19825304594269" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Weight Calculation and Angular Grid Generation\n", + "These functions calculate the integration weights for our grid points and generate the angular grid.\n", + "The weights ensure that our numerical integration is accurate, and the caching mechanism (@lru_cache) \n", + "improves performance by storing previously calculated grids.\n" + ], + "id": "c4e22c0a5219d24b" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.343496959Z", + "start_time": "2025-04-08T02:07:55.340695896Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 6, + "source": [ + "# Function to calculate integration weights for grid points\n", + "def calculate_weights(points):\n", + " # Convert Cartesian coordinates to spherical coordinates\n", + " points_sph = convert_cart_to_sph(points)\n", + " r, theta, phi = points_sph.T\n", + " n_points = len(points)\n", + " l_max = (np.sqrt(n_points) - 1).astype(int)\n", + "\n", + " # Generate spherical harmonics for the points\n", + " spherical_harmonics = generate_real_spherical_harmonics(l_max, theta, phi)\n", + " n_spherical_harmonics = len(spherical_harmonics)\n", + "\n", + " # Set up the right-hand side of the equation\n", + " b = np.zeros(n_spherical_harmonics)\n", + " b[0] = np.sqrt(4 * np.pi)\n", + "\n", + " # Solve the least squares problem to find the weights\n", + " w_sphere, _, _, s = np.linalg.lstsq(spherical_harmonics.astype(np.float64), b)\n", + "\n", + " return w_sphere\n", + "\n", + "\n", + "# Function to generate an angular grid from an icosphere with caching for efficiency\n", + "@lru_cache(maxsize=None)\n", + "def angular_grid_from_icosphere(icosphere_order):\n", + " points = generate_icosphere(icosphere_order)\n", + " w_sphere = calculate_weights(points)\n", + " return points, w_sphere" + ], + "id": "5cfebe91e4c16b2e" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Molecule Setup and Radial Grid Generation\n", + "Here we define a simple atom (neon) at the origin and create a radial grid for integration.\n", + "The radial grid is combined with the angular grid to form a complete 3D integration grid.\n" + ], + "id": "eb6f49cc49d9366b" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.350503980Z", + "start_time": "2025-04-08T02:07:55.344371708Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 7, + "source": [ + "# Define atom/molecule (neon atom at the origin)\n", + "atcoords = np.array([[0, 0, 0]])\n", + "atnums = np.array([10]) # Atomic number 10 is neon\n", + "promol = make_promolecule(atnums=atnums, coords=atcoords, dataset='slater')\n", + "\n", + "# Generate radial grid with 400 points from 0 to 10 Bohr\n", + "oned_grid = Trapezoidal(npoints=400)\n", + "radial_grid = LinearFiniteRTransform(0.0, 10).transform_1d_grid(oned_grid)" + ], + "id": "5e2a3b700db889cf" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Density Functional Theory (DFT) - PBE exchange functional\n", + "These functions implement various functions needed for PBE exchange calculations:\n", + "- Fermi wave vector (k_f)\n", + "- Exchange energy density (eps_x)\n", + "- Dimensionless density gradient (s)\n", + "- Enhancement factor (f_x) for PBE exchange functional\n", + "- Exchange energy (e_x)\n", + "- Exchange potential (v_x)\n" + ], + "id": "dd70340c887a06d4" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.403052059Z", + "start_time": "2025-04-08T02:07:55.354439862Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 8, + "source": [ + "# Functions for DFT calculations\n", + "\n", + "# Calculate Fermi wave vector\n", + "def k_f(dens_point):\n", + " kf = (dens_point * 3 * np.pi ** 2) ** (1 / 3)\n", + " return kf\n", + "\n", + "\n", + "# Calculate exchange energy density\n", + "def eps_x(dens_point):\n", + " e_val = 1\n", + " kf = k_f(dens_point)\n", + " epsx = -3 * kf * e_val ** 2 / (4 * np.pi)\n", + " return epsx\n", + "\n", + "\n", + "# Calculate dimensionless density gradient\n", + "def dimless_dens_grad(dens_point, grad_point):\n", + " kf = k_f(dens_point)\n", + " s = grad_point / (2 * kf * dens_point)\n", + " return s\n", + "\n", + "\n", + "# Calculate enhancement factor for PBE exchange functional\n", + "def f_x(dens_point, grad_point):\n", + " kappa = 0.8040\n", + " mu = 0.2195149727645171\n", + " s = dimless_dens_grad(dens_point, grad_point)\n", + " fx = 1 + kappa - kappa / (1 + (mu / kappa) * s ** 2)\n", + " return fx\n", + "\n", + "\n", + "# Calculate exchange energy\n", + "def e_x(dens_point, grad_point):\n", + " epsx = eps_x(dens_point)\n", + " fx = f_x(dens_point, grad_point)\n", + " ex = epsx * fx * dens_point\n", + " return ex\n", + "\n", + "\n", + "# Helper function to normalize vectors\n", + "def unit_v(vector):\n", + " return vector / np.linalg.norm(vector, axis=1, keepdims=True)\n", + "\n", + "\n", + "# Calculate density gradient gradient\n", + "def dens_grad_grad(grid):\n", + " dd_dens_norm = promol.atoms[0].dd_dens_func()(np.linalg.norm(grid, axis=1))\n", + " return dd_dens_norm[:, None] * unit_v(grid)\n", + "\n", + "\n", + "# Helper function for exchange potential calculation\n", + "def alg(grad_vec, dens_grad_grad):\n", + " a = grad_vec * dens_grad_grad\n", + " return a.sum(axis=1)\n", + "\n", + "\n", + "# Calculate derivative of enhancement factor\n", + "def d_f_x(dens_point, grad_point):\n", + " kappa = 0.8040\n", + " mu = 0.2195149727645171\n", + " s = dimless_dens_grad(dens_point, grad_point)\n", + " dfx = 2 * kappa ** 2 * mu * s / (kappa + mu * s ** 2) ** 2\n", + " return dfx\n", + "\n", + "\n", + "# Calculate second derivative of enhancement factor\n", + "def dd_f_x(dens_point, grad_point):\n", + " kappa = 0.8040\n", + " mu = 0.2195149727645171\n", + " s = dimless_dens_grad(dens_point, grad_point)\n", + " b = mu * s ** 2 / kappa + 1\n", + " ddfx = -kappa * (8 * mu ** 2 * s ** 2 / (kappa ** 2 * b ** 3) - 2 * mu / (kappa * b ** 2))\n", + " return ddfx\n", + "\n", + "\n", + "# Calculate exchange potential\n", + "def v_x(dens_point, grad_point, lap_point, grad_vec, dens_grad_grad):\n", + " s = dimless_dens_grad(dens_point, grad_point)\n", + " fx = f_x(dens_point, grad_point)\n", + " kf = k_f(dens_point)\n", + " algo = alg(grad_vec, dens_grad_grad)\n", + " dfx = d_f_x(dens_point, grad_point)\n", + " ddfx = dd_f_x(dens_point, grad_point)\n", + "\n", + " a_x = -3 * (3 * np.pi ** 2) ** (1 / 3) / (4 * np.pi)\n", + "\n", + " vx = a_x * dens_point ** (1 / 3) * (4 * fx / 3 +\n", + " (-4 / 3 * s - (\n", + " 1 / (2 * kf) * lap_point / grad_point) + 1 / (\n", + " 2 * kf) * algo / (\n", + " grad_point ** 2)) * dfx +\n", + " (-1 / (2 * kf) ** 2 * algo / (\n", + " grad_point * dens_point) + 4 / 3 * s ** 2) * ddfx)\n", + " return vx" + ], + "id": "2e304a01265283d4" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Variable Calculation Functions\n", + "These functions calculate different properties at each grid point:\n", + "- Number of electrons (electron density)\n", + "- Exchange energy\n", + "- Exchange potential\n", + "\n", + "These are the quantities we want to integrate over the grid.\n" + ], + "id": "6b1e728d5ba8243f" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.404048197Z", + "start_time": "2025-04-08T02:07:55.402899599Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 9, + "source": [ + "# Functions to calculate different variables at grid points\n", + "\n", + "# Calculate electron density at grid points\n", + "def calc_num_e(promol, points):\n", + " return promol.density(points)\n", + "\n", + "\n", + "# Calculate exchange energy at grid points\n", + "def calc_e_x(promol, points):\n", + " dens = promol.density(points)\n", + " dens_grad = promol.gradient(points)\n", + " dens_grad_norm = np.linalg.norm(dens_grad, axis=1)\n", + " return e_x(dens, dens_grad_norm)\n", + "\n", + "\n", + "# Calculate exchange potential at grid points\n", + "def calc_v_x(promol, points):\n", + " dens = promol.density(points)\n", + " dens_grad = promol.gradient(points)\n", + " dens_grad_norm = np.linalg.norm(dens_grad, axis=1)\n", + " dens_lap = promol.laplacian(points)\n", + " dens_gradgrad = dens_grad_grad(points)\n", + " vx = v_x(dens, dens_grad_norm, dens_lap, dens_grad, dens_gradgrad)\n", + " return vx" + ], + "id": "b09c0d97a2722fda" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Adaptive Grid Function\n", + "This is the main function that creates an adaptive integration grid. It works by:\n", + "1. Starting with a coarse grid\n", + "2. Comparing with a reference grid to check accuracy\n", + "3. For each radial point, increasing the angular resolution until convergence\n", + "4. Returning the optimized grid, weights, and icosphere orders\n", + "\n", + "This approach ensures we use just enough grid points to achieve the desired accuracy,\n", + "making the calculation more efficient.\n" + ], + "id": "7a002d79073cc30c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.404499196Z", + "start_time": "2025-04-08T02:07:55.403232861Z" + } + }, + "cell_type": "code", + "source": [ + "# Function to create an adaptive grid for numerical integration\n", + "def adaptative_grid(promol, variable, n_rgrid_points=100, tol=None):\n", + " # Select the appropriate calculation function and tolerance based on the variable\n", + " if variable == \"num_electrons\":\n", + " calc_variable = calc_num_e\n", + " if tol is None:\n", + " tol = 1e-15\n", + " elif variable == \"energy\":\n", + " calc_variable = calc_e_x\n", + " if tol is None:\n", + " tol = 1e-15\n", + " elif variable == \"potential\":\n", + " calc_variable = calc_v_x\n", + " if tol is None:\n", + " tol = 1e-5\n", + " else:\n", + " raise ValueError(\n", + " \"Variable can only be one of 'num_electrons', 'energy' or 'potential'.\")\n", + "\n", + " print(f'Calculating {variable}...')\n", + "\n", + " # Generate radial grid\n", + " oned_grid = Trapezoidal(npoints=n_rgrid_points)\n", + " radial_grid = LinearFiniteRTransform(1e-8, 10).transform_1d_grid(oned_grid)\n", + "\n", + " # Generate initial angular grid and compute the weights\n", + " points_sphere, w_sphere = angular_grid_from_icosphere(0)\n", + " icosphere_orders = np.zeros(len(radial_grid.points), dtype=np.int64)\n", + " grid = np.concatenate([x * points_sphere for x in radial_grid.points])\n", + "\n", + " # Obtain Becke weights and calculate the total weights\n", + " ws = BeckeWeights().compute_weights(points=grid, atcoords=atcoords, atnums=atnums)\n", + " weights = np.concatenate(\n", + " [w * w_sphere * p ** 2 for w, p in zip(radial_grid.weights, radial_grid.points)])\n", + " mol_weights = weights * ws\n", + "\n", + " # Calculate the variable at each point and integrate\n", + " val_0_integrand = calc_variable(promol, grid)\n", + " val_0 = np.nansum(val_0_integrand * mol_weights)\n", + "\n", + " # -------------------------- ITERATIONS AT EACH POINT OF R --------------------\n", + " max_iter = 5\n", + "\n", + " # Create a reference grid for comparison\n", + " atnum = promol.atoms[0]._data.atnum\n", + " atcoord = promol.coords[0]\n", + " reference_grid = AtomGrid.from_preset(atnum=atnum,\n", + " preset='ultrafine',\n", + " rgrid=radial_grid,\n", + " center=atcoord)\n", + " val_ref_integrand = calc_variable(promol, reference_grid.points)\n", + " val_ref = np.nansum(val_ref_integrand * reference_grid.weights)\n", + " print(f'{variable} for reference grid = {val_ref:.6f}\\n')\n", + "\n", + " # If initial grid is already accurate enough, return it\n", + " if abs(val_ref - val_0) < tol:\n", + " print(f'{variable} for initial grid = {val_0:.6f}')\n", + " print(f'Difference = {abs(val_ref - val_0):.3e}')\n", + " print(\"Order 0 grid gives results of similar accuracy to the reference grid.\")\n", + " return grid, weights, icosphere_orders\n", + "\n", + " radial_weights = radial_grid.weights * radial_grid.points ** 2\n", + "\n", + " # Adaptive refinement for each radial point\n", + " deltae_list = list()\n", + " val_final = 0\n", + " for i, (x, ws) in enumerate(zip(radial_grid.points, radial_weights)):\n", + " # Start with lowest order angular grid\n", + " points_o, weights_o = angular_grid_from_icosphere(0)\n", + " weights = ws * weights_o\n", + " radial_ox = points_o * x\n", + " val_prev_integrand = calc_variable(promol, radial_ox)\n", + " val_prev = np.nansum(val_prev_integrand * weights)\n", + "\n", + " # Increase angular resolution until convergence\n", + " for order in range(1, max_iter):\n", + " points_o, weights_o = angular_grid_from_icosphere(order)\n", + " weights = ws * weights_o\n", + " radial_ox = points_o * x\n", + " val_test_integrand = calc_variable(promol, radial_ox)\n", + " val_test = np.nansum(val_test_integrand * weights)\n", + " dval = abs(val_test - val_prev)\n", + " if dval < tol:\n", + " # Converged - use previous order\n", + " icosphere_orders[i] = order - 1\n", + " deltae_list.append(dval)\n", + " val_final += val_prev\n", + " break\n", + " else:\n", + " val_prev = val_test\n", + " else:\n", + " # Reached max iterations - use highest order\n", + " icosphere_orders[i] = order\n", + " deltae_list.append(dval)\n", + " val_final += val_test\n", + "\n", + " # Create final grid and weights using the determined icosphere orders\n", + " grid = np.concatenate([x * angular_grid_from_icosphere(o)[0]\n", + " for x, o in zip(radial_grid.points, icosphere_orders)])\n", + " weights = np.concatenate([angular_grid_from_icosphere(o)[1] * w\n", + " for w, o in zip(radial_weights, icosphere_orders)])\n", + "\n", + " # Print results\n", + " print(f'\\n{variable} for final grid = {val_final:.6f}')\n", + " print(f'Difference = {abs(val_final - val_ref):.3e}')\n", + "\n", + " return grid, weights, icosphere_orders" + ], + "id": "629931bb1aea49bb", + "outputs": [], + "execution_count": 10 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Main Execution\n", + "In this final section, we:\n", + "1. Define our atom (neon) at the origin\n", + "2. Create adaptive grids for three different properties:\n", + " - Number of electrons (electron density)\n", + " - Exchange energy\n", + " - Exchange potential\n", + "\n", + "Each grid will be optimized specifically for the property being calculated.\n" + ], + "id": "fc211f43ef9cad1b" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:07:55.405545556Z", + "start_time": "2025-04-08T02:07:55.403479320Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 11, + "source": [ + "# Define the atom (neon at origin)\n", + "atcoords = np.array([[0, 0, 0]])\n", + "atnums = np.array([10]) # Atomic number 10 is neon\n", + "promol = make_promolecule(atnums=atnums, coords=atcoords, dataset='slater')" + ], + "id": "4d56acb27411b2d" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "### Running the Adaptive Grid Algorithm\n", + "Now we run the adaptive grid algorithm for each property. The algorithm will print:\n", + "- The reference value calculated on a standard grid\n", + "- The final value calculated on our adaptive grid\n", + "- The difference between the two values\n" + ], + "id": "f25e4887e18db5c0" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:08:02.368828766Z", + "start_time": "2025-04-08T02:07:55.403717708Z" + } + }, + "cell_type": "code", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating num_electrons...\n", + "num_electrons for reference grid = 9.996794\n", + "\n", + "\n", + "num_electrons for final grid = 9.996794\n", + "Difference = 4.086e-14\n", + "Calculating energy...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_97009/1775444682.py:18: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n", + "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n", + " w_sphere, _, _, s = np.linalg.lstsq(spherical_harmonics.astype(np.float64), b)\n", + "$HOME/miniconda3/lib/python3.11/site-packages/grid/becke.py:310: UserWarning: Covalent radii for the following atom numbers [10] is nan. Instead the radii with 1 less the atomic number is used.\n", + " weights += self.compute_atom_weight(points, atcoords, atnums, select[0])\n", + "$HOME/miniconda3/lib/python3.11/site-packages/grid/atomgrid.py:895: UserWarning: Lebedev weights are negative which can introduce round-off errors.\n", + " sphere_grid = AngularGrid(degree=deg_i, method=method)\n", + "/tmp/ipykernel_97009/1775444682.py:18: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n", + "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n", + " w_sphere, _, _, s = np.linalg.lstsq(spherical_harmonics.astype(np.float64), b)\n", + "$HOME/miniconda3/lib/python3.11/site-packages/grid/becke.py:310: UserWarning: Covalent radii for the following atom numbers [10] is nan. Instead the radii with 1 less the atomic number is used.\n", + " weights += self.compute_atom_weight(points, atcoords, atnums, select[0])\n", + "$HOME/miniconda3/lib/python3.11/site-packages/grid/atomgrid.py:895: UserWarning: Lebedev weights are negative which can introduce round-off errors.\n", + " sphere_grid = AngularGrid(degree=deg_i, method=method)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "energy for reference grid = -12.040391\n", + "\n", + "energy for final grid = -12.040391\n", + "Difference = 4.086e-14\n", + "Calculating potential...\n", + "potential for reference grid = -33.394777\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "$HOME/miniconda3/lib/python3.11/site-packages/grid/becke.py:310: UserWarning: Covalent radii for the following atom numbers [10] is nan. Instead the radii with 1 less the atomic number is used.\n", + " weights += self.compute_atom_weight(points, atcoords, atnums, select[0])\n", + "$HOME/miniconda3/lib/python3.11/site-packages/grid/atomgrid.py:895: UserWarning: Lebedev weights are negative which can introduce round-off errors.\n", + " sphere_grid = AngularGrid(degree=deg_i, method=method)\n", + "/tmp/ipykernel_97009/1775444682.py:18: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n", + "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n", + " w_sphere, _, _, s = np.linalg.lstsq(spherical_harmonics.astype(np.float64), b)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "potential for final grid = -33.456511\n", + "Difference = 6.173e-02\n", + "Calculating num_electrons...\n", + "num_electrons for reference grid = 9.996794\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "$HOME/miniconda3/lib/python3.11/site-packages/grid/becke.py:310: UserWarning: Covalent radii for the following atom numbers [10] is nan. Instead the radii with 1 less the atomic number is used.\n", + " weights += self.compute_atom_weight(points, atcoords, atnums, select[0])\n", + "$HOME/miniconda3/lib/python3.11/site-packages/grid/atomgrid.py:895: UserWarning: Lebedev weights are negative which can introduce round-off errors.\n", + " sphere_grid = AngularGrid(degree=deg_i, method=method)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "num_electrons for final grid = 9.996794\n", + "Difference = 3.730e-14\n", + "Calculating energy...\n", + "energy for reference grid = -12.040391\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "$HOME/miniconda3/lib/python3.11/site-packages/grid/becke.py:310: UserWarning: Covalent radii for the following atom numbers [10] is nan. Instead the radii with 1 less the atomic number is used.\n", + " weights += self.compute_atom_weight(points, atcoords, atnums, select[0])\n", + "$HOME/miniconda3/lib/python3.11/site-packages/grid/atomgrid.py:895: UserWarning: Lebedev weights are negative which can introduce round-off errors.\n", + " sphere_grid = AngularGrid(degree=deg_i, method=method)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "energy for final grid = -12.040391\n", + "Difference = 3.730e-14\n" + ] + } + ], + "execution_count": 12, + "source": [ + "n_rgrid_points = 250\n", + "# Create adaptive grids for different properties\n", + "grid_e, weights_e, icosphere_orders_e = adaptative_grid(promol, \"num_electrons\", n_rgrid_points)\n", + "grid_x, weights_x, icosphere_orders_x = adaptative_grid(promol, \"energy\", n_rgrid_points)\n", + "grid_v, weights_v, icosphere_orders_v = adaptative_grid(promol, \"potential\", n_rgrid_points)\n", + "\n", + "grid_e_16, weights_e_16, icosphere_orders_e_16 = adaptative_grid(promol, \"num_electrons\", n_rgrid_points, tol=1e-16)\n", + "grid_x_16, weights_x_16, icosphere_orders_x_16 = adaptative_grid(promol, \"energy\", n_rgrid_points, tol=1e-16)" + ], + "id": "3fad755aa71b1bfa" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Comparison between grids" + ], + "id": "91b03e55d7d638a3" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "Import plotting libraries" + ], + "id": "a82fd77a87539b75" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:08:02.530825655Z", + "start_time": "2025-04-08T02:08:02.369310317Z" + } + }, + "cell_type": "code", + "outputs": [], + "execution_count": 13, + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import MultipleLocator" + ], + "id": "d6f788d497afcac2" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Comparison between adaptative grids" + ], + "id": "84b7aad00020a2bf" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "First, we compare the icosphere order for every radial point." + ], + "id": "146d0521a69e2fc2" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:08:02.718243377Z", + "start_time": "2025-04-08T02:08:02.532836920Z" + } + }, + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 14, + "source": [ + "oned_grid = Trapezoidal(npoints=n_rgrid_points)\n", + "radial_grid = LinearFiniteRTransform(0.0, 10).transform_1d_grid(oned_grid)\n", + "x = radial_grid.points\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x, icosphere_orders_v, label='Exchange Potential')\n", + "plt.plot(x, icosphere_orders_e, label='Electron Density ($tol=10^{-15}$)', linestyle=(2.5, (5, 3)), linewidth=2)\n", + "plt.plot(x, icosphere_orders_x, label='Exchange Energy ($tol=10^{-15}$)', linestyle=(0, (1, 3)), linewidth=4)\n", + "plt.plot(x, icosphere_orders_e_16, label='Electron Density ($tol=10^{-16}$)', linestyle=(2.5, (5, 3)), linewidth=2)\n", + "plt.plot(x, icosphere_orders_x_16, label='Exchange Energy ($tol=10^{-16}$)', linestyle=(0, (1, 3)), linewidth=4)\n", + "\n", + "ax = plt.gca()\n", + "ax.set_ylim([None, 5.5])\n", + "ax.yaxis.set_major_locator(plt.MaxNLocator(integer=True))\n", + "ax.xaxis.set_minor_locator(MultipleLocator(0.5))\n", + "\n", + "plt.xlabel('Radial Distance [a.u.]')\n", + "plt.ylabel('Icosphere Order for Angular Grid')\n", + "plt.title('Comparison of Icosphere Orders for Different Properties')\n", + "plt.legend()\n", + "plt.grid()" + ], + "id": "1b9268146426c977" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "Then, we compare the number of points in the icosphere corresponding to each radial point." + ], + "id": "bc9105761c0a7457" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:08:02.910302677Z", + "start_time": "2025-04-08T02:08:02.722237765Z" + } + }, + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 15, + "source": [ + "ICOSPHERE_NPOINTS = {\n", + " 0: 12,\n", + " 1: 42,\n", + " 2: 162,\n", + " 3: 642,\n", + " 4: 2562,\n", + " 5: 10242,\n", + " 6: 40962,\n", + " 7: 163842,\n", + " 8: 655362,\n", + " 9: 2621442,\n", + " 10: 10485762,\n", + "}\n", + "y_v = [ICOSPHERE_NPOINTS[o] for o in icosphere_orders_v]\n", + "y_e = [ICOSPHERE_NPOINTS[o] for o in icosphere_orders_e]\n", + "y_x = [ICOSPHERE_NPOINTS[o] for o in icosphere_orders_x]\n", + "y_e_16 = [ICOSPHERE_NPOINTS[o] for o in icosphere_orders_e_16]\n", + "y_x_16 = [ICOSPHERE_NPOINTS[o] for o in icosphere_orders_x_16]\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x, y_v, label='Exchange Potential')\n", + "plt.plot(x, y_e, label='Electron Density ($tol=10^{-15}$)', linestyle=(2.5, (5, 3)), linewidth=2)\n", + "plt.plot(x, y_x, label='Exchange Energy ($tol=10^{-15}$)', linestyle=(0, (1, 3)), linewidth=4)\n", + "plt.plot(x, y_e_16, label='Electron Density ($tol=10^{-16}$)', linestyle=(2.5, (5, 3)), linewidth=2)\n", + "plt.plot(x, y_x_16, label='Exchange Energy ($tol=10^{-16}$)', linestyle=(0, (1, 3)), linewidth=4)\n", + "\n", + "plt.yscale('log')\n", + "ax = plt.gca()\n", + "ax.set_ylim([None, 5.5])\n", + "ax.xaxis.set_minor_locator(MultipleLocator(0.5))\n", + "max_val = max(max(icosphere_orders_e), max(icosphere_orders_v), max(icosphere_orders_x))\n", + "y_ticks = [ICOSPHERE_NPOINTS[i] for i in range(max_val + 1)]\n", + "ax.yaxis.set_ticks(y_ticks)\n", + "ax.yaxis.set_ticklabels(y_ticks)\n", + "\n", + "plt.xlabel('Radial Distance [a.u.]')\n", + "plt.ylabel('log Number of Angular Points')\n", + "plt.title('Comparison of Number of Points for Each Grid')\n", + "plt.legend()\n", + "plt.grid()" + ], + "id": "119e8dc0978cca20" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "## Comparison of adaptative grids with presets included in theochem/grid" + ], + "id": "a0b8465be3d62af" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:08:03.055264882Z", + "start_time": "2025-04-08T02:08:02.911940376Z" + } + }, + "cell_type": "code", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "$HOME/miniconda3/lib/python3.11/site-packages/grid/atomgrid.py:895: UserWarning: Lebedev weights are negative which can introduce round-off errors.\n", + " sphere_grid = AngularGrid(degree=deg_i, method=method)\n" + ] + } + ], + "execution_count": 16, + "source": [ + "presets = ['coarse', 'medium', 'fine', 'veryfine', 'ultrafine', 'insane']\n", + "radius_count_list = []\n", + "grid_presets = {}\n", + "\n", + "atnum = promol.atoms[0]._data.atnum\n", + "atcoord = promol.coords[0]\n", + "for preset in presets:\n", + " reference_grid = AtomGrid.from_preset(atnum=atnum,\n", + " preset=preset,\n", + " rgrid=radial_grid,\n", + " center=atcoord)\n", + " grid_presets[preset] = reference_grid\n", + " grid_norm = np.linalg.norm(reference_grid.points, axis=1)\n", + " norm_list = np.round(grid_norm* 10**5)\n", + " radius, counts = np.unique(norm_list, axis=0, return_counts=True)\n", + " radius /= 10**5\n", + " radius_count_list.append((radius, counts))\n" + ], + "id": "d6619d8c0cdb7ae4" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "We compare the distribution of the number of points in the sphere corresponding to each radial point." + ], + "id": "182b616baabbcb14" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:08:03.321967418Z", + "start_time": "2025-04-08T02:08:03.057528221Z" + } + }, + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 17, + "source": [ + "plt.figure(figsize=(10, 6))\n", + "\n", + "plt.plot(x, y_v, label='Exchange Potential', linestyle=':')\n", + "plt.plot(x, y_e, label='Electron Density ($tol=10^{-15}$)', linestyle=(2.5, (5, 3)), linewidth=2)\n", + "plt.plot(x, y_x, label='Exchange Energy ($tol=10^{-15}$)', linestyle=(0, (1, 3)), linewidth=4)\n", + "plt.plot(x, y_e_16, label='Electron Density ($tol=10^{-16}$)', linestyle=(2.5, (5, 3)), linewidth=2)\n", + "plt.plot(x, y_x_16, label='Exchange Energy ($tol=10^{-16}$)', linestyle=(0, (1, 3)), linewidth=4)\n", + "\n", + "for i, (radius, counts) in enumerate(radius_count_list):\n", + " plt.plot(radius, counts, label=presets[i])\n", + "\n", + "plt.yscale('log')\n", + "ax = plt.gca()\n", + "ax.xaxis.set_minor_locator(MultipleLocator(0.5))\n", + "\n", + "y_ticks = [12, 42] + [max(counts) for radius, counts in radius_count_list] + [2562]\n", + "ax.yaxis.set_ticks(y_ticks)\n", + "ax.yaxis.set_ticklabels(y_ticks)\n", + "\n", + "plt.xlabel('Radial Distance [a.u.]')\n", + "plt.ylabel('Number of Grid Points')\n", + "plt.title('Comparison of Grid Point Distribution for Different Presets and Adaptative Grids')\n", + "plt.legend()\n", + "plt.grid()" + ], + "id": "ee7db1ef1db29729" + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "Finally, we compare the total number of points in each grid." + ], + "id": "55027be659cc6d5d" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-04-08T02:08:03.438122596Z", + "start_time": "2025-04-08T02:08:03.322330433Z" + } + }, + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "Text(0.5, 1.0, 'Comparison of Total Grid Points for Different Grids')" + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 18, + "source": [ + "plt.figure(figsize=(10, 6))\n", + "\n", + "grid_name = ['Exchange Potential', 'Electron Density ($tol=10^{-15}$)',\n", + " 'Exchange Energy ($tol=10^{-15}$)'] + ['Electron Density ($tol=10^{-16}$)',\n", + " 'Exchange Energy ($tol=10^{-16}$)'] + presets\n", + "\n", + "num_points = [sum(y_v), sum(y_e), sum(y_x)] + [sum(y_e_16), sum(y_x_16)]\n", + "for radius, counts in radius_count_list:\n", + " num_points.append(sum(counts))\n", + "\n", + "bar_colors = ['tab:blue'] * 3 + ['tab:green'] * 2 + ['tab:red'] * 6\n", + "\n", + "h = plt.bar(grid_name, num_points, color=bar_colors)\n", + "\n", + "plt.plot((-0.4,10.4), (sum(y_e_16), sum(y_e_16)), 'k', linestyle=':')\n", + "\n", + "plt.bar_label(h, padding=2, fmt='{:,.0f}')\n", + "\n", + "plt.xticks(rotation=45, ha='right')\n", + "plt.ylabel('Number of Grid Points')\n", + "plt.title('Comparison of Total Grid Points for Different Grids')" + ], + "id": "6344575427257981" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}