From 5ab538a2eb599a73b43ee53eea17d036d17e28f6 Mon Sep 17 00:00:00 2001
From: Paul Baksic <paul.baksic@outlook.fr>
Date: Thu, 17 Sep 2026 15:51:08 +0200
Subject: [PATCH 1/7] Add cli option to select type of regression + prepare
 list to know which type of regression it is

---
 .../SofaRegressionProgram.py                  | 23 +++++++++++++++----
 .../tools/RegressionSceneList.py              | 18 +++++++++++++++
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/SofaRegressionProgram/SofaRegressionProgram.py b/SofaRegressionProgram/SofaRegressionProgram.py
index 58d960d..e9de3e5 100644
--- a/SofaRegressionProgram/SofaRegressionProgram.py
+++ b/SofaRegressionProgram/SofaRegressionProgram.py
@@ -16,12 +16,12 @@
 import SofaRuntime # importing SofaRuntime will add the py3 loader to the scene loaders
 import tools.RegressionSceneList as RegressionSceneList
 import tools.RegressionWorker as RegressionWorker
-from tools.RegressionHelper import writeMessage
+from tools.RegressionHelper import writeMessage, writeWarning
 
 regression_file_extension = ".regression-tests"
 
 class RegressionProgram:
-    def __init__(self, input_folders, filter = None, disable_progress_bar = False, verbose = 1, nbr_jobs = 1, logs_output = None):
+    def __init__(self, input_folders, filter = None, reg_type = 'ALL',  disable_progress_bar = False, verbose = 1, nbr_jobs = 1, logs_output = None):
         """Initialize the RegressionProgram
 
         Args:
@@ -46,9 +46,10 @@ def __init__(self, input_folders, filter = None, disable_progress_bar = False, v
             for directory in input_folders :
                 for root, dirs, files in os.walk(directory):
                     for file in files:
-                        if file.endswith(regression_file_extension):
-                            file_path = os.path.join(root, file)
+                        file_path = os.path.join(root, file)
 
+                        #Warning lazy or in the end, if not lazy then this breaks
+                        if file.endswith(regression_file_extension) and (reg_type == 'ALL' or RegressionSceneList.RegressionSceneList.RegressionType[reg_type].value in file) :
                             scene_list = RegressionSceneList.RegressionSceneList(file_path, filter, self.disable_progress_bar, verbose, self.nbr_jobs)
 
                             if err_logs_stream is not None:
@@ -60,6 +61,9 @@ def __init__(self, input_folders, filter = None, disable_progress_bar = False, v
                                 print("", file=err_logs_stream)
 
                             self.scene_sets.append(scene_list)
+                        elif file.endswith(regression_file_extension):
+                            writeWarning(f"Regression file {file_path} skipped because of selected regression type {reg_type}", self.verbose)
+
         finally:
             if self.logs_output is not None :
                 with open(Path(self.logs_output) / "parse_errors_logs.txt", 'w', encoding="utf-8") as summary_file:
@@ -140,6 +144,15 @@ def make_parser():
                         default=[],
                         type=str)
 
+    regression_type_choices = ['ALL', *(reg_type.name for reg_type in RegressionSceneList.RegressionSceneList.RegressionType)]
+    parser.add_argument('--regression-type',
+                        dest='reg_type',
+                        choices=regression_type_choices,
+                        help=f"The regression type from {regression_type_choices}. Default value is ALL.",
+                        type=str,
+                        default='ALL')
+
+
     parser.add_argument('--filter',
                         dest='filter',
                         help="A regex filter to select scenes to test (e.g., '^demo.*.scn$')",
@@ -222,7 +235,7 @@ def make_parser():
 
     # 2- Process file
     if args.input:
-        reg_prog = RegressionProgram(args.input, args.filter, args.progress_bar_is_disabled, verbose, args.jobs, logs_output = args.output)
+        reg_prog = RegressionProgram(args.input, args.filter, args.reg_type, args.progress_bar_is_disabled, verbose, args.jobs, logs_output = args.output)
     else:
         parser.print_help()
         exit("Error: Argument is required ! Quitting.")
diff --git a/SofaRegressionProgram/tools/RegressionSceneList.py b/SofaRegressionProgram/tools/RegressionSceneList.py
index 7b6a3f7..189b8e6 100644
--- a/SofaRegressionProgram/tools/RegressionSceneList.py
+++ b/SofaRegressionProgram/tools/RegressionSceneList.py
@@ -1,21 +1,39 @@
+from enum import Enum
 import os
 import math
 import tools.RegressionSceneData as RegressionSceneData
 import tools.RegressionHelper as helper
 import tools.RegressionWorker as RegressionWorker
 import sys
+from pathlib import Path
 
 import re
 
 ## This class is responsible for loading a file.regression-tests to gather the list of scene to test with all arguments
 ## It will provide the API to launch the tests or write refs on all scenes contained in this file
 class RegressionSceneList:
+
+    class RegressionType(Enum):
+        STATE = "RegressionStateScenes"
+        TOPOLOGY = "RegressionTopologyScenes"
+
+
     def __init__(self, file_path, filter, disable_progress_bar = False, verbose = 1, nbr_jobs = 1):
         """
         /// Path to the file.regression-tests containing the list of scene to tests with all arguments
         std::string filePath;
         """
         self.file_path = file_path
+
+        self.regression_type = None
+        for reg_type in RegressionSceneList.RegressionType:
+           if reg_type.value in Path(self.file_path).name:
+               self.regression_type = reg_type
+               break
+
+        if self.regression_type is None:
+            raise ValueError(f"Regression type {Path(self.file_path).name} not recognize, can be of types {[reg_type.value for reg_type in RegressionSceneList.RegressionType]}.")
+
         self.filter = filter
         self.file_dir = os.path.dirname(file_path)
         self.scenes_data_sets = [] # List<RegressionSceneData>

From 23b020075931f0dd923f88713702e91a80925f8a Mon Sep 17 00:00:00 2001
From: Paul Baksic <paul.baksic@outlook.fr>
Date: Thu, 17 Sep 2026 16:42:46 +0200
Subject: [PATCH 2/7] Started work on adding topology test, need a simple
 factory for sceneData

---
 .../tools/RegressionSceneData.py              | 37 ++++++++++++++++++-
 .../tools/RegressionSceneList.py              |  3 ++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/SofaRegressionProgram/tools/RegressionSceneData.py b/SofaRegressionProgram/tools/RegressionSceneData.py
index 4095a6e..af80b9c 100644
--- a/SofaRegressionProgram/tools/RegressionSceneData.py
+++ b/SofaRegressionProgram/tools/RegressionSceneData.py
@@ -80,12 +80,10 @@ def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps
         self.epsilon = float(epsilon)
         self.meca_in_mapping = bool(meca_in_mapping)
         self.dump_number_step = int(dump_number_step)
-        self.meca_objs = []
         self.filenames = []
         self.mins = []
         self.maxs = []
         self.total_error = []
-        self.error_by_dof = []
         self.nbr_tested_frame = 0
         self.regression_failed = False
         self.root_node = None
@@ -97,6 +95,39 @@ def print_info(self):
         helper.writeLog("Test scene: " + self.file_scene_path + " vs " + self.file_ref_path + " using: " + str(self.steps)
               + " " + str(self.epsilon), self.verbose)
 
+    def log_errors(self, log_prefix='', err_log_stream=None):
+        pass
+
+    def apply_worker_result(self, result):
+        pass
+
+    def parse_node(self, node, level = 0):
+        pass
+
+    def load_scene(self, format = "JSON"):
+        pass
+
+    def write_references(self, format = "JSON"):
+        pass
+
+    def compare_references(self, format = "JSON"):
+        pass
+
+    def compare_legacy_references(self):
+        pass
+
+    def is_replay_available(self):
+        return False
+
+class StateRegressionSceneData(RegressionSceneData):
+    def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps = 1000,
+                 epsilon = 0.0001, meca_in_mapping = True, dump_number_step = 1, disable_progress_bar = False, verbose = 1):
+
+        RegressionSceneData.__init__(self, file_scene_path, file_ref_path, steps, epsilon, meca_in_mapping, dump_number_step, disable_progress_bar, verbose)
+
+        self.meca_objs = []
+        self.error_by_dof = []
+
     def log_errors(self, log_prefix='', err_log_stream=None):
         if self.regression_failed:
             helper.writeError(
@@ -541,6 +572,8 @@ def compare_legacy_references(self):
 
         return True
 
+    def is_replay_available(self):
+        return True
 
     def replay_references(self):
 
diff --git a/SofaRegressionProgram/tools/RegressionSceneList.py b/SofaRegressionProgram/tools/RegressionSceneList.py
index 189b8e6..a522a86 100644
--- a/SofaRegressionProgram/tools/RegressionSceneList.py
+++ b/SofaRegressionProgram/tools/RegressionSceneList.py
@@ -319,6 +319,9 @@ def compare_references(self, id_scene):
     def compare_all_references(self):
         return self._run_tasks("compare", "Compare all scenes from: " + self.file_path)
 
+    def is_replay_available(self):
+        #TODO check if sceneData type is able to do it
+        return True
 
     def replay_references(self, id_scene):
         if (id_scene < 0 or id_scene >= len(self.scenes_data_sets)):

From 324cfe8caf80ec1f95176fd6bebaabfff2716be6 Mon Sep 17 00:00:00 2001
From: Paul Baksic <paul.baksic@outlook.fr>
Date: Fri, 18 Sep 2026 10:47:19 +0200
Subject: [PATCH 3/7] make the worker agnostic from regression type

---
 .../SofaRegressionProgram.py                  | 10 +++++--
 .../tools/RegressionSceneData.py              | 28 +++++++++++++++++--
 .../tools/RegressionSceneList.py              | 15 +++++-----
 .../tools/RegressionWorker.py                 | 27 ++++++++++++------
 4 files changed, 58 insertions(+), 22 deletions(-)

diff --git a/SofaRegressionProgram/SofaRegressionProgram.py b/SofaRegressionProgram/SofaRegressionProgram.py
index e9de3e5..a9b470d 100644
--- a/SofaRegressionProgram/SofaRegressionProgram.py
+++ b/SofaRegressionProgram/SofaRegressionProgram.py
@@ -37,6 +37,7 @@ def __init__(self, input_folders, filter = None, reg_type = 'ALL',  disable_prog
         self.legacy_mode = False
         self.nbr_jobs = RegressionWorker.resolve_nbr_jobs(nbr_jobs)
         self.logs_output = logs_output
+        self.reg_type = reg_type
 
         err_logs_stream = None
         if self.logs_output is not None :
@@ -49,7 +50,7 @@ def __init__(self, input_folders, filter = None, reg_type = 'ALL',  disable_prog
                         file_path = os.path.join(root, file)
 
                         #Warning lazy or in the end, if not lazy then this breaks
-                        if file.endswith(regression_file_extension) and (reg_type == 'ALL' or RegressionSceneList.RegressionSceneList.RegressionType[reg_type].value in file) :
+                        if file.endswith(regression_file_extension) and (reg_type == 'ALL' or RegressionSceneList.RegressionSceneList.RegressionType[reg_type].value[0] in file) :
                             scene_list = RegressionSceneList.RegressionSceneList(file_path, filter, self.disable_progress_bar, verbose, self.nbr_jobs)
 
                             if err_logs_stream is not None:
@@ -124,8 +125,11 @@ def compare_all_sets_references(self):
         return self.run_all_sets("compare", "Compare All sets")
 
     def replay_references(self, id_scene, id_set=0):
-        scene_list = self.scene_sets[id_set]
-        scene_list.replay_references(id_scene)
+        if(self.scene_sets[id_set].regression_type is not None and self.scene_sets[id_set].regression_type.value[1].is_replay_available()):
+            scene_list = self.scene_sets[id_set]
+            scene_list.replay_references(id_scene)
+        else:
+            raise ValueError(f"Replay is not available for regression type {self.scene_sets[id_set].regression_type}")
 
 
 
diff --git a/SofaRegressionProgram/tools/RegressionSceneData.py b/SofaRegressionProgram/tools/RegressionSceneData.py
index af80b9c..093094b 100644
--- a/SofaRegressionProgram/tools/RegressionSceneData.py
+++ b/SofaRegressionProgram/tools/RegressionSceneData.py
@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 import time
 import numpy as np
 import pathlib
@@ -116,8 +117,6 @@ def compare_references(self, format = "JSON"):
     def compare_legacy_references(self):
         pass
 
-    def is_replay_available(self):
-        return False
 
 class StateRegressionSceneData(RegressionSceneData):
     def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps = 1000,
@@ -572,7 +571,8 @@ def compare_legacy_references(self):
 
         return True
 
-    def is_replay_available(self):
+    @staticmethod
+    def is_replay_available():
         return True
 
     def replay_references(self):
@@ -585,3 +585,25 @@ def replay_references(self):
         Sofa.Gui.GUIManager.SetDimension(1920, 1080)
         Sofa.Gui.GUIManager.MainLoop(self.root_node)
         Sofa.Gui.GUIManager.closeGUI()
+
+class TopologyRegressionSceneData(RegressionSceneData):
+
+    @dataclass
+    class TopologyError():
+        edges_error : list[float]
+        triangle_error : list[float]
+        quad_error : list[float]
+        tetra_error : list[float]
+        hexa_error : list[float]
+
+    def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps = 1000,
+                 epsilon = 0.0001, meca_in_mapping = True, dump_number_step = 1, disable_progress_bar = False, verbose = 1):
+
+        RegressionSceneData.__init__(self, file_scene_path, file_ref_path, steps, epsilon, meca_in_mapping, dump_number_step, disable_progress_bar, verbose)
+
+        self.topology = []
+        self.error_topology = TopologyRegressionSceneData.TopologyError
+
+    @staticmethod
+    def is_replay_available():
+        return False
diff --git a/SofaRegressionProgram/tools/RegressionSceneList.py b/SofaRegressionProgram/tools/RegressionSceneList.py
index a522a86..3fdebb5 100644
--- a/SofaRegressionProgram/tools/RegressionSceneList.py
+++ b/SofaRegressionProgram/tools/RegressionSceneList.py
@@ -14,8 +14,8 @@
 class RegressionSceneList:
 
     class RegressionType(Enum):
-        STATE = "RegressionStateScenes"
-        TOPOLOGY = "RegressionTopologyScenes"
+        STATE = ("RegressionStateScenes", RegressionSceneData.StateRegressionSceneData)
+        TOPOLOGY = ("RegressionTopologyScenes", RegressionSceneData.TopologyRegressionSceneData)
 
 
     def __init__(self, file_path, filter, disable_progress_bar = False, verbose = 1, nbr_jobs = 1):
@@ -27,12 +27,12 @@ def __init__(self, file_path, filter, disable_progress_bar = False, verbose = 1,
 
         self.regression_type = None
         for reg_type in RegressionSceneList.RegressionType:
-           if reg_type.value in Path(self.file_path).name:
+           if reg_type.value[0] in Path(self.file_path).name:
                self.regression_type = reg_type
                break
 
         if self.regression_type is None:
-            raise ValueError(f"Regression type {Path(self.file_path).name} not recognize, can be of types {[reg_type.value for reg_type in RegressionSceneList.RegressionType]}.")
+            raise ValueError(f"Regression type {Path(self.file_path).name} not recognize, can be of types {[reg_type.value[0] for reg_type in RegressionSceneList.RegressionType]}.")
 
         self.filter = filter
         self.file_dir = os.path.dirname(file_path)
@@ -173,7 +173,7 @@ def parse_scene_line(self, values, line_number, err_log_stream = None):
 
         full_ref_file_path = os.path.normpath(os.path.join(self.ref_dir_path, values[0]))
 
-        return RegressionSceneData.RegressionSceneData(full_file_path, full_ref_file_path,
+        return self.regression_type.value[1](full_file_path, full_ref_file_path,
                                                        steps, epsilon, meca_in_mapping, dump_number_step,
                                                        self.disable_progress_bar, self.verbose)
 
@@ -320,8 +320,9 @@ def compare_all_references(self):
         return self._run_tasks("compare", "Compare all scenes from: " + self.file_path)
 
     def is_replay_available(self):
-        #TODO check if sceneData type is able to do it
-        return True
+        if self.regression_type is not None:
+            return self.regression_type.value[1].is_replay_available()
+        return False
 
     def replay_references(self, id_scene):
         if (id_scene < 0 or id_scene >= len(self.scenes_data_sets)):
diff --git a/SofaRegressionProgram/tools/RegressionWorker.py b/SofaRegressionProgram/tools/RegressionWorker.py
index 1aa1b6d..cb6e964 100644
--- a/SofaRegressionProgram/tools/RegressionWorker.py
+++ b/SofaRegressionProgram/tools/RegressionWorker.py
@@ -53,7 +53,7 @@ def _safe_remove(path):
 # --------------------------------------------------
 # Parent side: spawn one child process for one scene
 # --------------------------------------------------
-def run_scene_in_subprocess(scene_data, mode, legacy=False,
+def run_scene_in_subprocess(scene_data, mode, scene_list = None, legacy=False,
                             disable_progress_bar=False, verbose=1,
                             format="JSON", python_exe=None,
                             capture_output=False):
@@ -92,6 +92,7 @@ def run_scene_in_subprocess(scene_data, mode, legacy=False,
         "--ref", str(scene_data.file_ref_path),
         "--steps", str(scene_data.steps),
         "--epsilon", repr(scene_data.epsilon),
+        "--regression-type", scene_list.regression_type.name,
         "--meca-in-mapping", "1" if scene_data.meca_in_mapping else "0",
         "--dump-number-step", str(scene_data.dump_number_step),
         "--format", format,
@@ -198,6 +199,7 @@ def _run(task):
             task["scene_data"],
             mode=task["mode"],
             legacy=task.get("legacy", False),
+            scene_list= task["scene_list"],
             # In parallel the per-step progress bars of the children are
             # captured along with their output: they would only produce noise.
             disable_progress_bar=disable_progress_bar or nbr_jobs > 1,
@@ -260,8 +262,9 @@ def _run(task):
                     executor.shutdown(wait=False, cancel_futures=True)
                     raise
     finally:
-        with open(Path(logs_output) / "run_errors_logs.txt", 'w', encoding="utf-8") as error_logs_file:
-            error_logs_file.write(stream_out.getvalue())
+        if logs_output is not None:
+            with open(Path(logs_output) / "run_errors_logs.txt", 'w', encoding="utf-8") as error_logs_file:
+                error_logs_file.write(stream_out.getvalue())
 
     return len(tasks)
 
@@ -276,6 +279,7 @@ def _make_worker_parser():
     parser.add_argument("--ref", required=True)
     parser.add_argument("--steps", type=int, required=True)
     parser.add_argument("--epsilon", type=float, required=True)
+    parser.add_argument("--regression-type", dest="regression_type", type=str, required=True)
     parser.add_argument("--meca-in-mapping", dest="meca_in_mapping", choices=["0", "1"], required=True)
     parser.add_argument("--dump-number-step", dest="dump_number_step", type=int, required=True)
     parser.add_argument("--format", default="JSON")
@@ -307,8 +311,13 @@ def _worker_main():
         import Sofa
         import SofaRuntime  # noqa: F401  (registers the py3 scene loader)
         import tools.RegressionSceneData as RegressionSceneData
+        import tools.RegressionSceneList as RegressionSceneList
+        import numpy as np
 
-        scene = RegressionSceneData.RegressionSceneData(
+        np.set_printoptions(legacy='1.25') # revert printing floating-point type in numpy (concretely remove np.array when displaying a list of np.float)
+
+
+        scene = RegressionSceneList.RegressionSceneList.RegressionType[args.regression_type].value[1](
             file_scene_path=args.scene,
             file_ref_path=args.ref,
             steps=args.steps,
@@ -333,13 +342,13 @@ def _worker_main():
             result = {
                 "ok": True,
                 "result": bool(passed),
-                "regression_failed": bool(scene.regression_failed),
-                "nbr_tested_frame": int(scene.nbr_tested_frame),
-                "total_run_time": int(scene.total_run_time),
-                "error_by_dof": [float(v) for v in scene.error_by_dof],
-                "total_error": [float(v) for v in scene.total_error],
                 "error": None,
+                **scene.__dict__
             }
+            ## Remove data that break json
+            result.__delitem__("meca_objs")
+            result.__delitem__("root_node")
+
     except Exception as e:
         import traceback
         result = {"ok": False, "error": str(e), "traceback": traceback.format_exc()}

From 4f3818914772a5b31312d187fb0aa1f80b3bcc1e Mon Sep 17 00:00:00 2001
From: Paul Baksic <paul.baksic@outlook.fr>
Date: Fri, 18 Sep 2026 17:08:25 +0200
Subject: [PATCH 4/7] Add legacy and new reference files version

---
 .../tools/ReferenceFileIO.py                  |  71 ++++
 .../tools/RegressionSceneData.py              | 383 +++++++++++++++++-
 .../tools/RegressionWorker.py                 |   8 +-
 3 files changed, 458 insertions(+), 4 deletions(-)

diff --git a/SofaRegressionProgram/tools/ReferenceFileIO.py b/SofaRegressionProgram/tools/ReferenceFileIO.py
index cd014e8..77cfe0c 100644
--- a/SofaRegressionProgram/tools/ReferenceFileIO.py
+++ b/SofaRegressionProgram/tools/ReferenceFileIO.py
@@ -137,3 +137,74 @@ def read_legacy_reference(filename, mechanical_object):
         )
 
     return times, values
+
+# --------------------------------------------------
+# Helper: read the legacy topology reference format
+# --------------------------------------------------
+# Written by the former C++ WriteTopology component, one block per timestep:
+#   T= <time>
+#     Edges= <nbr>
+#   <nbr edges, 2 ints each, space separated, on one line (blank if nbr==0)>
+#     Triangles= <nbr>
+#   <...>
+#     Quads= <nbr>
+#   <...>
+#     Tetrahedra= <nbr>
+#   <...>
+#     Hexahedra= <nbr>
+#   <...>
+_legacy_topology_categories = (
+    ("Edges=", "edges", 2),
+    ("Triangles=", "triangles", 3),
+    ("Quads=", "quads", 4),
+    ("Tetrahedra=", "tetrahedra", 4),
+    ("Hexahedra=", "hexahedra", 8),
+)
+
+
+def read_legacy_topology_reference(filename):
+    times = []
+    values = []
+    current_entry = None
+
+    with gzip.open(filename, "rt") as f:
+        for line in f:
+            stripped = line.strip()
+            if not stripped:
+                continue
+
+            if stripped.startswith("T="):
+                if current_entry is not None:
+                    values.append(current_entry)
+                times.append(float(stripped.split("=", 1)[1]))
+                current_entry = {key: [] for _, key, _ in _legacy_topology_categories}
+                continue
+
+            for label, key, arity in _legacy_topology_categories:
+                if not stripped.startswith(label):
+                    continue
+
+                nbr = int(stripped.split("=", 1)[1].strip())
+                if nbr > 0:
+                    raw = next(f).split()
+                    if len(raw) != nbr * arity:
+                        raise ValueError(
+                            f"Legacy topology reference corrupted in {filename}: "
+                            f"expected {nbr * arity} values for '{key}', got {len(raw)}"
+                        )
+                    current_entry[key] = [
+                        tuple(int(v) for v in raw[i * arity:(i + 1) * arity])
+                        for i in range(nbr)
+                    ]
+                break
+
+    if current_entry is not None:
+        values.append(current_entry)
+
+    if len(times) != len(values):
+        raise RuntimeError(
+            f"Legacy topology reference corrupted in {filename}: "
+            f"{len(times)} times vs {len(values)} entries"
+        )
+
+    return times, values
diff --git a/SofaRegressionProgram/tools/RegressionSceneData.py b/SofaRegressionProgram/tools/RegressionSceneData.py
index 093094b..bb4cee8 100644
--- a/SofaRegressionProgram/tools/RegressionSceneData.py
+++ b/SofaRegressionProgram/tools/RegressionSceneData.py
@@ -588,6 +588,10 @@ def replay_references(self):
 
 class TopologyRegressionSceneData(RegressionSceneData):
 
+    # Categories checked by the legacy CompareTopology visitor, in the order
+    # they were written to the reference files.
+    topology_categories = ("edges", "triangles", "quads", "tetrahedra", "hexahedra")
+
     @dataclass
     class TopologyError():
         edges_error : list[float]
@@ -602,8 +606,385 @@ def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps
         RegressionSceneData.__init__(self, file_scene_path, file_ref_path, steps, epsilon, meca_in_mapping, dump_number_step, disable_progress_bar, verbose)
 
         self.topology = []
-        self.error_topology = TopologyRegressionSceneData.TopologyError
+        # Kept as flat, individually JSON-serializable attributes (rather than
+        # inside a TopologyError instance) so they survive the trip through
+        # the isolated worker subprocess: see error_topology below.
+        self.edges_error = []
+        self.triangle_error = []
+        self.quad_error = []
+        self.tetra_error = []
+        self.hexa_error = []
+
+    @property
+    def error_topology(self):
+        """Convenience read-only view combining the per-category error lists
+        into a single TopologyError. Built on demand (never stored) so that
+        it never ends up in self.__dict__, which the worker subprocess
+        serializes to JSON to report results back - a TopologyError instance
+        itself is not JSON-serializable."""
+        return TopologyRegressionSceneData.TopologyError(
+            self.edges_error, self.triangle_error, self.quad_error, self.tetra_error, self.hexa_error
+        )
 
     @staticmethod
     def is_replay_available():
         return False
+
+    def log_errors(self, log_prefix='', err_log_stream=None):
+        if self.regression_failed:
+            helper.writeError(
+                                f"{self.file_scene_path} | Number of key frames compared: {self.nbr_tested_frame} | run time: {self.total_run_time/1e9} seconds. "
+                                f"\n    ### Errors by topology container:"
+                                f"\n        Edges: {self.error_topology.edges_error}"
+                                f"\n        Triangles: {self.error_topology.triangle_error}"
+                                f"\n        Quads: {self.error_topology.quad_error}"
+                                f"\n        Tetrahedra: {self.error_topology.tetra_error}"
+                                f"\n        Hexahedra: {self.error_topology.hexa_error}"
+                                f"\n    ### Total Error: {self.total_error} > Threshold: {self.epsilon}",
+                                self.verbose,
+                                log_prefix,
+                                err_log_stream = err_log_stream
+                            )
+        elif self.nbr_tested_frame == 0:
+            helper.writeError(f"No frames were tested for {self.file_scene_path}",
+                              self.verbose,
+                              log_prefix,
+                              err_log_stream = err_log_stream)
+        else:
+            helper.writeSuccess(f"{self.file_scene_path} | Number of key frames compared: {self.nbr_tested_frame} | run time: {self.total_run_time/1e9} seconds. ",
+                                self.verbose,
+                                log_prefix)
+
+    def apply_worker_result(self, result):
+        """Copy the fields reported by an isolated worker process back onto this
+        object so that log_errors() and error counting behave as if the scene had
+        been compared in-process."""
+        self.regression_failed = bool(result.get("regression_failed", False))
+        self.nbr_tested_frame = int(result.get("nbr_tested_frame", 0))
+        self.total_run_time = result.get("total_run_time", 0)
+        self.total_error = result.get("total_error", [])
+        self.edges_error = result.get("edges_error", [])
+        self.triangle_error = result.get("triangle_error", [])
+        self.quad_error = result.get("quad_error", [])
+        self.tetra_error = result.get("tetra_error", [])
+        self.hexa_error = result.get("hexa_error", [])
+
+
+    def parse_node(self, node, level = 0):
+        # Mirrors CompareTopologyCreator::processNodeTopDown: only a topology
+        # container attached directly to this node is considered (not one
+        # inherited from a parent), so the same physical container is never
+        # tested twice through two different nodes.
+        topo = node.getMeshTopology(Sofa.Core.BaseContext.SearchDirection.Local)
+        if topo is not None and (self.meca_in_mapping is True or is_mapped(node) is False):
+                self.topology.append(topo)
+                helper.writeLog("  " * level + f"- Adding Topology: {topo.name.value} from Node: {node.name.value}", self.verbose)
+
+        # recursively check children
+        for child in node.children:
+            self.parse_node(child, level + 1)
+
+
+    @staticmethod
+    def _get_topology_state(topo):
+        """Snapshot of a BaseMeshTopology's element containers, read directly
+        through the python bindings (no WriteTopology/ReadTopology component
+        added to the scene)."""
+        return {
+            "edges": [tuple(topo.getEdge(i)) for i in range(topo.getNbEdges())],
+            "triangles": [tuple(topo.getTriangle(i)) for i in range(topo.getNbTriangles())],
+            "quads": [tuple(topo.getQuad(i)) for i in range(topo.getNbQuads())],
+            "tetrahedra": [tuple(topo.getTetrahedron(i)) for i in range(topo.getNbTetrahedra())],
+            "hexahedra": [tuple(topo.getHexahedron(i)) for i in range(topo.getNbHexahedra())],
+        }
+
+
+    @staticmethod
+    def _compare_topology_states(ref_state, current_state):
+        """Reproduce CompareTopology::processCompareTopology: for each
+        category, a count mismatch adds the absolute difference in count as
+        the error; otherwise every element is compared and each mismatching
+        one adds 1. A reference count of 0 means the category was never
+        recorded for this frame (the legacy writer always writes the count,
+        even when null, but the legacy reader/comparator only acts on it when
+        non-zero), so it is skipped rather than compared against 0.
+        """
+        errors = {}
+        for category in TopologyRegressionSceneData.topology_categories:
+            ref_elements = ref_state.get(category, [])
+            ref_count = len(ref_elements)
+
+            if ref_count == 0:
+                errors[category] = 0
+                continue
+
+            cur_elements = current_state[category]
+            cur_count = len(cur_elements)
+
+            if ref_count != cur_count:
+                errors[category] = abs(ref_count - cur_count)
+            else:
+                errors[category] = sum(
+                    1 for ref_elem, cur_elem in zip(ref_elements, cur_elements)
+                    if list(ref_elem) != list(cur_elem)
+                )
+        return errors
+
+
+    def load_scene(self, format = "JSON"):
+        helper.writeLog(f"Loading scene: {self.file_scene_path}", self.verbose)
+        self.root_node = Sofa.Simulation.load(self.file_scene_path)
+        if not self.root_node: # error while loading
+            raise RuntimeError(f"While trying to load {self.file_scene_path}")
+        else:
+            helper.writeLog("Initializing root node", self.verbose)
+            Sofa.Simulation.initRoot(self.root_node)
+
+            # prepare ref files per topology container:
+            self.parse_node(self.root_node, 0)
+            counter = 0
+            for topo in self.topology:
+                if format != "JSON":
+                    raise ValueError(f"Unsupported format for TOPOLOGY regression: {format}")
+                _filename = self.file_ref_path + ".reference_topology_" + str(counter) + "_" + topo.name.value + ".json.gz"
+                self.filenames.append(_filename)
+                counter = counter + 1
+
+
+    def write_references(self, format = "JSON"):
+        if format != "JSON":
+            raise ValueError(f"Unsupported format for TOPOLOGY regression: {format}")
+
+        pbar_simu = pbh.ProgressBarHandler(total=self.steps, disable=self.disable_progress_bar)
+        pbar_simu.set_description("Simulate: " + self.file_scene_path)
+
+        dt = self.root_node.dt.value
+        nbr_topo = len(self.topology)
+        numpy_data = [dict() for _ in range(nbr_topo)] # List<map>
+
+        # The legacy WriteTopology component listens to AnimateBeginEvent, the
+        # same event used by topology-mutating components (e.g.
+        # TopologicalChangeProcessor). Since those are dispatched first, by
+        # the time WriteTopology records the topology for time step*dt, any
+        # change scheduled at that same time has already been applied. We
+        # reproduce this by sampling right after the animate() call that
+        # advances the simulation to step*dt, rather than before it.
+        for step in range(self.steps):
+            Sofa.Simulation.animate(self.root_node, dt)
+            pbar_simu.update(1)
+
+            t = dt * step
+            for topo_id in range(nbr_topo):
+                numpy_data[topo_id][t] = TopologyRegressionSceneData._get_topology_state(self.topology[topo_id])
+
+        pbar_simu.close()
+
+        # write reference files
+        for topo_id in range(nbr_topo):
+            output_file = pathlib.Path(self.filenames[topo_id])
+            output_file.parent.mkdir(exist_ok=True, parents=True)
+            reference_io.write_JSON_reference_file(self.filenames[topo_id], numpy_data[topo_id])
+
+        Sofa.Simulation.unload(self.root_node)
+
+
+    def compare_references(self, format = "JSON"):
+        if format != "JSON":
+            helper.writeError(f"Unsupported format: {format}", self.verbose)
+            raise ValueError(f"Unsupported format: {format}")
+
+        pbar_simu = pbh.ProgressBarHandler(total=float(self.steps), disable=self.disable_progress_bar)
+        pbar_simu.set_description("compare_references: " + self.file_scene_path)
+
+        nbr_topo = len(self.topology)
+
+        # Reference data
+        keyframes = [] # shared timeline
+        numpy_data = [] # List<map>
+
+        # Outputs init
+        self.total_error = [0.0] * nbr_topo
+        self.edges_error = [0.0] * nbr_topo
+        self.triangle_error = [0.0] * nbr_topo
+        self.quad_error = [0.0] * nbr_topo
+        self.tetra_error = [0.0] * nbr_topo
+        self.hexa_error = [0.0] * nbr_topo
+        self.nbr_tested_frame = 0
+        self.regression_failed = False
+
+        # --------------------------------------------------
+        # Load reference files
+        # --------------------------------------------------
+        for topo_id in range(nbr_topo):
+            try:
+                decoded_array, decoded_keyframes = reference_io.read_JSON_reference_file(self.filenames[topo_id])
+            except KeyError as e:
+                e.add_note(f"Missing metadata key {e} in reference file: {self.file_ref_path}")
+                raise
+            numpy_data.append(decoded_array)
+
+            # Keep timeline from first topology container
+            if topo_id == 0:
+                keyframes = decoded_keyframes
+
+        # --------------------------------------------------
+        # Simulation + comparison
+        # --------------------------------------------------
+        nbr_frames = len(keyframes)
+        dt = self.root_node.dt.value
+
+        if nbr_frames != self.steps:
+            helper.writeWarning(f"Number of frames saved in reference file ({nbr_frames}) does not match the number of required steps ({self.steps})", self.verbose)
+
+        for step in range(self.steps):
+            start_time = time.time_ns()
+            Sofa.Simulation.animate(self.root_node, dt)
+            self.total_run_time += time.time_ns() - start_time
+
+            pbar_simu.update(1)
+
+            # Sample right after animate(): see the comment in write_references()
+            # for why this mirrors the legacy AnimateBeginEvent-based sampling.
+            if step < nbr_frames:
+                for topo_id in range(nbr_topo):
+                    ref_state = numpy_data[topo_id][str(keyframes[step])]
+                    current_state = TopologyRegressionSceneData._get_topology_state(self.topology[topo_id])
+
+                    errors = TopologyRegressionSceneData._compare_topology_states(ref_state, current_state)
+
+                    helper.writeLog(
+                        f"{step} | {self.topology[topo_id].name.value} | errors: {errors}",
+                        self.verbose
+                    )
+
+                    self.error_topology.edges_error[topo_id] += errors["edges"]
+                    self.error_topology.triangle_error[topo_id] += errors["triangles"]
+                    self.error_topology.quad_error[topo_id] += errors["quads"]
+                    self.error_topology.tetra_error[topo_id] += errors["tetrahedra"]
+                    self.error_topology.hexa_error[topo_id] += errors["hexahedra"]
+
+                    self.total_error[topo_id] += sum(errors.values())
+
+                self.nbr_tested_frame += 1
+        pbar_simu.close()
+
+        # Final regression returns value
+        for topo_id in range(nbr_topo):
+            if not np.isfinite(self.total_error[topo_id]):
+                self.regression_failed = True
+                return False
+            if self.total_error[topo_id] > self.epsilon:
+                self.regression_failed = True
+                return False
+
+        return True
+
+
+    def compare_legacy_references(self):
+        pbar_simu = pbh.ProgressBarHandler(total=float(self.steps), disable=self.disable_progress_bar)
+        pbar_simu.set_description("compare_legacy_references: " + self.file_scene_path)
+
+        nbr_topo = len(self.topology)
+
+        # Reference data
+        ref_times = []  # shared timeline
+        ref_values = [] # List[List[dict category -> list[tuple]]]
+
+        self.total_error = [0.0] * nbr_topo
+        self.edges_error = [0.0] * nbr_topo
+        self.triangle_error = [0.0] * nbr_topo
+        self.quad_error = [0.0] * nbr_topo
+        self.tetra_error = [0.0] * nbr_topo
+        self.hexa_error = [0.0] * nbr_topo
+        self.nbr_tested_frame = 0
+        self.regression_failed = False
+
+        if nbr_topo == 0:
+            self.regression_failed = True
+            return False
+
+        # --------------------------------------------------
+        # Load legacy reference files
+        # --------------------------------------------------
+        for topo_id in range(nbr_topo):
+            legacy_filename = (self.file_ref_path + ".reference_" + str(topo_id) + "_"
+                                + self.topology[topo_id].name.value + "_topology.txt.gz")
+            try:
+                times, values = reference_io.read_legacy_topology_reference(legacy_filename)
+            except Exception as e:
+                e.add_note(
+                        f"While reading legacy topology references for container "
+                        f"'{self.topology[topo_id].name.value}'"
+                    )
+                raise
+
+            # Keep timeline from first topology container
+            if topo_id == 0:
+                ref_times = times
+            else:
+                if len(times) != len(ref_times):
+                    raise ValueError(
+                        f"Reference timeline mismatch for file {self.file_scene_path}, "
+                        f"Topology {topo_id}",
+                        self.verbose
+                    )
+
+            ref_values.append(values)
+
+        # --------------------------------------------------
+        # Simulation + comparison
+        # --------------------------------------------------
+        frame_step = 0
+        nbr_frames = len(ref_times)
+        dt = self.root_node.dt.value
+
+        if nbr_frames != self.steps:
+            helper.writeWarning(f"Number of steps saved in reference file ({nbr_frames}) does not match the number of required steps ({self.steps})", self.verbose)
+
+        for step in range(self.steps):
+            Sofa.Simulation.animate(self.root_node, dt)
+            pbar_simu.update(1)
+
+            # Sample right after animate(): see the comment in write_references()
+            # for why this mirrors the legacy AnimateBeginEvent-based sampling.
+            simu_time = dt * step
+
+            # Use tolerance for float comparison
+            if frame_step < nbr_frames and abs(simu_time - ref_times[frame_step]) < dt / 2.0:
+                for topo_id in range(nbr_topo):
+                    ref_state = ref_values[topo_id][frame_step]
+                    current_state = TopologyRegressionSceneData._get_topology_state(self.topology[topo_id])
+
+                    errors = TopologyRegressionSceneData._compare_topology_states(ref_state, current_state)
+
+                    helper.writeLog(
+                        f"    {step} | {self.topology[topo_id].name.value} | errors: {errors}",
+                        self.verbose
+                    )
+
+                    self.error_topology.edges_error[topo_id] += errors["edges"]
+                    self.error_topology.triangle_error[topo_id] += errors["triangles"]
+                    self.error_topology.quad_error[topo_id] += errors["quads"]
+                    self.error_topology.tetra_error[topo_id] += errors["tetrahedra"]
+                    self.error_topology.hexa_error[topo_id] += errors["hexahedra"]
+
+                    self.total_error[topo_id] += sum(errors.values())
+
+                frame_step += 1
+                self.nbr_tested_frame += 1
+
+                # security exit if simulation steps exceed nbr_frames
+                if frame_step == nbr_frames:
+                    break
+        pbar_simu.close()
+
+        # Final regression returns value
+        for topo_id in range(nbr_topo):
+            if not np.isfinite(self.total_error[topo_id]):
+                self.regression_failed = True
+                return False
+            if self.total_error[topo_id] > self.epsilon:
+                self.regression_failed = True
+                return False
+
+        return True
diff --git a/SofaRegressionProgram/tools/RegressionWorker.py b/SofaRegressionProgram/tools/RegressionWorker.py
index cb6e964..1e2284e 100644
--- a/SofaRegressionProgram/tools/RegressionWorker.py
+++ b/SofaRegressionProgram/tools/RegressionWorker.py
@@ -345,9 +345,11 @@ def _worker_main():
                 "error": None,
                 **scene.__dict__
             }
-            ## Remove data that break json
-            result.__delitem__("meca_objs")
-            result.__delitem__("root_node")
+            ## Remove data that break json. Not every regression type carries
+            ## every one of these attributes (e.g. TopologyRegressionSceneData
+            ## has no "meca_objs"), so remove them only if present.
+            for key in ("meca_objs", "root_node", "topology", "error_topology"):
+                result.pop(key, None)
 
     except Exception as e:
         import traceback

From 52eb82fdd5330d139821f3fc31fcf24ea109f27a Mon Sep 17 00:00:00 2001
From: Paul Baksic <paul.baksic@outlook.fr>
Date: Mon, 21 Sep 2026 15:22:40 +0200
Subject: [PATCH 5/7] Only one list remaining to change for new element types

---
 .../tools/ReferenceFileIO.py                  |   4 +-
 .../tools/RegressionSceneData.py              | 100 +++++-------------
 .../tools/RegressionWorker.py                 |   2 +-
 3 files changed, 31 insertions(+), 75 deletions(-)

diff --git a/SofaRegressionProgram/tools/ReferenceFileIO.py b/SofaRegressionProgram/tools/ReferenceFileIO.py
index 77cfe0c..8a8f2db 100644
--- a/SofaRegressionProgram/tools/ReferenceFileIO.py
+++ b/SofaRegressionProgram/tools/ReferenceFileIO.py
@@ -82,7 +82,7 @@ def read_JSON_reference_file(file_path):
         keyframes = []
         for key in decoded_array:
             keyframes.append(float(key))
-    
+
         return decoded_array, keyframes
 
 # --------------------------------------------------
@@ -109,7 +109,7 @@ def read_legacy_reference(filename, mechanical_object):
             if line.startswith("T="):
                 current_time = float(line.split("=", 1)[1])
                 times.append(current_time)
-         
+
             # Positions
             elif line.startswith("X="):
                 if current_time is None:
diff --git a/SofaRegressionProgram/tools/RegressionSceneData.py b/SofaRegressionProgram/tools/RegressionSceneData.py
index bb4cee8..2fa445b 100644
--- a/SofaRegressionProgram/tools/RegressionSceneData.py
+++ b/SofaRegressionProgram/tools/RegressionSceneData.py
@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+import dataclasses
 import time
 import numpy as np
 import pathlib
@@ -590,41 +590,20 @@ class TopologyRegressionSceneData(RegressionSceneData):
 
     # Categories checked by the legacy CompareTopology visitor, in the order
     # they were written to the reference files.
-    topology_categories = ("edges", "triangles", "quads", "tetrahedra", "hexahedra")
+    topology_categories = (("edge", "edges"), ("edge", "triangles"), ("quad", "quads"),
+                           ("tetrahedron", "tetrahedra"), ("hexahedron", "hexahedra"),
+                           ("prism", "prisms"), ("pyramid", "pyramids"))
+    #When the support is complete
+    # "quadratic_edges", "quadratic_triangles", "quadratic_quads", "quadratic_tetrahedra", "quadratic_hexahedra", "quadratic_prisms", "quadratic_pyramids"
 
-    @dataclass
-    class TopologyError():
-        edges_error : list[float]
-        triangle_error : list[float]
-        quad_error : list[float]
-        tetra_error : list[float]
-        hexa_error : list[float]
 
     def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps = 1000,
                  epsilon = 0.0001, meca_in_mapping = True, dump_number_step = 1, disable_progress_bar = False, verbose = 1):
 
         RegressionSceneData.__init__(self, file_scene_path, file_ref_path, steps, epsilon, meca_in_mapping, dump_number_step, disable_progress_bar, verbose)
 
+        self.error_topology = {elemType[1] : [] for elemType in TopologyRegressionSceneData.topology_categories}
         self.topology = []
-        # Kept as flat, individually JSON-serializable attributes (rather than
-        # inside a TopologyError instance) so they survive the trip through
-        # the isolated worker subprocess: see error_topology below.
-        self.edges_error = []
-        self.triangle_error = []
-        self.quad_error = []
-        self.tetra_error = []
-        self.hexa_error = []
-
-    @property
-    def error_topology(self):
-        """Convenience read-only view combining the per-category error lists
-        into a single TopologyError. Built on demand (never stored) so that
-        it never ends up in self.__dict__, which the worker subprocess
-        serializes to JSON to report results back - a TopologyError instance
-        itself is not JSON-serializable."""
-        return TopologyRegressionSceneData.TopologyError(
-            self.edges_error, self.triangle_error, self.quad_error, self.tetra_error, self.hexa_error
-        )
 
     @staticmethod
     def is_replay_available():
@@ -632,14 +611,14 @@ def is_replay_available():
 
     def log_errors(self, log_prefix='', err_log_stream=None):
         if self.regression_failed:
+            body = ""
+            for topo_type in TopologyRegressionSceneData.topology_categories:
+                if len(self.error_topology[topo_type[1]]) > 0 :
+                    body += f"\n        {topo_type[1].replace('_',' ').capitalize()}: {self.error_topology[topo_type[1]]}"
             helper.writeError(
                                 f"{self.file_scene_path} | Number of key frames compared: {self.nbr_tested_frame} | run time: {self.total_run_time/1e9} seconds. "
                                 f"\n    ### Errors by topology container:"
-                                f"\n        Edges: {self.error_topology.edges_error}"
-                                f"\n        Triangles: {self.error_topology.triangle_error}"
-                                f"\n        Quads: {self.error_topology.quad_error}"
-                                f"\n        Tetrahedra: {self.error_topology.tetra_error}"
-                                f"\n        Hexahedra: {self.error_topology.hexa_error}"
+                                f"{body}"
                                 f"\n    ### Total Error: {self.total_error} > Threshold: {self.epsilon}",
                                 self.verbose,
                                 log_prefix,
@@ -662,12 +641,8 @@ def apply_worker_result(self, result):
         self.regression_failed = bool(result.get("regression_failed", False))
         self.nbr_tested_frame = int(result.get("nbr_tested_frame", 0))
         self.total_run_time = result.get("total_run_time", 0)
-        self.total_error = result.get("total_error", [])
-        self.edges_error = result.get("edges_error", [])
-        self.triangle_error = result.get("triangle_error", [])
-        self.quad_error = result.get("quad_error", [])
-        self.tetra_error = result.get("tetra_error", [])
-        self.hexa_error = result.get("hexa_error", [])
+        self.error_topology = result.get("error_topology", {})
+
 
 
     def parse_node(self, node, level = 0):
@@ -690,14 +665,7 @@ def _get_topology_state(topo):
         """Snapshot of a BaseMeshTopology's element containers, read directly
         through the python bindings (no WriteTopology/ReadTopology component
         added to the scene)."""
-        return {
-            "edges": [tuple(topo.getEdge(i)) for i in range(topo.getNbEdges())],
-            "triangles": [tuple(topo.getTriangle(i)) for i in range(topo.getNbTriangles())],
-            "quads": [tuple(topo.getQuad(i)) for i in range(topo.getNbQuads())],
-            "tetrahedra": [tuple(topo.getTetrahedron(i)) for i in range(topo.getNbTetrahedra())],
-            "hexahedra": [tuple(topo.getHexahedron(i)) for i in range(topo.getNbHexahedra())],
-        }
-
+        return {topo_type[1] : [tuple(topo.__getattribute__(f"get{topo_type[0].capitalize()}")(i)) for i in range(topo.__getattribute__(f"getNb{topo_type[1].capitalize()}")())] for topo_type in TopologyRegressionSceneData.topology_categories}
 
     @staticmethod
     def _compare_topology_states(ref_state, current_state):
@@ -711,20 +679,20 @@ def _compare_topology_states(ref_state, current_state):
         """
         errors = {}
         for category in TopologyRegressionSceneData.topology_categories:
