Skip to content

Extended Hückel Theory (EHT)

sci-form implements a full Extended Hückel Theory (EHT) pipeline for semiempirical electronic-structure calculations. EHT calculates molecular orbital (MO) energies, coefficients, and volumetric orbital densities from a 3D geometry without self-consistent field iteration.

Overview

EHT was introduced by Hoffmann (1963) as an extension of Hückel theory to all valence electrons (not just π electrons). It requires only:

  1. The molecular geometry (Cartesian coordinates)
  2. A set of Valence State Ionization Potentials (VSIP) per element
  3. Slater-type orbital exponents per element

The pipeline has five phases:

PhaseDescription
B1Build atomic orbital basis from element parameters
B2Compute overlap matrix S and Hamiltonian H
B3Solve generalized eigenproblem HC = SCE
B4Evaluate MO densities on 3D volumetric grid
B5Extract isosurfaces via Marching Cubes

Phase B1: Atomic Basis Set

Each atom contributes one or two valence orbitals (s and p) described as Slater-type orbitals (STOs) expanded in a minimal STO-3G Gaussian basis.

Slater-Type Orbitals

A Slater orbital of principal quantum number n and exponent ζ (bohr⁻¹):

χnlm(r,θ,ϕ)=Nrn1eζrYlm(θ,ϕ)

where N is a normalization constant and Ylm are spherical harmonics.

STO-3G Expansion

Each Slater orbital is approximated by 3 Gaussian primitives fitted to reproduce the STO shape:

χ(r)=k=13dkGk(αk,rRA)

where Gk(αk,r)=Nkexp(αk|r|2) is a normalized Gaussian primitive.

VSIP Parameter Table

The following Hoffmann parameters are used as diagonal Hamiltonian elements:

ElementOrbitalVSIP (eV)Slater ζ (bohr⁻¹)
H1s−13.61.300
C2s−21.41.625
C2p−11.41.625
N2s−26.01.950
N2p−13.41.950
O2s−32.32.275
O2p−14.82.275
F2s−40.02.425
F2p−18.12.425
Cl3s−26.32.183
Cl3p−14.21.733
Br4s−22.072.588
Br4p−13.12.131
I5s−18.02.679
I5p−12.72.322

Phase B2: Overlap Matrix and Hamiltonian

Overlap Matrix S

Sij=χi(r)χj(r)dr

Computed analytically using the Gaussian product theorem: the product of two Gaussians centered at A and B is a single Gaussian centered at the weighted midpoint P:

Ga(α,rA)Gb(β,rB)=KABGa+b(γ,rP)

where γ=α+β, P=αA+βBγ, and KAB=exp(αβγ|AB|2).

This allows exact analytical evaluation of all s|s, s|p, and p|p integrals without numerical quadrature.

Hamiltonian Matrix H

Diagonal elements (Hückel approximation):

Hii=VSIPi

Off-diagonal elements (Wolfsberg-Helmholtz approximation):

Hij=12KSij(Hii+Hjj)

where K=1.75 is the Wolfsberg-Helmholtz constant. This is the key approximation of EHT: the resonance integral between two orbitals is proportional to their overlap and the average of their ionization potentials.


Phase B3: Generalized Eigenproblem

The EHT secular equation is the generalized eigenproblem:

HC=SCE

where E is a diagonal matrix of orbital energies and the columns of C are MO coefficient vectors. sci-form solves this using Löwdin symmetric orthogonalization:

Step 1: Diagonalize S

S=UΛUT

Step 2: Compute S1/2

S1/2=Udiag(λi1/2)UT

Eigenvalues smaller than 1010 are discarded to avoid numerical instability.

Step 3: Transform to Standard Form

H=S1/2HS1/2

Step 4: Diagonalize H

HC=CE

Step 5: Back-Transform Coefficients

C=S1/2C

Eigenvalues are sorted in ascending order. The HOMO and LUMO indices are identified from the number of valence electrons (filled two electrons per orbital).

Output: EhtResult

rust
pub struct EhtResult {
    pub energies: Vec<f64>,      // MO energies (eV), ascending
    pub coefficients: Vec<Vec<f64>>, // C matrix: coefficients[ao][mo]
    pub n_electrons: usize,       // total valence electrons
    pub homo_index: usize,        // HOMO (0-based)
    pub lumo_index: usize,        // LUMO (0-based)
    pub homo_energy: f64,         // eV
    pub lumo_energy: f64,         // eV
    pub gap: f64,                 // HOMO-LUMO gap (eV)
}

Phase B4: Orbital Grid Evaluation

