lno: compatibility with pyscf >= 2.14 (dfccsd._contract_vvvv_t2 signature) and NumPy 2 (_cp) (#212)

* lno: compatibility with pyscf >= 2.14 and NumPy 2 in lnoccsd

- DFLNOCCSD._contract_vvvv_t2: pyscf 2.14 changed dfccsd._contract_vvvv_t2 to a
  seven-argument signature (mycc, mol, vvL, VVL, t2, out, verbose). The old
  six-argument call shifted the arguments, so t2 arrived as out and every
  DF-LNO-CCSD run crashed. The call now adapts to the installed signature.
- _cp: np.array(a, copy=False, ...) raises under NumPy 2 when a copy is
  unavoidable, which it is for an h5py slice on the out-of-core path
  (max_memory below the fragment's Lov block). np.asarray keeps the intended
  behaviour on both NumPy 1 and 2.

Both fixes have been running in production LNO-CCSD(T) calculations on benzene
and naphthalene (cc-pVDZ/cc-pVTZ, pyscf 2.14.0, NumPy 2) since 2026-09-10.

* lno: call dfccsd._contract_vvvv_t2 with its real signature, keep _cp NumPy-2 safe, add a regression test for the DF-CCSD fragment solver

Both fixes sit in the DF-CCSD fragment solver (MODIFIED_DFCCSD / _make_df_eris / _DFChemistsERIs), which lnoccsd.CCSD selects only when a
fragment's vvvv block does not fit in 70 % of the available memory; the shipped water-dimer tests never reach it. Review of 24/25 Sep:
- pyscf's dfccsd._contract_vvvv_t2 has had the VVL argument since at least v2.10, so the six-argument call was wrong for every supported
  version; call it with (mycc, mol, vvL, VVL, t2, out, verbose) unconditionally, no signature inspection, VVL = vvL as in pyscf's own
  _ChemistsERIs.
- _cp: np.asarray(a, order='C') (NumPy 2 raises on copy=False for the non-contiguous Lov slices of the blocked loops).
- test_dfccsd_solver_blocked_df_eris: MODIFIED_DFCCSD on the test's water dimer with max_memory = 1 (forces the blocked loops); fails on
  master with ValueError in _cp, with _cp alone fixed with AttributeError in dfccsd._contract_vvvv_t2, passes with both; e_corr equals
  cc.CCSD on the same DF mean field to 1e-7.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>

Author: thebreadishard

pyscf/lno/lnoccsd.py

@@ -396,7 +396,10 @@ def ao2mo(self, mo_coeff=None):
 class _DFChemistsERIs(_ChemistsERIs):
     def _contract_vvvv_t2(self, mycc, t2, direct=False, out=None, verbose=None):
         assert(not direct)
-        return dfccsd._contract_vvvv_t2(mycc, self.mol, self.vvL, t2, out, verbose)
+        # pyscf's dfccsd._contract_vvvv_t2 is (mycc, mol, vvL, VVL, t2, out=None, verbose=None) -- VVL has been
+        # part of the signature since at least pyscf 2.10; with six arguments t2 arrived as VVL and `out` as t2.
+        # VVL = vvL, as in pyscf.cc.dfccsd._ChemistsERIs.
+        return dfccsd._contract_vvvv_t2(mycc, self.mol, self.vvL, self.vvL, t2, out, verbose)
 def _make_df_eris(cc, mo_coeff=None):
     from pyscf.ao2mo import _ao2mo
 
@@ -467,7 +470,9 @@ def _make_df_eris(cc, mo_coeff=None):
     return eris
 
 def _cp(a):
-    return np.array(a, copy=False, order='C')
+    # NumPy 2 raises on copy=False when a copy is unavoidable (a non-contiguous Lov slice in the
+    # blocked loops of _make_df_eris); np.asarray keeps the NumPy 1.x meaning.
+    return np.asarray(a, order='C')
 
 class MODIFIED_DFCCSD_complex:
     pass

pyscf/lno/test/test_lnoccsd.py

@@ -66,6 +66,21 @@ def tearDownClass(cls):
         cls.mol.stdout.close()
         del cls.mol, cls.mf, cls.ecano, cls.frozen
 
+    def test_dfccsd_solver_blocked_df_eris(self):
+        # The DF-CCSD fragment solver (chosen by lnoccsd.CCSD when a fragment's vvvv block does not fit in
+        # memory, i.e. large fragments or a small max_memory) with the blocked loops of _make_df_eris:
+        # _cp must accept a non-contiguous Lov slice under NumPy 2, and _DFChemistsERIs._contract_vvvv_t2
+        # must call pyscf's dfccsd._contract_vvvv_t2 with its (mycc, mol, vvL, VVL, t2, out, verbose)
+        # signature. Neither path is reached by the LNO tests above on this small system.
+        from pyscf.lno import lnoccsd
+        ref = cc.CCSD(self.mf, frozen=self.frozen).run().e_corr
+        mycc = lnoccsd.MODIFIED_DFCCSD(self.mf, frozen=self.frozen)
+        mycc.max_memory = 1     # forces the blocked loops; the arrays stay small
+        mycc.verbose = 0
+        mycc.kernel()
+        self.assertTrue(mycc.converged)
+        self.assertAlmostEqual(mycc.e_corr, ref, 7)
+
     def test_lno_pm_by_thresh(self):
         mol = self.mol
         mf = self.mf