additional notes

Author: falesiani

content/notes/2026-02-PME.md

@@ -0,0 +1,110 @@
+---
+title: Smooth Particle Mesh Ewald (PME)
+date: 2025-02-15
+math: true
+
+image:
+  filename: ""
+  caption: "Math / formula (optional caption)"
+  focal_point: Smart
+  preview_only: false
+---
+
+# Smooth Particle Mesh Ewald (PME)
+
+In molecular simulations, calculating electrostatic interactions is computationally expensive because the Coulomb potential ($1/r$) is long-ranged. A "brute-force" calculation for $N$ particles scales as $O(N^2)$. **Smooth Particle Mesh Ewald (PME)** is an algorithm that reduces this complexity to $O(N \log N)$.
+
+## 1. The Core Problem
+When using periodic boundary conditions, we must sum the interactions of a particle with every other particle in an infinite periodic grid. This sum is only conditionally convergent and extremely slow to compute directly.
+
+The Ewald technique splits the interaction into two parts:
+1.  **Short-range (Real Space):** Interactions that decay quickly.
+2.  **Long-range (Reciprocal Space):** A slowly varying part handled in Fourier space.
+
+---
+
+## 2. Mathematical Decomposition
+
+The total electrostatic energy $V_{total}$ is expressed as:
+
+$$V_{total} = V_{real} + V_{recip} + V_{self}$$
+
+### A. Real-Space Term (Short Range)
+This term handles nearby particles. It uses the **complementary error function** ($\text{erfc}$) to screen the charges:
+
+$$V_{real} = \frac{1}{2} \sum_{i,j}^N \sum_{n \in \mathbb{Z}^3}^* \frac{q_i q_j \text{erfc}(\alpha |r_{ij} + nL|)}{|r_{ij} + nL|}$$
+
+* **$\alpha$**: The Ewald splitting parameter (controls the rate of decay).
+* **$nL$**: Periodic images in a box of length $L$.
+
+
+
+### B. Reciprocal-Space Term (Long Range)
+The "smooth" part of the potential is periodic and solved using a Fourier Series:
+
+$$V_{recip} = \frac{1}{2\pi \Omega} \sum_{k \neq 0} \frac{4\pi}{k^2} e^{-k^2 / 4\alpha^2} |S(k)|^2$$
+
+* **$\Omega$**: The volume of the unit cell.
+* **$S(k)$**: The **structure factor**, $\sum q_j e^{ik \cdot r_j}$.
+
+> **The PME Innovation:** Instead of calculating $S(k)$ directly, PME interpolates charges onto a 3D grid using **B-splines** and solves the sum using the **Fast Fourier Transform (FFT)**.
+
+### C. Self-Correction Term
+Since the reciprocal sum includes the interaction of a particle with its own neutralizing background, we subtract the self-energy:
+
+$$V_{self} = -\frac{\alpha}{\sqrt{\pi}} \sum_{i=1}^N q_i^2$$
+
+---
+
+## 3. The PME Workflow
+
+
+
+1.  **Charge Assignment:** Map point charges $q_i$ to a regular 3D mesh using cardinal B-splines.
+2.  **FFT:** Transform the grid-based charge distribution into reciprocal space.
+3.  **Green's Function:** Multiply by the reciprocal potential (the $1/k^2$ term).
+4.  **Inverse FFT:** Transform back to real space to get the potential on the grid.
+5.  **Force Interpolation:** Calculate the gradient of the potential at each particle's actual position to determine the forces.
+
+---
+
+## 4. Key Parameters in MD Engines
+
+| Parameter | Recommended Value / Impact |
+| :--- | :--- |
+| **PME Order** | Usually **4** (Cubic Splines). Balance between accuracy and speed. |
+| **Grid Spacing** | Typically **0.10 to 0.15 nm**. Affects FFT resolution. |
+| **$\alpha$ (Tolerance)** | Often derived from the real-space cutoff (e.g., $10^{-5}$). |
+
+
+
+
+
+---
+
+## 5. Foundational & Modern References
+
+### The Smooth Particle Mesh Ewald (SPME)
+* **Essmann, U., Perera, L., Berkowitz, M. L., Darden, T., Lee, H., & Pedersen, L. G. (1995).** "A smooth particle mesh Ewald method." *The Journal of Chemical Physics*, 103(19), 8577-8593.
+
+### The Original Particle Mesh Ewald (PME)
+* **Darden, T., York, D., & Pedersen, L. (1993).** "Particle mesh Ewald: An $N \cdot \log(N)$ method for Ewald sums in large systems." *The Journal of Chemical Physics*, 98(12), 10089-10092.
+
+### The Original Ewald Method
+* **Ewald, P. P. (1921).** "Die Berechnung optischer und elektrostatischer Gitterpotentiale." *Annalen der Physik*, 369(3), 253-287.
+
+
+### Modern Implementation: DIMOS (PyTorch)
+* **Christiansen, H., et al. (2025).** "Fast, Modular, and Differentiable Framework for Machine Learning-Enhanced Molecular Simulations." *The Journal of Chemical Physics*.
+    * [Article DOI: 10.1063/5.0277356](https://doi.org/10.1063/5.0277356)
+    * [arXiv: 2503.20541](https://arxiv.org/abs/2503.20541)
+    * [GitHub Code: nec-research/DIMOS](https://github.com/nec-research/DIMOS)
+    > **Note:** This framework provides a high-performance, differentiable environment for integrating ML potentials directly into MD/MC workflows using PyTorch.
+
+
+
+---
+*Note: PME is essential for maintaining stability in simulations of charged systems like DNA, proteins, and lipid bilayers.*
+
+---
+*Note: This note was prepared as a technical summary for molecular dynamics enthusiasts.*

content/notes/2026-02-spherical-harmonics/index.md

@@ -0,0 +1,109 @@
+---
+title: Spherical Harmonics
+date: 2025-02-15
+math: true
+image:
+  filename: ""
+  caption: ""
+  focal_point: Smart
+  preview_only: false
+---
+
+# Spherical Harmonics and e3nn
+
+**Spherical Harmonics** ($Y_{\ell}^m$) are a set of orthogonal functions defined on the surface of a sphere. They are the angular portion of a set of solutions to Laplace's equation and serve as the Fourier basis for functions defined on a sphere.
+
+## 1. Mathematical Overview
+
+In spherical coordinates $(\theta, \phi)$, the real spherical harmonics are defined as:
+$$Y_{\ell}^m(\theta, \phi) = N_{\ell}^m P_{\ell}^m(\cos \theta) \text{trig}(m\phi)$$
+
+Where:
+- $\ell \ge 0$ is the **degree** (angular momentum).
+- $-\ell \le m \le \ell$ is the **order**.
+- $P_{\ell}^m$ are the associated Legendre polynomials.
+- $N_{\ell}^m$ is a normalization constant.
+
+In modern geometric machine learning, we often represent these in **Cartesian coordinates** $(x, y, z)$, where they become homogeneous polynomials of degree $\ell$.
+
+---
+
+## 2. Using the `e3nn` Library
+
+The [e3nn](https://github.com/e3nn/e3nn) library is designed for **Euclidean Neural Networks**. It uses spherical harmonics as the primary way to lift geometric data (like atomic positions) into a representation that is equivariant to rotations ($SO(3)$) and inversion ($O(3)$).
+
+### Key Concepts in e3nn:
+* **Irreps (Irreducible Representations):** e3nn tracks how data transforms. A spherical harmonic of degree $\ell$ belongs to the irrep $\ell$.
+* **Parity:** In e3nn, spherical harmonics have a definite parity $p = (-1)^\ell$.
+* **Coordinate Convention:** e3nn typically expects input vectors in $(x, y, z)$ but internally uses a $y, z, x$ convention for alignment with standard real spherical harmonics.
+
+---
+
+## 3. Python Implementation
+
+To use this code, you will need to install the library:
+`pip install e3nn torch`
+
+### Code Example: Generating and Visualizing
+The following script calculates the spherical harmonic coefficients for a given set of vectors.
+
+```python
+import torch
+from e3nn import o3
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import cm
+
+def plot_all_harmonics(l_max):
+    fig = plt.figure(figsize=(12, 8))
+    
+    # Grid coordinates for sampling the sphere
+    phi, theta = np.mgrid[0:2*np.pi:70j, 0:np.pi:70j]
+    x = np.sin(theta) * np.cos(phi)
+    y = np.sin(theta) * np.sin(phi)
+    z = np.cos(theta)
+    vectors = torch.tensor(np.stack([x.flatten(), y.flatten(), z.flatten()], axis=1), dtype=torch.float32)
+
+    plot_idx = 1
+    for l in range(l_max + 1):
+        # Get irreps and compute SH for this specific L
+        irreps = o3.Irreps.spherical_harmonics(l)
+        sh_values = o3.spherical_harmonics(irreps, vectors, normalize=True)
+        
+        # There are 2L + 1 components for each L
+        num_m = 2 * l + 1
+        
+        for m_idx in range(num_m):
+            # Create subplot: rows = l_max+1, cols = 2*l_max+1
+            # We center the plots by offsetting the start index
+            ax_idx = l * (2 * l_max + 1) + (l_max - l) + m_idx + 1
+            ax = fig.add_subplot(l_max + 1, 2 * l_max + 1, ax_idx, projection='3d')
+            
+            # Extract the specific m component
+            r_vals = sh_values[:, m_idx].reshape(70, 70).numpy()
+            
+            # Radial distance is absolute value, color is the sign
+            R = np.abs(r_vals)
+            X_p, Y_p, Z_p = R * x, R * y, R * z
+            
+            # Normalize colors so 0 is white/middle
+            v_max = np.max(np.abs(r_vals))
+            norm = plt.Normalize(-v_max, v_max)
+            colors = cm.RdBu(norm(r_vals))
+
+            ax.plot_surface(X_p, Y_p, Z_p, facecolors=colors, antialiased=True, shade=True)
+            
+            ax.set_title(f"L={l}, m_idx={m_idx}", fontsize=8)
+            ax.axis('off')
+            
+    plt.tight_layout()
+    plt.savefig('spherical_harmonics_l3.png', dpi=300, transparent=True)
+    plt.show()
+
+plot_all_harmonics(l_max=3)
+
+```
+
+
+![Spherical Harmonics plot](spherical_harmonics_l3.png)
+