-            ref_elements = ref_state.get(category, [])
+            ref_elements = ref_state.get(category[1], [])
             ref_count = len(ref_elements)
 
             if ref_count == 0:
-                errors[category] = 0
+                errors[category[1]] = 0
                 continue
 
-            cur_elements = current_state[category]
+            cur_elements = current_state[category[1]]
             cur_count = len(cur_elements)
 
             if ref_count != cur_count:
-                errors[category] = abs(ref_count - cur_count)
+                errors[category[1]] = abs(ref_count - cur_count)
             else:
-                errors[category] = sum(
+                errors[category[1]] = sum(
                     1 for ref_elem, cur_elem in zip(ref_elements, cur_elements)
                     if list(ref_elem) != list(cur_elem)
                 )
@@ -804,11 +772,8 @@ def compare_references(self, format = "JSON"):
 
         # Outputs init
         self.total_error = [0.0] * nbr_topo
-        self.edges_error = [0.0] * nbr_topo
-        self.triangle_error = [0.0] * nbr_topo
-        self.quad_error = [0.0] * nbr_topo
-        self.tetra_error = [0.0] * nbr_topo
-        self.hexa_error = [0.0] * nbr_topo
+        for topo_type in self.error_topology:
+            self.error_topology[topo_type] = [0.0] * nbr_topo
         self.nbr_tested_frame = 0
         self.regression_failed = False
 
@@ -857,11 +822,8 @@ def compare_references(self, format = "JSON"):
                         self.verbose
                     )
 
