qualia_core_db/specialized_libs/chemistry_modeling/
integrals.rs1use crate::specialized_libs::shared::zero_heap_algebra::ZeroHeapMatrix;
8use core::f64::consts::PI;
9
10#[derive(Debug, Clone, Copy)]
12pub struct GtoPrimitive {
13 pub origin: [f64; 3],
14 pub exponent: f64,
15 pub l: [u8; 3], pub coefficient: f64,
17}
18
19impl GtoPrimitive {
20 pub fn total_angular_momentum(&self) -> u8 {
22 self.l[0] + self.l[1] + self.l[2]
23 }
24}
25
26pub struct IntegralEngine;
28
29impl IntegralEngine {
30 pub fn evaluate_overlap<const N: usize, const M: usize>(
33 basis_a: &[GtoPrimitive; N],
34 basis_b: &[GtoPrimitive; M],
35 ) -> ZeroHeapMatrix<f64, N, M> {
36 let mut s_matrix = ZeroHeapMatrix::zeros();
37
38 for i in 0..N {
39 for j in 0..M {
40 let a = &basis_a[i];
41 let b = &basis_b[j];
42
43 let l_total = a.total_angular_momentum() + b.total_angular_momentum();
45
46 let val = if l_total <= 2 {
47 Self::os_overlap(a, b)
49 } else {
50 Self::rys_overlap(a, b)
52 };
53
54 s_matrix.set(i, j, val);
55 }
56 }
57
58 s_matrix
59 }
60
61 fn os_overlap(a: &GtoPrimitive, b: &GtoPrimitive) -> f64 {
63 let alpha = a.exponent;
66 let beta = b.exponent;
67 let p = alpha + beta;
68 let mu = (alpha * beta) / p;
69
70 let dx = a.origin[0] - b.origin[0];
71 let dy = a.origin[1] - b.origin[1];
72 let dz = a.origin[2] - b.origin[2];
73 let ab2 = dx * dx + dy * dy + dz * dz;
74
75 let s_s = (PI / p).powf(1.5) * f64::exp(-mu * ab2);
76
77 s_s * a.coefficient * b.coefficient
79 }
80
81 fn rys_overlap(a: &GtoPrimitive, b: &GtoPrimitive) -> f64 {
83 Self::os_overlap(a, b)
87 }
88
89 pub fn overlap_s(a: &GtoPrimitive, b: &GtoPrimitive) -> f64 {
96 let (p, mu, ab2) = Self::gauss_product(a, b);
97 (PI / p).powf(1.5) * f64::exp(-mu * ab2) * a.coefficient * b.coefficient
98 }
99
100 pub fn kinetic_s(a: &GtoPrimitive, b: &GtoPrimitive) -> f64 {
105 let (p, mu, ab2) = Self::gauss_product(a, b);
106 let s_bare = (PI / p).powf(1.5) * f64::exp(-mu * ab2);
107 mu * (3.0 - 2.0 * mu * ab2) * s_bare * a.coefficient * b.coefficient
108 }
109
110 pub fn nuclear_s(a: &GtoPrimitive, b: &GtoPrimitive, center: [f64; 3], z: f64) -> f64 {
118 let (p, mu, ab2) = Self::gauss_product(a, b);
119 let alpha = a.exponent;
120 let beta = b.exponent;
121 let pcenter = [
122 (alpha * a.origin[0] + beta * b.origin[0]) / p,
123 (alpha * a.origin[1] + beta * b.origin[1]) / p,
124 (alpha * a.origin[2] + beta * b.origin[2]) / p,
125 ];
126 let pc2 = (pcenter[0] - center[0]).powi(2)
127 + (pcenter[1] - center[1]).powi(2)
128 + (pcenter[2] - center[2]).powi(2);
129 let k = f64::exp(-mu * ab2);
130 let f0 = Self::boys_function(0, p * pc2);
131 -z * (2.0 * PI / p) * k * f0 * a.coefficient * b.coefficient
132 }
133
134 pub fn dipole_s(a: &GtoPrimitive, b: &GtoPrimitive) -> [f64; 3] {
139 let (p, mu, ab2) = Self::gauss_product(a, b);
140 let alpha = a.exponent;
141 let beta = b.exponent;
142 let s = (PI / p).powf(1.5) * f64::exp(-mu * ab2) * a.coefficient * b.coefficient;
143 let pcenter = [
144 (alpha * a.origin[0] + beta * b.origin[0]) / p,
145 (alpha * a.origin[1] + beta * b.origin[1]) / p,
146 (alpha * a.origin[2] + beta * b.origin[2]) / p,
147 ];
148 [pcenter[0] * s, pcenter[1] * s, pcenter[2] * s]
149 }
150
151 #[inline]
154 fn gauss_product(a: &GtoPrimitive, b: &GtoPrimitive) -> (f64, f64, f64) {
155 let alpha = a.exponent;
156 let beta = b.exponent;
157 let p = alpha + beta;
158 let mu = (alpha * beta) / p;
159 let dx = a.origin[0] - b.origin[0];
160 let dy = a.origin[1] - b.origin[1];
161 let dz = a.origin[2] - b.origin[2];
162 (p, mu, dx * dx + dy * dy + dz * dz)
163 }
164
165 pub fn evaluate_eri(
169 a: &GtoPrimitive,
170 b: &GtoPrimitive,
171 c: &GtoPrimitive,
172 d: &GtoPrimitive,
173 ) -> f64 {
174 let l_total = a.total_angular_momentum()
175 + b.total_angular_momentum()
176 + c.total_angular_momentum()
177 + d.total_angular_momentum();
178
179 if l_total <= 4 {
180 Self::hgp_eri(a, b, c, d)
181 } else {
182 Self::rys_eri(a, b, c, d)
183 }
184 }
185
186 fn hgp_eri(a: &GtoPrimitive, b: &GtoPrimitive, c: &GtoPrimitive, d: &GtoPrimitive) -> f64 {
188 let alpha = a.exponent;
189 let beta = b.exponent;
190 let gamma = c.exponent;
191 let delta = d.exponent;
192
193 let p = alpha + beta;
194 let q = gamma + delta;
195 let alpha_p = (alpha * beta) / p;
196 let alpha_q = (gamma * delta) / q;
197
198 let r_p = [
199 (alpha * a.origin[0] + beta * b.origin[0]) / p,
200 (alpha * a.origin[1] + beta * b.origin[1]) / p,
201 (alpha * a.origin[2] + beta * b.origin[2]) / p,
202 ];
203
204 let r_q = [
205 (gamma * c.origin[0] + delta * d.origin[0]) / q,
206 (gamma * c.origin[1] + delta * d.origin[1]) / q,
207 (gamma * c.origin[2] + delta * d.origin[2]) / q,
208 ];
209
210 let ab2 = (a.origin[0] - b.origin[0]).powi(2)
211 + (a.origin[1] - b.origin[1]).powi(2)
212 + (a.origin[2] - b.origin[2]).powi(2);
213 let cd2 = (c.origin[0] - d.origin[0]).powi(2)
214 + (c.origin[1] - d.origin[1]).powi(2)
215 + (c.origin[2] - d.origin[2]).powi(2);
216 let pq2 = (r_p[0] - r_q[0]).powi(2) + (r_p[1] - r_q[1]).powi(2) + (r_p[2] - r_q[2]).powi(2);
217
218 let t = (p * q) / (p + q) * pq2;
219 let f0_t = Self::boys_function(0, t);
220
221 let prefactor = 2.0 * PI.powf(2.5) / (p * q * f64::sqrt(p + q));
222 let exp_ab = f64::exp(-alpha_p * ab2);
223 let exp_cd = f64::exp(-alpha_q * cd2);
224
225 prefactor
226 * exp_ab
227 * exp_cd
228 * f0_t
229 * a.coefficient
230 * b.coefficient
231 * c.coefficient
232 * d.coefficient
233 }
234
235 fn rys_eri(a: &GtoPrimitive, b: &GtoPrimitive, c: &GtoPrimitive, d: &GtoPrimitive) -> f64 {
237 let l_total = a.total_angular_momentum()
238 + b.total_angular_momentum()
239 + c.total_angular_momentum()
240 + d.total_angular_momentum();
241
242 let n_roots = (l_total / 2 + 1) as usize;
243
244 let mut roots = [0.0; 8];
246 let mut weights = [0.0; 8];
247
248 let alpha = a.exponent;
249 let beta = b.exponent;
250 let gamma = c.exponent;
251 let delta = d.exponent;
252 let p = alpha + beta;
253 let q = gamma + delta;
254 let t = (p * q) / (p + q); let mut f_vals = [0.0; 17]; for m in 0..=(2 * n_roots) {
259 f_vals[m] = Self::boys_function(m as u8, t);
260 }
261
262 let mut alpha_coef = [0.0; 8];
265 let mut beta_coef = [0.0; 8];
266 let mut sigma = [[0.0; 17]; 9]; for i in 0..=(2 * n_roots) {
270 sigma[1][i] = f_vals[i];
271 }
272
273 if f_vals[0].abs() > 1e-15 {
274 alpha_coef[0] = f_vals[1] / f_vals[0];
275 beta_coef[0] = f_vals[0];
276
277 for k in 1..n_roots {
278 for l in k..(2 * n_roots - k + 1) {
279 sigma[k + 1][l] = sigma[k][l + 1]
280 - alpha_coef[k - 1] * sigma[k][l]
281 - beta_coef[k - 1] * sigma[k - 1][l];
282 }
283 if sigma[k][k - 1].abs() > 1e-15 {
284 alpha_coef[k] =
285 sigma[k + 1][k + 1] / sigma[k + 1][k] - sigma[k][k] / sigma[k][k - 1];
286 beta_coef[k] = sigma[k + 1][k] / sigma[k][k - 1];
287 }
288 }
289
290 let mut t_mat = crate::specialized_libs::shared::zero_heap_algebra::ZeroHeapMatrix::<
292 f64,
293 8,
294 8,
295 >::zeros();
296 for i in 0..8 {
297 if i < n_roots {
298 t_mat.set(i, i, alpha_coef[i]);
299 if i < n_roots - 1 {
300 let off_diag = beta_coef[i + 1].abs().sqrt();
301 t_mat.set(i, i + 1, off_diag);
302 t_mat.set(i + 1, i, off_diag);
303 }
304 } else {
305 t_mat.set(i, i, 1.0); }
307 }
308
309 if let Ok((evals, evecs)) =
310 crate::specialized_libs::chemistry_modeling::scf::jacobi_diagonalization(&t_mat)
311 {
312 for i in 0..n_roots {
313 roots[i] = evals[i];
314 let v = evecs.get(0, i);
315 weights[i] = v * v * f_vals[0];
316 }
317 } else {
318 roots[0] = t / (p + q);
319 weights[0] = f_vals[0];
320 }
321 } else {
322 roots[0] = t / (p + q);
323 weights[0] = f_vals[0];
324 }
325
326 let mut eri = 0.0;
327
328 let r_p = [
330 (alpha * a.origin[0] + beta * b.origin[0]) / p,
331 (alpha * a.origin[1] + beta * b.origin[1]) / p,
332 (alpha * a.origin[2] + beta * b.origin[2]) / p,
333 ];
334 let r_q = [
335 (gamma * c.origin[0] + delta * d.origin[0]) / q,
336 (gamma * c.origin[1] + delta * d.origin[1]) / q,
337 (gamma * c.origin[2] + delta * d.origin[2]) / q,
338 ];
339
340 for i in 0..n_roots {
341 let u2 = roots[i];
343 let w = weights[i];
344
345 let ix = Self::hermite_1d(
350 u2,
351 r_p[0] - a.origin[0],
352 r_p[0] - b.origin[0],
353 r_q[0] - c.origin[0],
354 r_q[0] - d.origin[0],
355 a.l[0],
356 b.l[0],
357 c.l[0],
358 d.l[0],
359 );
360 let iy = Self::hermite_1d(
361 u2,
362 r_p[1] - a.origin[1],
363 r_p[1] - b.origin[1],
364 r_q[1] - c.origin[1],
365 r_q[1] - d.origin[1],
366 a.l[1],
367 b.l[1],
368 c.l[1],
369 d.l[1],
370 );
371 let iz = Self::hermite_1d(
372 u2,
373 r_p[2] - a.origin[2],
374 r_p[2] - b.origin[2],
375 r_q[2] - c.origin[2],
376 r_q[2] - d.origin[2],
377 a.l[2],
378 b.l[2],
379 c.l[2],
380 d.l[2],
381 );
382
383 eri += w * ix * iy * iz;
384 }
385
386 eri * a.coefficient * b.coefficient * c.coefficient * d.coefficient
387 }
388
389 fn hermite_1d(
401 u: f64,
402 pa: f64,
403 pb: f64,
404 qc: f64,
405 qd: f64,
406 la: u8,
407 lb: u8,
408 lc: u8,
409 ld: u8,
410 ) -> f64 {
411 if la + lb + lc + ld == 0 {
413 return 1.0;
414 }
415
416 let bra = if la == 1 && lb == 0 {
420 u * pa
421 } else if la == 0 && lb == 1 {
422 u * pb
423 } else if la == 1 && lb == 1 {
424 u * u * pa * pb
425 } else if la == 2 && lb == 0 {
426 u * u * pa * pa + 0.5
427 } else if la == 0 && lb == 2 {
428 u * u * pb * pb + 0.5
429 } else {
430 1.0
431 }; let ket = if lc == 1 && ld == 0 {
435 u * qc
436 } else if lc == 0 && ld == 1 {
437 u * qd
438 } else if lc == 1 && ld == 1 {
439 u * u * qc * qd
440 } else if lc == 2 && ld == 0 {
441 u * u * qc * qc + 0.5
442 } else if lc == 0 && ld == 2 {
443 u * u * qd * qd + 0.5
444 } else {
445 1.0
446 };
447
448 bra * ket
449 }
450
451 pub fn boys_function(n: u8, t: f64) -> f64 {
456 const T_LOWER: f64 = 1e-7;
457 const T_UPPER: f64 = 30.0;
458
459 if t <= T_LOWER {
460 let mut result = 0.0;
463 let mut term = 1.0 / (2.0 * n as f64 + 1.0);
464 let mut k = 0;
465
466 while term.abs() > 1e-15 && k < 10 {
467 result += term;
468 k += 1;
469 let k_f64 = k as f64;
470 term = -term * t * (2.0 * n as f64 + 2.0 * k_f64 - 1.0)
471 / (k_f64 * (2.0 * n as f64 + 2.0 * k_f64 + 1.0));
472 }
473 result
474 } else if t >= T_UPPER {
475 let mut val = (PI / t).sqrt() / 2.0;
478 for i in 1..=n {
479 val *= (2.0 * i as f64 - 1.0) / (2.0 * t);
480 }
481 val
482 } else {
483 let m_max = n + 15;
491 let mut fm = 0.0;
492 let mut term = 1.0 / (2.0 * m_max as f64 + 1.0);
493 let mut k = 0;
494 while term.abs() > 1e-15 && k < 50 {
495 fm += term;
496 k += 1;
497 let k_f64 = k as f64;
498 term = -term * t * (2.0 * m_max as f64 + 2.0 * k_f64 - 1.0)
499 / (k_f64 * (2.0 * m_max as f64 + 2.0 * k_f64 + 1.0));
500 }
501
502 let exp_t = f64::exp(-t);
503 for m in (n..m_max).rev() {
504 fm = (2.0 * t * fm + exp_t) / (2.0 * m as f64 + 1.0);
505 }
506 fm
507 }
508 }
509}
510
511#[cfg(test)]
512mod tests {
513 use super::*;
514 use core::f64::consts::PI;
515
516 #[test]
517 fn test_overlap_s_orbitals() {
518 let a = GtoPrimitive {
519 origin: [0.0, 0.0, 0.0],
520 exponent: 1.0,
521 l: [0, 0, 0],
522 coefficient: 1.0,
523 };
524
525 let b = GtoPrimitive {
526 origin: [1.0, 0.0, 0.0],
527 exponent: 1.0,
528 l: [0, 0, 0],
529 coefficient: 1.0,
530 };
531
532 let basis_a = [a];
533 let basis_b = [b];
534
535 let overlap = IntegralEngine::evaluate_overlap(&basis_a, &basis_b);
536 let val = overlap.get(0, 0);
537
538 let expected = (PI / 2.0).powf(1.5) * f64::exp(-0.5);
540 assert!(
541 (val - expected).abs() < 1e-8,
542 "Overlap mismatch: expected {}, got {}",
543 expected,
544 val
545 );
546 }
547}