split terms into separate table entries

src/rimsschemedrawer/json_parser.py

@@ -277,9 +277,16 @@ def reshuffle_list_low_lying(lst: List) -> List:
             "Step",
             "λ (nm)",
             "From (cm⁻¹)",
-            "To (cm⁻¹)",
         ]
 
+        has_from_term = any(self.step_terms) or self.gs_term
+        has_to_term = any(self.step_terms) or self.ip_term
+        if has_from_term:
+            headers.append("Term")
+        headers.append("To (cm⁻¹)")
+        if has_to_term:
+            headers.append("Term")
+
         first_no_lowlying = np.where(~self._low_lying)[0][0]
 
         steps = np.ones(self.number_of_levels, dtype=int)
@@ -290,45 +297,49 @@ def reshuffle_list_low_lying(lst: List) -> List:
         lambdas = reshuffle_list_low_lying(lambdas)
 
         from_level = ["" for _ in range(self.number_of_levels)]
+        from_term = from_level.copy()
         # add low-lying states
         for it in range(first_no_lowlying):
             tmp_str = f"{self.step_levels[it]:.{prec}f}"
             if term := self.step_terms_html[it]:
-                tmp_str += f" ({term})"
+                from_term[it] = term
             from_level[it] = tmp_str
         # add ground state
         gs = self.gs_level
         if gs == 0:
             tmp_str = "0"
         else:
             tmp_str = f"{gs:.{prec}f}"
-        if term := self.gs_term_html:
-            tmp_str += f" ({term})"
         from_level[first_no_lowlying] = tmp_str
+        if term := self.gs_term_html:
+            from_term[first_no_lowlying] = term
         # add steps
         for it in range(
             first_no_lowlying + 1, self.number_of_levels
         ):  # above ground state
             tmp_str = f"{self.step_levels[it - 1]:.{prec}f}"
             if term := self.step_terms_html[it - 1]:
-                tmp_str += f" ({term})"
+                from_term[it] = term
             from_level[it] = tmp_str
         from_level = reshuffle_list_low_lying(from_level)
+        from_term = reshuffle_list_low_lying(from_term)
 
         to_level = ["" for _ in range(self.number_of_levels)]
+        to_term = to_level.copy()
         # add low-lying states and first step
         for it in range(first_no_lowlying + 1):
             tmp_str = f"{self.step_levels[first_no_lowlying]:.{prec}f}"
             if term := self.step_terms_html[first_no_lowlying]:
-                tmp_str += f" ({term})"
+                to_term[it] = term
             to_level[it] = tmp_str
         # add steps
         for it in range(first_no_lowlying + 1, self.number_of_levels):
             tmp_str = f"{self.step_levels[it]:.{prec}f}"
             if term := self.step_terms_html[it]:
-                tmp_str += f" ({term})"
+                to_term[it] = term
             to_level[it] = tmp_str
         to_level = reshuffle_list_low_lying(to_level)
+        to_term = reshuffle_list_low_lying(to_term)
 
         # forbidden transitions
         if np.any(self.step_forbidden):
@@ -359,8 +370,12 @@ def reshuffle_list_low_lying(lst: List) -> List:
                 str(steps[idx]),
                 lambdas[idx],
                 from_level[idx],
-                to_level[idx],
             ]
+            if has_from_term:
+                row.append(from_term[idx])
+            row.append(to_level[idx])
+            if has_to_term:
+                row.append(to_term[idx])
             if np.any(self.step_forbidden):
                 row.append(forbidden[idx])
             if np.any(self.transition_strengths):

tests/test_scheme_table.py

@@ -23,15 +23,17 @@ def test_ti_new_json(data_path):
         "Step",
         "λ (nm)",
         "From (cm⁻¹)",
+        "Term",
         "To (cm⁻¹)",
+        "Term",
     ]
 
     table_exp = [
-        ["1", "465.777", f"0 ({tts('3F2')})", f"21469.500 ({tts('3G3')})"],
-        ["1", "469.498", f"170.150 ({tts('3F3')})", f"21469.500 ({tts('3G3')})"],
-        ["1", "474.324", f"386.880 ({tts('3F4')})", f"21469.500 ({tts('3G3')})"],
-        ["2", "416.158", f"21469.500 ({tts('3G3')})", f"45498.850 ({tts('3G4')})"],
-        ["3", "881.399", f"45498.850 ({tts('3G4')})", "56844.450"],
+        ["1", "465.777", "0", f"{tts('3F2')}", "21469.500", f"{tts('3G3')}"],
+        ["1", "469.498", "170.150", f"{tts('3F3')}", "21469.500", f"{tts('3G3')}"],
+        ["1", "474.324", "386.880", f"{tts('3F4')}", "21469.500", f"{tts('3G3')}"],
+        ["2", "416.158", "21469.500", f"{tts('3G3')}", "45498.850", f"{tts('3G4')}"],
+        ["3", "881.399", "45498.850", f"{tts('3G4')}", "56844.450", ""],
     ]
 
     header, table = parser.scheme_table()
@@ -63,7 +65,7 @@ def test_raised_ground(data_path):
             f"1000.000 ({tts('5D0')})",
             f"25983.609 ({tts('5F1')})",
             "",
-            "$1.0 \\times 10^{6}$",
+            "1.0 × 10<sup>6</sup>",
         ],
         [
             "2",
@@ -79,7 +81,7 @@ def test_raised_ground(data_path):
             f"50525.354 ({tts('5D2')})",
             f"63480.266 ({tts('AI')})",
             "",
-            "$3.0 \\times 10^{5}$",
+            "3.0 × 10<sup>5</sup>",
         ],
     ]