Once the MO coefficients are known, any orbital ψm can be evaluated on a 3D volumetric grid:

ψm(r)=μ=1NAOCμmχμ(r)

The orbital density (for visualization) is:

ρm(r)=|ψm(r)|2

The grid is parallelized over chunks using Rayon, evaluating all AO basis functions at each grid point.

Grid Parameters

rust
pub struct VolumetricGrid {
    pub origin: [f64; 3],    // lower-left corner (Å)
    pub spacing: f64,         // grid spacing (Å), default 0.15
    pub dims: [usize; 3],    // (Nx, Ny, Nz)
    pub values: Vec<f32>,    // scalar field (f32 for compact transfer)
}

Phase B5: Marching Cubes Isosurface

Isosurfaces of MO density are extracted using the Marching Cubes algorithm (Lorensen & Cline 1987):

  1. For each voxel cube in the grid, determine which vertices are inside/outside the isovalue threshold
  2. Use the 256-case lookup table to identify the edge intersections
  3. Interpolate vertex positions on crossed edges
  4. Return a triangle mesh

The isosurface mesh is returned as:

rust
pub struct IsosurfaceMesh {
    pub vertices: Vec<[f32; 3]>,    // xyz positions
    pub normals: Vec<[f32; 3]>,     // per-vertex normals
    pub indices: Vec<u32>,           // triangle indices
}

API

Rust

rust
use sci_form::{eht_calculate, eht_orbital_mesh};

// Run EHT calculation
let result = eht_calculate("C6H6", None)?;  // benzene
println!("HOMO: {:.2} eV", result.homo_energy);
println!("LUMO: {:.2} eV", result.lumo_energy);
println!("Gap:  {:.2} eV", result.gap);

// Get orbital isosurface as JSON mesh
let mesh_json = eht_orbital_mesh("C6H6", result.homo_index, 0.05, 0.15, None)?;

Python

python
import sci_form

result = sci_form.eht_calculate("c1ccccc1")  # benzene (aromatic SMILES)
print(f"HOMO = {result.homo_energy:.2f} eV")
print(f"LUMO = {result.lumo_energy:.2f} eV")
print(f"Gap  = {result.gap:.2f} eV")
print(f"Coefficients shape: {len(result.coefficients)} x {len(result.coefficients[0])}")

# Get orbital grid for visualization
grid = sci_form.eht_orbital_mesh("c1ccccc1", result.homo_index, 0.05, 0.15)

TypeScript / WASM

typescript
import init, { eht_calculate, eht_orbital_grid_typed } from 'sci-form-wasm';

await init();

const result = JSON.parse(eht_calculate("c1ccccc1"));
console.log(`HOMO = ${result.homo_energy.toFixed(2)} eV`);
console.log(`Gap  = ${result.gap.toFixed(2)} eV`);

// Get orbital volume as a flat Float32Array (Nx × Ny × Nz)
const gridInfo = JSON.parse(compute_esp_grid_info("c1ccccc1", ...));
const orbital = eht_orbital_grid_typed("c1ccccc1", result.homo_index, 0.05, 0.15);
// orbital: Float32Array — ready for Three.js Data3DTexture

Capabilities and Limitations

PropertyValue
Supported elementsH, C, N, O, F, Si, P, S, Cl, Br, I
Basis setSTO-3G (minimal, 1–2 orbitals per atom)
CorrelationNone (single-determinant)
Relativistic effectsNo
Self-consistencyNo (one-shot diagonalization)
CostO(N3) diagonalization + O(N2) overlap

EHT is appropriate for qualitative visualization of frontier orbitals (HOMO/LUMO), rough HOMO-LUMO gap estimates, and as a fast electronic descriptor. For quantitative accuracy, DFT or post-Hartree-Fock methods are required.


References

  1. Hoffmann, R. An Extended Hückel Theory. I. Hydrocarbons. J. Chem. Phys. 1963, 39, 1397–1412.
  2. Wolfsberg, M.; Helmholtz, L. The Spectra and Electronic Structure of the Tetrahedral Ions MnO₄⁻, CrO₄²⁻, and ClO₄⁻. J. Chem. Phys. 1952, 20, 837–843.
  3. Löwdin, P.-O. On the Non-Orthogonality Problem Connected with the Use of Atomic Wave Functions in the Theory of Molecules and Crystals. J. Chem. Phys. 1950, 18, 365–375.
  4. Lorensen, W. E.; Cline, H. E. Marching Cubes: A High Resolution 3D Surface Construction Algorithm. SIGGRAPH 1987, 21, 163–169.

Released under the MIT License.