-                    self.error_topology.edges_error[topo_id] += errors["edges"]
-                    self.error_topology.triangle_error[topo_id] += errors["triangles"]
-                    self.error_topology.quad_error[topo_id] += errors["quads"]
-                    self.error_topology.tetra_error[topo_id] += errors["tetrahedra"]
-                    self.error_topology.hexa_error[topo_id] += errors["hexahedra"]
+                    for topo_type in self.error_topology:
+                        self.error_topology[topo_type][topo_id] += errors[topo_type]
 
                     self.total_error[topo_id] += sum(errors.values())
 
@@ -891,11 +853,8 @@ def compare_legacy_references(self):
         ref_values = [] # List[List[dict category -> list[tuple]]]
 
         self.total_error = [0.0] * nbr_topo
-        self.edges_error = [0.0] * nbr_topo
-        self.triangle_error = [0.0] * nbr_topo
-        self.quad_error = [0.0] * nbr_topo
-        self.tetra_error = [0.0] * nbr_topo
-        self.hexa_error = [0.0] * nbr_topo
+        for topo_type in self.error_topology:
+            self.error_topology[topo_type] = [0.0] * nbr_topo
         self.nbr_tested_frame = 0
         self.regression_failed = False
 
@@ -962,11 +921,8 @@ def compare_legacy_references(self):
                         self.verbose
                     )
 
