gfn1-rs-python 0.4.5__tar.gz → 0.4.6__tar.gz

{gfn1_rs_python-0.4.5 → gfn1_rs_python-0.4.6}/Cargo.lock

@@ -420,7 +420,7 @@ dependencies = [
 
 [[package]]
 name = "gfn1-rs"
-version = "0.4.5"
+version = "0.4.6"
 dependencies = [
  "faer",
  "libm",

{gfn1_rs_python-0.4.5 → gfn1_rs_python-0.4.6}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gfn1-rs"
-version = "0.4.5"
+version = "0.4.6"
 edition = "2021"
 license = "GPL-3.0-or-later"
 authors = ["ss0832"]

{gfn1_rs_python-0.4.5 → gfn1_rs_python-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gfn1-rs-python
-Version: 0.4.5
+Version: 0.4.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: ase>=3.22 ; extra == 'ase'

{gfn1_rs_python-0.4.5 → gfn1_rs_python-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "gfn1-rs-python"
-version = "0.4.5"
+version = "0.4.6"
 description = "Python and ASE interface for the native Rust GFN1-RS implementation"
 requires-python = ">=3.9,<3.15"
 license = "GPL-3.0-or-later"

{gfn1_rs_python-0.4.5 → gfn1_rs_python-0.4.6}/src/dispersion.rs

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //! DFT-D3(BJ) dispersion and experimental non-PBC DFT-D4 dispersion for GFN1-xTB.
 //!
-//! The large D3 C6 reference table is deliberately not bundled. It is read
-//! from the `s-dftd3/src/dftd3/reference.f90` source used by tblite.
+//! The large D3 C6 reference table is bundled under `third_party/simple-dftd3`
+//! and embedded at build time (`s-dftd3/src/dftd3/reference.f90`), so it is used
+//! by default; an explicit path or the `GFN1_D3_REFERENCE` environment variable
+//! can override it.
 //! D4 reference data are stored with upstream provenance under `third_party/dftd4`;
 //! the GFN1 damping constants `a1`, `a2`, and `s8` are read from the
 //! user-supplied `param_gfn1-xtb.txt` through [`Gfn1Parameters`].  The experimental
@@ -21,7 +23,7 @@ use crate::params::{Gfn1Parameters, GFN1_D3_REFERENCE_ENV};
 use crate::system::PeriodicSystem;
 use std::collections::HashMap;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::{Arc, Mutex, OnceLock};
 
 const WF: f64 = 4.0;
@@ -1238,8 +1240,7 @@ pub fn dispersion_energy_gradient(
     let a1 = params.required_global("a1")?;
     let a2 = params.required_global("a2")?;
 
-    let reference_path = resolve_d3_reference_path(params, explicit_reference_path)?;
-    let reference = load_d3_reference(&reference_path)?;
+    let reference = resolve_and_load_d3_reference(explicit_reference_path)?;
     let cn = coordination_with_derivatives(
         system,
         CoordinationOptions {
@@ -1374,8 +1375,7 @@ pub fn dispersion_energy_gradient_hessian(
     }
     let a1 = params.required_global("a1")?;
     let a2 = params.required_global("a2")?;
-    let reference_path = resolve_d3_reference_path(params, explicit_reference_path)?;
-    let reference = load_d3_reference(&reference_path)?;
+    let reference = resolve_and_load_d3_reference(explicit_reference_path)?;
     let nat = system.atoms.len();
     let ndof = 3 * nat;
     let coords = jet_coordinates(system, ndof);
@@ -1474,8 +1474,7 @@ fn dispersion_strain_energy_jet(
     let atm_active = s9.abs() > 1.0e-15;
     let a1 = params.required_global("a1")?;
     let a2 = params.required_global("a2")?;
-    let reference_path = resolve_d3_reference_path(params, explicit_reference_path)?;
-    let reference = load_d3_reference(&reference_path)?;
+    let reference = resolve_and_load_d3_reference(explicit_reference_path)?;
     let cn = d3_strain_coordination_jets(system, ndof)?;
     let weights = reference_weight_jets(system, &reference, &cn, ndof)?;
     let c6 = atomic_c6_jets(system, &reference, &weights, ndof)?;
@@ -1642,65 +1641,37 @@ fn d3_atm_triple_energy_strain_jet(
     pref.mul(&angular).mul(&fdmp)
 }
 
-fn resolve_d3_reference_path(
-    params: &Gfn1Parameters,
+/// Resolve and load the D3 C6 reference data. An explicit path (the
+/// `--d3-reference` API argument) or the `GFN1_D3_REFERENCE` environment variable
+/// overrides the default; when neither is set, the reference bundled with the
+/// library and embedded at build time is used.
+fn resolve_and_load_d3_reference(
     explicit_reference_path: Option<&str>,
-) -> Result<PathBuf> {
+) -> Result<Arc<D3Reference>> {
     if let Some(path) = explicit_reference_path {
         let trimmed = path.trim();
         if !trimmed.is_empty() {
-            return Ok(PathBuf::from(trimmed));
+            return load_d3_reference(Path::new(trimmed));
         }
     }
     if let Ok(path) = std::env::var(GFN1_D3_REFERENCE_ENV) {
         let trimmed = path.trim();
         if !trimmed.is_empty() {
-            return Ok(PathBuf::from(trimmed));
-        }
-    }
-
-    if let Some(param_path) = &params.source_path {
-        let param = Path::new(param_path);
-        if let Some(param_dir) = param.parent() {
-            if let Some(root) = param_dir.parent() {
-                let candidate = root
-                    .join("tblite")
-                    .join("subprojects")
-                    .join("s-dftd3")
-                    .join("src")
-                    .join("dftd3")
-                    .join("reference.f90");
-                if candidate.exists() {
-                    return Ok(candidate);
-                }
-            }
-            let candidate = param_dir
-                .join("..")
-                .join("tblite")
-                .join("subprojects")
-                .join("s-dftd3")
-                .join("src")
-                .join("dftd3")
-                .join("reference.f90");
-            if candidate.exists() {
-                return Ok(candidate);
-            }
+            return load_d3_reference(Path::new(trimmed));
         }
     }
+    bundled_d3_reference()
+}
 
-    let bundled = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("third_party")
-        .join("simple-dftd3")
-        .join("src")
-        .join("dftd3")
-        .join("reference.f90");
-    if bundled.exists() {
-        return Ok(bundled);
+/// Parse and cache the D3 reference embedded in the library.
+fn bundled_d3_reference() -> Result<Arc<D3Reference>> {
+    static CACHE: OnceLock<Arc<D3Reference>> = OnceLock::new();
+    if let Some(found) = CACHE.get() {
+        return Ok(found.clone());
     }
-
-    Err(Gfn1Error::InvalidInput(format!(
-        "missing D3 reference data; pass --d3-reference FILE or set {GFN1_D3_REFERENCE_ENV}"
-    )))
+    let loaded = Arc::new(D3Reference::bundled()?);
+    let _ = CACHE.set(loaded.clone());
+    Ok(loaded)
 }
 
 #[derive(Clone, Debug)]
@@ -2777,8 +2748,7 @@ pub fn dispersion_third_derivative(
     }
     let a1 = params.required_global("a1")?;
     let a2 = params.required_global("a2")?;
-    let reference_path = resolve_d3_reference_path(params, explicit_reference_path)?;
-    let reference = load_d3_reference(&reference_path)?;
+    let reference = resolve_and_load_d3_reference(explicit_reference_path)?;
     let nat = system.atoms.len();
     let ndof = 3 * nat;
     let coords = jet3_coordinates(system, ndof);
@@ -2827,10 +2797,18 @@ struct D3Reference {
     r4r2: Vec<f64>,
 }
 
+/// D3 C6 reference table and `r4/r2` data, bundled under `third_party/simple-dftd3`
+/// and embedded at build time so the default dispersion path needs no external
+/// file. Overridable through the `--d3-reference` API argument or the
+/// `GFN1_D3_REFERENCE` environment variable.
+const BUNDLED_D3_REFERENCE_F90: &str =
+    include_str!("../third_party/simple-dftd3/src/dftd3/reference.f90");
+const BUNDLED_D3_R4R2_F90: &str =
+    include_str!("../third_party/simple-dftd3/src/dftd3/data/r4r2.f90");
+
 impl D3Reference {
-    fn from_reference_file(path: &Path) -> Result<Self> {
-        let text = fs::read_to_string(path)?;
-        let clean = strip_fortran_comments(&text);
+    fn from_reference_text(reference_text: &str, r4r2_text: &str) -> Result<Self> {
+        let clean = strip_fortran_comments(reference_text);
         let max_elem = parse_parameter_usize(&clean, "max_elem")?;
         let max_ref = parse_parameter_usize(&clean, "max_ref")?;
         let number_of_references = parse_int_array_after(&clean, "number_of_references")?
@@ -2859,14 +2837,7 @@ impl D3Reference {
                 c6.len()
             )));
         }
-        let r4r2_path = path
-            .parent()
-            .ok_or_else(|| {
-                Gfn1Error::InvalidInput("D3 reference path has no parent directory".to_string())
-            })?
-            .join("data")
-            .join("r4r2.f90");
-        let r4r2 = parse_r4r2_file(&r4r2_path)?;
+        let r4r2 = parse_r4r2_text(r4r2_text)?;
         Ok(Self {
             max_elem,
             max_ref,
@@ -2877,6 +2848,27 @@ impl D3Reference {
         })
     }
 
+    /// Parse the D3 reference from a `reference.f90` file, reading the companion
+    /// `data/r4r2.f90` next to it. Used only when an explicit path or the
+    /// `GFN1_D3_REFERENCE` environment variable overrides the bundled default.
+    fn from_reference_file(path: &Path) -> Result<Self> {
+        let reference_text = fs::read_to_string(path)?;
+        let r4r2_path = path
+            .parent()
+            .ok_or_else(|| {
+                Gfn1Error::InvalidInput("D3 reference path has no parent directory".to_string())
+            })?
+            .join("data")
+            .join("r4r2.f90");
+        let r4r2_text = fs::read_to_string(&r4r2_path)?;
+        Self::from_reference_text(&reference_text, &r4r2_text)
+    }
+
+    /// The D3 reference bundled with the library and embedded at build time.
+    fn bundled() -> Result<Self> {
+        Self::from_reference_text(BUNDLED_D3_REFERENCE_F90, BUNDLED_D3_R4R2_F90)
+    }
+
     fn number_of_references(&self, z: u8) -> Result<usize> {
         self.number_of_references
             .get(z as usize - 1)
@@ -2944,9 +2936,8 @@ fn load_d3_reference(path: &Path) -> Result<Arc<D3Reference>> {
     Ok(loaded)
 }
 
-fn parse_r4r2_file(path: &Path) -> Result<Vec<f64>> {
-    let text = fs::read_to_string(path)?;
-    let clean = strip_fortran_comments(&text);
+fn parse_r4r2_text(text: &str) -> Result<Vec<f64>> {
+    let clean = strip_fortran_comments(text);
     let raw = parse_float_array_after(&clean, "r4_over_r2")?;
     Ok(raw
         .into_iter()
@@ -3082,8 +3073,8 @@ fn push_float_token(out: &mut Vec<f64>, token: &str) -> Result<()> {
 mod tests {
     use super::{
         dispersion_energy, dispersion_energy_gradient, dispersion_energy_gradient_hessian,
-        dispersion_third_derivative, load_d3_reference, reference_weight_cn_derivatives,
-        resolve_d3_reference_path,
+        dispersion_third_derivative, reference_weight_cn_derivatives,
+        resolve_and_load_d3_reference,
     };
     use crate::lattice::Lattice;
     use crate::math::{Mat3, Vec3};
@@ -3152,9 +3143,7 @@ mod tests {
 
     #[test]
     fn bundled_d3_reference_is_available() {
-        let params = Gfn1Parameters::default();
-        let path = resolve_d3_reference_path(&params, None).unwrap();
-        let reference = load_d3_reference(&path).unwrap();
+        let reference = resolve_and_load_d3_reference(None).unwrap();
         assert!(reference.number_of_references(6).unwrap() > 0);
         assert!(reference.r4r2(8).unwrap() > 0.0);
     }

{gfn1_rs_python-0.4.5 → gfn1_rs_python-0.4.6}/src/hessian.rs

@@ -257,6 +257,10 @@ pub fn analytic_hessian_from_result(
     } else {
         None
     };
+    // The assembled Hessian is symmetric in exact arithmetic; average it with its
+    // transpose to remove the small asymmetry left by finite-precision accumulation
+    // across the per-term contributions.
+    symmetrize_in_place(&mut hessian);
     Ok(AnalyticHessianResult {
         hessian,
         repulsion,
@@ -501,6 +505,7 @@ pub fn fixed_density_pulay_hessian(
 /// geometric channels — `part_c_sab` = the `C·S_ab` (overlap-coeff × overlap-2nd-deriv) channel, and
 /// `part_h0` = the `2p·(h0_c·S_r + h0_r·S_c + S·h0_rc)` (h0-derivative) channel. Same loop/weights as
 /// [`fixed_density_pulay_hessian`]; used to FD-attribute the reconverged density-path residual `miss[c]`.
+#[cfg(test)]
 pub(crate) fn fixed_density_pulay_hessian_parts(
     system: &PeriodicSystem,
     params: &Gfn1Parameters,
@@ -578,6 +583,7 @@ pub(crate) fn fixed_density_pulay_hessian_parts(
 /// Their sum is exactly `part_c_sab` from [`fixed_density_pulay_hessian_parts`]. Used to attribute the
 /// reconverged density-path residual `miss_csab` to the P·2h0 / −P·V / −2W sub-channels (the −2W block is
 /// the EWD/W channel; its analytic linearized density-path is `−2·W^(c)·d²S_ab`).
+#[cfg(test)]
 pub(crate) fn fixed_density_pulay_hessian_csab_subparts(
     system: &PeriodicSystem,
     params: &Gfn1Parameters,
@@ -2308,6 +2314,20 @@ fn add_matrix(lhs: &mut Matrix, rhs: &Matrix) -> Result<()> {
     Ok(())
 }
 
+/// Replace a square matrix with `½(H + Hᵀ)`, enforcing exact symmetry on the
+/// final Hessian.
+fn symmetrize_in_place(hessian: &mut Matrix) {
+    let n = hessian.rows();
+    debug_assert_eq!(n, hessian.cols(), "Hessian must be square to symmetrize");
+    for i in 0..n {
+        for j in (i + 1)..n {
+            let avg = 0.5 * (hessian[(i, j)] + hessian[(j, i)]);
+            hessian[(i, j)] = avg;
+            hessian[(j, i)] = avg;
+        }
+    }
+}
+
 type Ten3 = [[[f64; 3]; 3]; 3];
 
 /// `H0` (or bare `poly`) value plus its bra/ket Cartesian derivative tensors up to **third**
@@ -2677,6 +2697,7 @@ pub fn fixed_density_pulay_third_derivative(
 ///
 /// `response_density`=P^(c), `response_ew_density`=W^(c), `response_scalar_potential`=V^(c). Returned
 /// ordered slabs `tensor[c][(a,b)]`. `only_channel`: Some(0)=C:S_ab only, Some(1)=h0 only, None=both.
+#[cfg(test)]
 pub(crate) fn pulay_density_path_geom_cross_ordered(
     system: &PeriodicSystem,
     params: &Gfn1Parameters,
@@ -2816,120 +2837,6 @@ pub(crate) fn pulay_density_path_geom_cross_ordered(
     Ok(tensor)
 }
 
-/// PULAY density-path GEOMETRY×RESPONSE cross term (the missing 3rd-derivative piece). The linearized
-/// density-path `pulay(P^(c),W^(c),V) + [pulay(V+V^(c))−pulay(V)]` reproduces the pulay Hessian with the
-/// RESPONSE coefficient `C^(c) = P^(c)(2h0−V) + P(−V^(c)) − 2W^(c)` and `two_p^(c) = 2P^(c)`, but at FIXED
-/// geometry — it omits the ONE geometry derivative (slab `c`) acting on that already-response coefficient's
-/// overlap / h0 factors. This function supplies exactly that: the geometric slab-`c` derivative of the
-/// pulay Hessian body with the coefficient held at the linear response `(C^(c), two_p^(c))`. Same overlap /
-/// h0 third-derivative machinery and weights as [`fixed_density_pulay_third_derivative`]; the coefficient
-/// is the response, the geometry derivatives are the base geometry. First-order-response only.
-///
-/// `response_density` = P^(c), `response_ew_density` = W^(c), `response_scalar_potential` = V^(c) (the shell
-/// SCC-potential response). Returned ordered slabs `tensor[c][(a,b)]`.
-pub(crate) fn pulay_density_path_geom_cross(
-    system: &PeriodicSystem,
-    params: &Gfn1Parameters,
-    electronic: &ElectronicResult,
-    response_density: &Matrix,
-    response_ew_density: &Matrix,
-    response_scalar_potential: &[f64],
-) -> Result<Vec<Matrix>> {
-    ensure_non_pbc(system)?;
-    let nat = system.atoms.len();
-    let ndof = 3 * nat;
-    let basis = &electronic.basis;
-    let mut tensor = vec![Matrix::zeros(ndof, ndof); ndof];
-    // Base and response AO scalar potentials.
-    let ao_v = ao_scalar_potentials(basis, &electronic.shell_scc_potential);
-    let ao_vc = ao_scalar_potentials(basis, response_scalar_potential);
-
-    for mu in 0..basis.len() {
-        let atom_mu = basis.aos[mu].atom_index;
-        let shell_mu_index = basis.aos[mu].shell_index;
-        let rmu = system.atoms[atom_mu].position;
-        for nu in 0..mu {
-            let atom_nu = basis.aos[nu].atom_index;
-            if atom_mu == atom_nu {
-                continue;
-            }
-            let shell_nu_index = basis.aos[nu].shell_index;
-            let rnu = system.atoms[atom_nu].position;
-            let p = electronic.density[(mu, nu)];
-            let pc = response_density[(mu, nu)];
-            let wc = response_ew_density[(mu, nu)];
-            if p.abs().max(pc.abs()).max(wc.abs()) <= 1.0e-18 {
-                continue;
-            }
-            let pair =
-                contracted_pair_with_third_derivatives(&basis.aos[mu], &basis.aos[nu], rmu, rnu);
-            let overlap = pair.moments[0];
-            let h0 =
-                h0_prefactor_third(system, params, electronic, shell_mu_index, shell_nu_index)?;
-            let scalar_shift = ao_v[mu] + ao_v[nu];
-            let scalar_shift_c = ao_vc[mu] + ao_vc[nu];
-            // Response coefficient: C^(c) = P^(c)(2h0−V) + P(−V^(c)) − 2W^(c); two_p^(c) = 2 P^(c).
-            let overlap_coeff = pc * (2.0 * h0.value - scalar_shift) - p * scalar_shift_c - 2.0 * wc;
-            let two_p = 2.0 * pc;
-
-            let atom_of = |c: Center| match c {
-                Center::Bra => atom_mu,
-                Center::Ket => atom_nu,
-            };
-            let s1 = |c: Center, ax: usize| first(&pair.d_bra[0], &pair.d_ket[0], c, ax);
-            let s2 = |ca: Center, cb: Center, axa: usize, axb: usize| {
-                second(&pair.h_bra_bra[0], &pair.h_bra_ket[0], &pair.h_ket_ket[0], ca, cb, axa, axb)
-            };
-            let h1 = |c: Center, ax: usize| first_vec(h0.d_bra, h0.d_ket, c, ax);
-            let h2 = |ca: Center, cb: Center, axa: usize, axb: usize| {
-                second(&h0.h_bra_bra, &h0.h_bra_ket, &h0.h_ket_ket, ca, cb, axa, axb)
-            };
-            let slot_center = |s: usize| if s < 3 { Center::Bra } else { Center::Ket };
-            let value_of = |i: usize, j: usize, k: usize| -> f64 {
-                let (ca, axa) = (slot_center(i), i % 3);
-                let (cb, axb) = (slot_center(j), j % 3);
-                let (cc, axc) = (slot_center(k), k % 3);
-                let s_abc = third_select(
-                    &pair.t_bra_bra_bra[0], &pair.t_bra_bra_ket[0], &pair.t_bra_ket_ket[0],
-                    &pair.t_ket_ket_ket[0], [ca, cb, cc], [axa, axb, axc],
-                );
-                let h_abc = third_select(
-                    &h0.t_bra_bra_bra, &h0.t_bra_bra_ket, &h0.t_bra_ket_ket,
-                    &h0.t_ket_ket_ket, [ca, cb, cc], [axa, axb, axc],
-                );
-                let (s_a, s_b, s_c) = (s1(ca, axa), s1(cb, axb), s1(cc, axc));
-                let s_ab = s2(ca, cb, axa, axb);
-                let s_ac = s2(ca, cc, axa, axc);
-                let s_bc = s2(cb, cc, axb, axc);
-                let (h_a, h_b, h_c) = (h1(ca, axa), h1(cb, axb), h1(cc, axc));
-                let h_ab = h2(ca, cb, axa, axb);
-                let h_ac = h2(ca, cc, axa, axc);
-                let h_bc = h2(cb, cc, axb, axc);
-                overlap_coeff * s_abc
-                    + two_p
-                        * (overlap * h_abc
-                            + (h_ab * s_c + h_ac * s_b + h_bc * s_a)
-                            + (h_a * s_bc + h_b * s_ac + h_c * s_ab))
-            };
-            let dof = |s: usize| 3 * atom_of(slot_center(s)) + s % 3;
-            for i in 0..6 {
-                for j in i..6 {
-                    for k in j..6 {
-                        let v = value_of(i, j, k);
-                        if v == 0.0 {
-                            continue;
-                        }
-                        for &(pp, qq, rr) in &distinct_perms(i, j, k) {
-                            tensor[dof(rr)][(dof(pp), dof(qq))] += v;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    Ok(tensor)
-}
-
 #[cfg(test)]
 mod third_derivative_tests {
     use super::*;