Tests: xTB parser

Author: alongd

arc/parser/parser_test.py

@@ -732,10 +732,12 @@ def test_parse_1d_scan_energies(self):
                                       8.397974544321187, 7.071194090611243, 5.214457982623571, 3.4362612986915337,
                                       1.958199294316728, 0.8766536693692615, 0.22504856466548517,
                                       0.0004629911018128041])
+        # Length-matched: 44 energies -> 44 angles (step = 360/(n+1) = 8 deg)
+        self.assertEqual(len(angles_3), len(energies_3))
         self.assertEqual(angles_3, [0.0, 8.0, 16.0, 24.0, 32.0, 40.0, 48.0, 56.0, 64.0, 72.0, 80.0, 88.0, 96.0,
                                     104.0, 112.0, 120.0, 128.0, 136.0, 144.0, 152.0, 160.0, 168.0, 176.0, 184.0, 192.0,
                                     200.0, 208.0, 216.0, 224.0, 232.0, 240.0, 248.0, 256.0, 264.0, 272.0, 280.0, 288.0,
-                                    296.0, 304.0, 312.0, 320.0, 328.0, 336.0, 344.0, 352.0])
+                                    296.0, 304.0, 312.0, 320.0, 328.0, 336.0, 344.0])
 
         path_4 = os.path.join(ARC_TESTING_PATH, 'rotor_scans', 'orca', 'cc.txt')
         energies_4, angles_4 = parser.parse_1d_scan_energies(log_file_path=path_4)
@@ -1000,6 +1002,81 @@ def test_parse_active_space(self):
                                                               xyz="""N      0.0   0.0    0.0"""))
         self.assertEqual(active, {'e_o': (5, 4), 'occ': [3, 1, 1, 0, 1, 0, 0, 0], 'closed': [1, 0, 0, 0, 0, 0, 0, 0]})
 
+    # ----- xTB-specific improvements -----
+
+    def test_xtb_logfile_contains_errors(self):
+        """xTB error detection should return None for clean files."""
+        from arc.parser.adapters.xtb import XTBParser
+        clean_path = os.path.join(ARC_TESTING_PATH, 'sp', 'NCC_xTB.out')
+        adapter = XTBParser(log_file_path=clean_path)
+        self.assertIsNone(adapter.logfile_contains_errors())
+
+    def test_xtb_parse_e_elect_avoids_false_match(self):
+        """parse_e_elect should not match 'total energy gain' lines from optimization deltas.
+
+        The CO2_xtb.out file contains both 'total energy gain : -0.1724555 Eh' (delta)
+        and ':: total energy -10.308452243026 Eh' (final). The parser must return the
+        final value, not the delta.
+        """
+        from arc.constants import E_h_kJmol
+        path = os.path.join(ARC_TESTING_PATH, 'freq', 'CO2_xtb.out')
+        e_elect = parser.parse_e_elect(path)
+        self.assertAlmostEqual(e_elect, -10.308452243026 * E_h_kJmol, places=3)
+        # Make sure we did NOT pick up the delta value
+        delta_value = -0.1724555 * E_h_kJmol  # ~-452 kJ/mol
+        self.assertNotAlmostEqual(e_elect, delta_value, places=1)
+
+    def test_xtb_parse_frequencies_takes_last_block(self):
+        """parse_frequencies should return the LAST eigval block.
+
+        TS_NH2+N2H3_xtb.out prints frequencies twice. Both blocks should be identical;
+        if the parser stops after the first block, it would still get the right values,
+        but using the last block is more robust against truncated/duplicate blocks.
+        """
+        path = os.path.join(ARC_TESTING_PATH, 'freq', 'TS_NH2+N2H3_xtb.out')
+        freqs = parser.parse_frequencies(log_file_path=path)
+        self.assertIsNotNone(freqs)
+        # Imaginary frequency should be the first non-zero one
+        self.assertAlmostEqual(freqs[0], -781.89, places=1)
+        # Last frequency
+        self.assertAlmostEqual(freqs[-1], 3467.59, places=1)
+        # 24 modes total (3*8 - 6 = 18 + 6 zero = 24, but only 18 non-zero in TS)
+        self.assertEqual(len(freqs), 18)
+
+    def test_xtb_parse_zpe_correction_regex(self):
+        """parse_zpe_correction uses regex to find ZPE in scientific notation safely."""
+        from arc.constants import E_h_kJmol
+        path = os.path.join(ARC_TESTING_PATH, 'freq', 'TS_NH2+N2H3_xtb.out')
+        zpe = parser.parse_zpe_correction(log_file_path=path)
+        self.assertIsNotNone(zpe)
+        self.assertAlmostEqual(zpe, 0.056690417480 * E_h_kJmol, places=3)
+
+    def test_xtb_parse_1d_scan_energies_length_match(self):
+        """Energies and angles returned by parse_1d_scan_energies must have matching lengths."""
+        path = os.path.join(ARC_TESTING_PATH, 'rotor_scans', 'xtb_1', 'output.out')
+        energies, angles = parser.parse_1d_scan_energies(log_file_path=path)
+        self.assertIsNotNone(energies)
+        self.assertIsNotNone(angles)
+        self.assertEqual(len(energies), len(angles))
+        # First angle = 0, all angles strictly increasing
+        self.assertEqual(angles[0], 0.0)
+        for i in range(1, len(angles)):
+            self.assertGreater(angles[i], angles[i - 1])
+        # All angles should be in [0, 360)
+        self.assertLess(angles[-1], 360.0)
+
+    def test_xtb_parse_geometry_resets_on_new_block(self):
+        """parse_geometry should not accumulate atoms across multiple geometry blocks.
+
+        For CO2_xtb.out (Turbomol $coord with 3 atoms), the parser should return
+        exactly 3 atoms, not 6 or more even if the file mentions multiple blocks.
+        """
+        path = os.path.join(ARC_TESTING_PATH, 'freq', 'CO2_xtb.out')
+        xyz = parser.parse_geometry(log_file_path=path)
+        self.assertIsNotNone(xyz)
+        self.assertEqual(len(xyz['symbols']), 3)
+        self.assertEqual(xyz['symbols'], ('O', 'C', 'O'))
+
 
     def test_parse_opt_steps(self):
         """Test parsing the number of optimization steps from various ESS output files."""