-                    self.error_topology.edges_error[topo_id] += errors["edges"]
-                    self.error_topology.triangle_error[topo_id] += errors["triangles"]
-                    self.error_topology.quad_error[topo_id] += errors["quads"]
-                    self.error_topology.tetra_error[topo_id] += errors["tetrahedra"]
-                    self.error_topology.hexa_error[topo_id] += errors["hexahedra"]
+                    for topo_type in self.error_topology:
+                        self.error_topology[topo_type][topo_id] += errors[topo_type]
 
                     self.total_error[topo_id] += sum(errors.values())
 
diff --git a/SofaRegressionProgram/tools/RegressionWorker.py b/SofaRegressionProgram/tools/RegressionWorker.py
index 1e2284e..6c749c1 100644
--- a/SofaRegressionProgram/tools/RegressionWorker.py
+++ b/SofaRegressionProgram/tools/RegressionWorker.py
@@ -348,7 +348,7 @@ def _worker_main():
             ## Remove data that break json. Not every regression type carries
             ## every one of these attributes (e.g. TopologyRegressionSceneData
             ## has no "meca_objs"), so remove them only if present.
-            for key in ("meca_objs", "root_node", "topology", "error_topology"):
+            for key in ("meca_objs", "root_node", "topology"):
                 result.pop(key, None)
 
     except Exception as e:

From f2b0499f292218712ffe4465f92aaaa87638369f Mon Sep 17 00:00:00 2001
From: Paul Baksic <30337881+bakpaul@users.noreply.github.com>
Date: Tue, 22 Sep 2026 14:22:39 +0200
Subject: [PATCH 6/7] Apply batched suggestions from code review

Co-authored-by: erik pernod <erik.pernod@gmail.com>
---
 SofaRegressionProgram/tools/ReferenceFileIO.py     | 10 +++++-----
 SofaRegressionProgram/tools/RegressionSceneData.py |  8 +-------
 2 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/SofaRegressionProgram/tools/ReferenceFileIO.py b/SofaRegressionProgram/tools/ReferenceFileIO.py
index 8a8f2db..b5448f1 100644
--- a/SofaRegressionProgram/tools/ReferenceFileIO.py
+++ b/SofaRegressionProgram/tools/ReferenceFileIO.py
@@ -144,15 +144,15 @@ def read_legacy_reference(filename, mechanical_object):
 # Written by the former C++ WriteTopology component, one block per timestep:
 #   T= <time>
 #     Edges= <nbr>
-#   <nbr edges, 2 ints each, space separated, on one line (blank if nbr==0)>
+#   <raw edges list, 2 ints each, space separated, on one line (blank if nbr==0)>
 #     Triangles= <nbr>
-#   <...>
+#   <raw triangles list, 3 ints each, space separated, on one line (blank if nbr==0)>
 #     Quads= <nbr>
-#   <...>
+#   <raw quads list, 4 ints each, space separated, on one line (blank if nbr==0)>
 #     Tetrahedra= <nbr>
-#   <...>
+#   <raw tetrahedra list, 4 ints each, space separated, on one line (blank if nbr==0)>
 #     Hexahedra= <nbr>
-#   <...>
+#   <raw hexahedra list, 8 ints each, space separated, on one line (blank if nbr==0)>
 _legacy_topology_categories = (
     ("Edges=", "edges", 2),
     ("Triangles=", "triangles", 3),
diff --git a/SofaRegressionProgram/tools/RegressionSceneData.py b/SofaRegressionProgram/tools/RegressionSceneData.py
index 2fa445b..41268c0 100644
--- a/SofaRegressionProgram/tools/RegressionSceneData.py
+++ b/SofaRegressionProgram/tools/RegressionSceneData.py
@@ -730,13 +730,7 @@ def write_references(self, format = "JSON"):
         nbr_topo = len(self.topology)
         numpy_data = [dict() for _ in range(nbr_topo)] # List<map>
 
-        # The legacy WriteTopology component listens to AnimateBeginEvent, the
-        # same event used by topology-mutating components (e.g.
-        # TopologicalChangeProcessor). Since those are dispatched first, by
-        # the time WriteTopology records the topology for time step*dt, any
-        # change scheduled at that same time has already been applied. We
-        # reproduce this by sampling right after the animate() call that
-        # advances the simulation to step*dt, rather than before it.
+        # Store the topology structure at each time step to catch potential topological changes during the simulation
         for step in range(self.steps):
             Sofa.Simulation.animate(self.root_node, dt)
             pbar_simu.update(1)

From f0f51bea5d835314a4d2c0852fa2888dc4e46a84 Mon Sep 17 00:00:00 2001
From: Paul Baksic <paul.baksic@outlook.fr>
Date: Tue, 22 Sep 2026 14:41:20 +0200
Subject: [PATCH 7/7] Take @epernod ocmments on topology state into acocunt

---
 SofaRegressionProgram/tools/RegressionSceneData.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/SofaRegressionProgram/tools/RegressionSceneData.py b/SofaRegressionProgram/tools/RegressionSceneData.py
index 41268c0..e9679fa 100644
--- a/SofaRegressionProgram/tools/RegressionSceneData.py
+++ b/SofaRegressionProgram/tools/RegressionSceneData.py
@@ -661,14 +661,14 @@ def parse_node(self, node, level = 0):
 
 
     @staticmethod
-    def _get_topology_state(topo):
+    def _get_topology_structure(topo):
         """Snapshot of a BaseMeshTopology's element containers, read directly
         through the python bindings (no WriteTopology/ReadTopology component
         added to the scene)."""
         return {topo_type[1] : [tuple(topo.__getattribute__(f"get{topo_type[0].capitalize()}")(i)) for i in range(topo.__getattribute__(f"getNb{topo_type[1].capitalize()}")())] for topo_type in TopologyRegressionSceneData.topology_categories}
 
     @staticmethod
-    def _compare_topology_states(ref_state, current_state):
+    def _compare_topology_structure(ref_state, current_state):
         """Reproduce CompareTopology::processCompareTopology: for each
         category, a count mismatch adds the absolute difference in count as
         the error; otherwise every element is compared and each mismatching
@@ -737,7 +737,7 @@ def write_references(self, format = "JSON"):
 
             t = dt * step
             for topo_id in range(nbr_topo):
-                numpy_data[topo_id][t] = TopologyRegressionSceneData._get_topology_state(self.topology[topo_id])
+                numpy_data[topo_id][t] = TopologyRegressionSceneData._get_topology_structure(self.topology[topo_id])
 
         pbar_simu.close()
 
@@ -807,9 +807,9 @@ def compare_references(self, format = "JSON"):
             if step < nbr_frames:
                 for topo_id in range(nbr_topo):
                     ref_state = numpy_data[topo_id][str(keyframes[step])]
-                    current_state = TopologyRegressionSceneData._get_topology_state(self.topology[topo_id])
+                    current_state = TopologyRegressionSceneData._get_topology_structure(self.topology[topo_id])
 
-                    errors = TopologyRegressionSceneData._compare_topology_states(ref_state, current_state)
+                    errors = TopologyRegressionSceneData._compare_topology_structure(ref_state, current_state)
 
                     helper.writeLog(
                         f"{step} | {self.topology[topo_id].name.value} | errors: {errors}",
@@ -906,9 +906,9 @@ def compare_legacy_references(self):
             if frame_step < nbr_frames and abs(simu_time - ref_times[frame_step]) < dt / 2.0:
                 for topo_id in range(nbr_topo):
                     ref_state = ref_values[topo_id][frame_step]
-                    current_state = TopologyRegressionSceneData._get_topology_state(self.topology[topo_id])
+                    current_state = TopologyRegressionSceneData._get_topology_structure(self.topology[topo_id])
 
-                    errors = TopologyRegressionSceneData._compare_topology_states(ref_state, current_state)
+                    errors = TopologyRegressionSceneData._compare_topology_structure(ref_state, current_state)
 
                     helper.writeLog(
                         f"    {step} | {self.topology[topo_id].name.value} | errors: {errors}",