add 4 new topology cases from Guoxi Liu

eval_cases/topology/topology_cases.yaml

@@ -193,4 +193,115 @@
       value: |
           1. Q1 correct answer: no
           2. Q2 correct answer: (C)
-          3. Q3 correct answer: (C)
+          3. Q3 correct answer: (C)
+
+
+# 6. noisyTerrain
+# This dataset is a terrain with random scalar values added to create noise, originally from Julien Tierny. See https://github.com/topology-tool-kit/ttk-data.
+- vars:
+    question: |    
+          1. Load the dataset from "noisyTerrain/data/noisyTerrain.vtu".
+          2. Compute the persistence diagram on the scalar field named "Blend".
+          3. Apply a threshold to filter out pairs with persistence value less than 1.
+          4. Save the persistence diagram as "noisyTerrain/results/{agent_mode}/noisyTerrain.vtk" in legacy VTK format.
+            - The output should contain the points in the persistence diagram as point data, and each persistence pair is represented as a cell.
+            - Include the following three scalar arrays with the given names and purposes:
+              * "Birth" array: store the birth value of each pair.
+              * "Persistence" array: store the persistence value of each pair.
+              * "IsFinite" array: use 1 to mark finite persistence and 0 to mark infinite persistence.
+  assert:
+    - type: rule_based
+      eval_script: noisyTerrain/GS/noisyTerrain_eval.py
+      eval_function: evaluateNoisyTerrainPersistenceDiagram
+      gs_file: 
+        - noisyTerrain/GS/noisyTerrain_gs.vtk
+      rs_file: 
+        - noisyTerrain/results/{agent_mode}/noisyTerrain.vtk
+
+
+# 7. molecule
+# This dataset contains electron density and reduced gradient for a simple Ethane-Diol molecule, which is originally from Roberto Alvarez Boto. See https://github.com/topology-tool-kit/ttk-data.
+- vars:
+    question: |    
+          1. Load the data file "molecule/data/molecule.vti".
+          2. Compute the Morse-Smale segmentation on the scalar field named "log(s)".
+          3. Save the Morse-Smale segmentation as "molecule/results/{agent_mode}/molecule.vti". 
+          It should have a point array called "Segmentation". 
+          For each point x, the array "Segmentation" should store the id number of the region in the segmentation that x belongs to.
+  assert:
+    - type: rule_based
+      eval_script: molecule/GS/molecule_eval.py
+      eval_function: 
+      gs_file: 
+        - molecule/GS/molecule_gs.vtk
+      rs_file: 
+        - molecule/results/{agent_mode}/molecule.vtk
+
+
+# 8. moons
+# This 2D data set is based on the scikit-learn clustering examples (see https://scikit-learn.org/stable/modules/clustering.html), which computes a density field using Gaussian Resampling on the original point cloud.
+- vars:
+    question: |    
+          1. Load the data file "moons/data/moons.vti".
+          2. Apply topological simplification to the field "SplatterValues" with a persistence threshold of 10.
+          3. Compute the Morse-Smale segmentation on the simplified scalar field.
+          4. Save only the Ascending Manifold as "moons/results/{agent_mode}/moons.vti".
+          It should have a point array called "AscendingManifold". 
+          For each point x, the array "AscendingManifold" should store the id number of the region that x belongs to.
+  assert:
+    - type: rule_based
+      eval_script: moons/GS/moons_eval.py
+      eval_function: evaluateMoonAscendingManifold
+      gs_file: 
+        - moons/GS/moons_gs.vtk
+      rs_file: 
+        - moons/results/{agent_mode}/moons.vtk
+
+
+# 9. dragon
+# The dataset is the scanned dragon model in the ttk-data GitHub repo (https://github.com/topology-tool-kit/ttk-data), originally from VisionAIR (VISION Advanced Infrastructure for Research).
+- vars:
+    question: |    
+        1. Load the dataset from "dragon/data/dragon.vtu".
+
+        2. Compute the Morse-Smale complex on the scalar field named "density". Make sure 1-Separatrices are computed.
+
+        3. Compute the critical points on the previous elevation scalar field. 
+
+        4. Save the critical points as "dragon/results/{agent_mode}/dragon.vtk" in legacy VTK format.
+            - The output should contain the critical points as point dataset
+            - Include an array called "CriticalType" that labels each point according to what type of critical type it is. Use the following convention: 
+                * 0 for minima
+                * 1 for 1-saddles
+                * 2 for 2-saddles
+                * 3 for maxima
+            - The point coordinates should be in world coordinates 
+
+        5. Analyze the visualization and answer the following questions:
+
+        Q1: How many saddle-maximum pairs are present in the dataset? 
+        (A) 2 (B) 4 (C) 6 (D) 10.
+
+        Q2: How many minima are computed?
+        (A) 2 (B) 5 (C) 8 (D) 10.
+
+        Q3: Are there any saddle-saddle pairs in the persistence diagram?
+        (Yes/No)
+
+        Save the answers to the analysis questions in plain text as "dragon/results/{agent_mode}/answers.txt".
+  assert:
+    - type: rule_based
+      eval_script: dragon/GS/dragon_eval.py
+      eval_function: evaluateDragonCriticalPoints
+      gs_file: 
+        - dragon/GS/dragon_gs.vtk
+      rs_file: 
+        - dragon/results/{agent_mode}/dragon.vtk
+    - type: llm-rubric
+      subtype: text
+      value: |
+          1. Q1 correct answer: (C) 6
+
+          2. Q2 correct answer: (B) 5
+
+          3. Q3 correct answer: No

topology/QMCPACK/task_description.txt

@@ -10,4 +10,12 @@
     * 2 for 2-saddles  
     * 3 for maxima
     * 4 for degenerate critical points
-    - The point coordinates should be in index space (grid coordinates), not world coordinates
+    - The point coordinates should be in index space (grid coordinates), not world coordinates
+
+4. Analyze the visualization and answer the following questions:
+    Q1: How many index 1 saddles are there: 
+    (A) 248 (B) 274 (C) 299 (D) 344
+
+    Q2: What is the type of critical point closest to coordinates (4,58,12): 
+    (A) minimum (B) 1-saddle (C) 2-saddle (D) maximum
+Save the answers to the analysis questions in plain text as "QMCPACK/results/{agent_mode}/answers.txt".

topology/brain/task_description.txt

@@ -1,3 +1,9 @@
 1. Load the file "brain/data/brain.vti". It is a symmetric tensor field, where the (1,1), (1,2) and (2,2) components of the tensor are respectively given by the arrays A, B, and D.
 2. Compute degenerate points of the tensor field.
-3. Save the degenerate points as "brain/results/{agent_mode}/brain.vtk" in legacy VTK format. Label the type of degenerate point for each point in an array called DegeneracyType. Use a value of 0 for trisectors and 1 for wedges.
+3. Save the degenerate points as "brain/results/{agent_mode}/brain.vtk" in legacy VTK format. Label the type of degenerate point for each point in an array called DegeneracyType. Use a value of 0 for trisectors and 1 for wedges.
+4. Analyze the visualization and answer the following questions:
+    Q1: Are there more trisectors than wedges? (yes/no)
+
+    Q2: Out of all degenerate points, the sum of one point's coordinates is the highest. What is this highest sum, rounded to the nearest integer?
+    (A) 124 (B) 136 (C) 148 (D) 160
+Save the answers to the analysis questions in plain text as "brain/results/{agent_mode}/answers.txt".

topology/cylinder/task_description.txt

@@ -1,4 +1,11 @@
 1. Please load the file "cylinder/data/cylinder.vti"
 2. Apply persistence simplification of 0.01 to the Speed field.
 3. Compute the Morse-Smale segmentation of the simplified Speed field.
-4. Save the Morse-Smale segmentation as "cylinder/results/{agent_mode}/cylinder.vti". It should have a point array called Partition. For each point x, the array "Partition" should store the id number of the region in the segmentation that x belongs to.
+4. Save the Morse-Smale segmentation as "cylinder/results/{agent_mode}/cylinder.vti". It should have a point array called Partition. For each point x, the array "Partition" should store the id number of the region in the segmentation that x belongs to.
+5. Analyze the visualization and answer the following questions:
+    Q1: How many unique partition regions are there?
+    (A) 152 (B) 163 (C) 174 (D) 185
+
+    Q2: How many points are in the largest partition region?
+    (A) 6879 (B) 7968 (C) 8796 (D) 9687
+Save the answers to the analysis questions in plain text as "cylinder/results/{agent_mode}/answers.txt".

topology/dragon/GS/dragon_eval.py

@@ -0,0 +1,33 @@
+import sys
+import os
+
+# Add the topology directory to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+from topologyScoring import pointCloudGeometryScore
+
+def evaluateDragonCriticalPoints(gtFilename : str, reconFilename : str, verbose : bool = False):
+    """
+    Given two sets of critical points, return a similarity score from 0-10.
+    
+    A score of 0 is considered bad and a score of 10 is considered good.
+
+    Args:
+        gtPointsFile: The name of a file in legacy VTK format (.vtk) that stores the locations of each critical point
+                      in the ground truth data. It should also have a point array called "CriticalType". It should assign
+                      values as follows: 0: minimum. 1: 1-saddle. 2: 2-saddle. 3: maximum. 4: degenerate critical point.
+        reconPointsFile: The name of a file in legacy VTK format (.vtk) that stores the locations and degeneracy types
+                         of each point in the reconstructed data.
+        verbose: Should error messages be printed if there are issues with the input files.
+    """
+    return pointCloudGeometryScore(gtFilename, "CriticalType", reconFilename, "CriticalType", verbose)
+
+if __name__ == "__main__":
+
+    if len(sys.argv) != 3:
+        print(f"{os.path.basename(__file__)}: usage is 'python3 {os.path.basename(__file__)} gt_points.vtk recon_points.vtk'")
+        exit(1)
+
+    score = evaluateDragonCriticalPoints(sys.argv[1], sys.argv[2], verbose=True)
+
+    print(f"These critical points scored: {score}")

topology/dragon/GS/dragon_gs.vtk

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34f548c791a15ab3c72c752009b5cd6924b617ebffe505207014d1d9416c7c45
+size 8156

topology/dragon/task_description.txt

@@ -1,11 +1,19 @@
-Task:
-1. Load the dragon dataset from "dragon/data/dragon.vtu". Apply an elevation function along the y-axis, ranging from 0 to 100. 
+1. Load the dataset from "dragon/data/dragon.vtu".
 
-2. Compute the persistence diagram using the \"elevation\" scalar field. 
+2. Compute the Morse-Smale complex on the scalar field named "density". Make sure 1-Separatrices are computed.
 
-3. After filtering out persistence values less than 10, compute the critical points (e.g., minima, maxima, and saddle points) on the dataset.
+3. Compute the critical points on the previous elevation scalar field. 
 
-4. Analyze the visualization and answer the following questions:
+4. Save the critical points as "dragon/results/{agent_mode}/dragon.vtk" in legacy VTK format.
+    - The output should contain the critical points as point dataset
+    - Include an array called "CriticalType" that labels each point according to what type of critical type it is. Use the following convention: 
+        * 0 for minima
+        * 1 for 1-saddles
+        * 2 for 2-saddles
+        * 3 for maxima
+    - The point coordinates should be in world coordinates 
+
+5. Analyze the visualization and answer the following questions:
 
 Q1: How many saddle-maximum pairs are present in the dataset? 
 (A) 2 (B) 4 (C) 6 (D) 10.
@@ -16,6 +24,4 @@ Q2: How many minima are computed?
 Q3: Are there any saddle-saddle pairs in the persistence diagram?
 (Yes/No)
 
-5. Save your work:
-Save the ParaView state as "dragon/results/{agent_mode}/dragon.pvsm".
 Save the answers to the analysis questions in plain text as "dragon/results/{agent_mode}/answers.txt".

topology/dragon/visualization_goals.txt

@@ -1,13 +0,0 @@
-vision:
-1. Overall visualization quality
-
-2. Correct color mapping for critical points
-
-3. Correct pairing of critical points
-
-text:
-1. Q1 correct answer: (C) 6
-
-2. Q2 correct answer: (B) 5
-
-3. Q3 correct answer: No

topology/isabel/task_description.txt

@@ -6,4 +6,14 @@ This file should have two point arrays. One should be called "CriticalType" and
 It should follow the following convention: 0: minima. 1: 1-saddles. 2: 2-saddles. 3: maxima. 4: degenerate critical points. 
 The other point array should be called "Scalar" and should contain the scalar field value at each point in the merge tree.
 5. Save the edges of the merge tree as "isabel/results/{agent_mode}/isabel_edges.vtk" in legacy VTK format. 
-The file should store each edge as a separate cell with type vtkLine.
+The file should store each edge as a separate cell with type vtkLine.
+6. Analyze the visualization and answer the following questions:
+Q1: The parent node of the leaf (377, 265, 0) has coordinates (x,y,z). What is x+y+z?
+(A) 627 (B) 854 (C) 992 (D) 1039
+
+Q2: How many edges are there in the merge tree?
+(A) 154 (B) 195 (C) 204 (D) 254
+
+Q3: What is the highest scalar field value of a minimum, rounded to the nearest whole number?
+(A) 12 (B) 26 (C) 31 (D) 58
+Save the answers to the analysis questions in plain text as "isabel/results/{agent_mode}/answers.txt".

topology/molecule/GS/molecule_gs.vti

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd16c23afd789bdbe0bdc80227f8bb3064cc187efd430bf8866bd205b0018a5a
+size 9534120

topology/molecule/data/molecule.vti

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1d4cfbd469fbe131ff36790302ea0ba9fd5407472c7b0c8c7990f8db360a1cb
+size 28601738

topology/molecule/task_description.txt

@@ -0,0 +1,5 @@
+1. Load the data file "molecule/data/molecule.vti".
+2. Compute the Morse-Smale segmentation on the scalar field named "log(s)".
+3. Save the Morse-Smale segmentation as "molecule/results/{agent_mode}/molecule.vti". 
+It should have a point array called "Segmentation". 
+For each point x, the array "Segmentation" should store the id number of the region in the segmentation that x belongs to.

topology/moon/GS/moons_eval.py

@@ -0,0 +1,32 @@
+import os
+import sys
+
+# Add the topology directory to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+from topologyScoring import partitionTopologicalDiceScore
+
+def evaluateMoonAscendingManifold(gtFilename : str, reconFilename : str, verbose : bool = False) -> int:
+    """
+    Given two ascending manifolds of the same domain, return a similarity score from 0-10.
+    A score of 0 is considered bad and a score of 10 is considered good. The segmentations should be
+    represented by a point array called "AscendingManifold" that assigs a region identifier to each point in 
+    the domain. The region identifiers between the ground truth and reconstructed files do not need to match. 
+    Args:
+        gtFilename: The name of a file storing VTK image data (.vti) storing the ground truth ascending manifold.
+                    each point's region ID should be stored in a point array called "AscendingManifold".
+        reconFilename: The name of a file storing VTK image data (.vti) storing the reconstructed ascending manifold.
+        verbose: Should error messages be printed if there are issues with the input files.
+    """
+
+    return partitionTopologicalDiceScore(gtFilename, "AscendingManifold", reconFilename, "AscendingManifold", verbose)
+
+if __name__ == "__main__":
+
+    if len(sys.argv) != 3:
+        print(f"{os.path.basename(__file__)}: usage is 'python3 {os.path.basename(__file__)} gt_filename.vti recon_filename.vti")
+        exit(1)
+
+    score = evaluateMoonAscendingManifold(sys.argv[1], sys.argv[2], verbose=True)
+
+    print(f"This ascending manifold scored: {score}")

topology/moon/GS/moons_gs.vti

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a94f60f79a15c79dd8199613d78c0a6cd42a10cf548fc36e3b49cd3cec9f572b
+size 350065

topology/moon/data/moons.vti

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c733c228cf65c44f68c22dfdf1cfee2af8a5725658f370f3255c80ce582df614
+size 699632

topology/moon/task_description.txt

@@ -0,0 +1,6 @@
+1. Load the data file "moons/data/moons.vti".
+2. Apply topological simplification to the field "SplatterValues" with a persistence threshold of 10.
+3. Compute the Morse-Smale segmentation on the simplified scalar field.
+4. Save only the Ascending Manifold as "moons/results/{agent_mode}/moons.vti".
+It should have a point array called "AscendingManifold". 
+For each point x, the array "AscendingManifold" should store the id number of the region that x belongs to.

topology/noisyTerrain/GS/noisyTerrain_eval.py

@@ -0,0 +1,151 @@
+import vtk
+import numpy as np
+import gudhi
+import sys
+import os
+
+# Add the topology directory to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+###############################################################################
+# The following parameters are from `topologyScoring.py` 
+###############################################################################
+# Set to True to allow data that is not perfectly predicted to score a perfect 10.
+# If this is set to False, the highest possible score that an imperfect prediction can score is a 9.
+canImperfectPredictionsScore10 = False
+
+# The order of the Wasserstein distance
+wassersteinOrder = 1.0
+
+# The ground metric used for computing the Wasserstein distance
+wassersteinGroundMetric = float('inf')
+
+# This is the maximum average Wasserstein distance (the average is taken over (|P|+|Q|)/2) that can score points.
+# Any distance above this score will score a 0.
+maximumAverageWassersteinDistance = 0.2
+
+###############################################################################
+# You can integrate the following two functions into `topologyScoring.py` 
+############################################################################### 
+def _loadPersistenceDiagramFromVTK(pdFilename : str) -> np.ndarray:
+    """
+    Load a persistence diagram from a VTK file computed with TTK.
+    
+    Args:
+        pdFilename: The path to the VTK file containing the persistence diagram.
+        
+    Returns:
+        A numpy array of shape (n, 2) where each row is a (birth, death) pair for finite persistence pairs.
+    """
+    reader = vtk.vtkDataSetReader()
+    reader.SetFileName(pdFilename)
+    reader.Update()
+    
+    output = reader.GetOutput()
+    if output is None:
+        raise ValueError(f"Could not read VTK file: {pdFilename}")
+    
+    cellData = output.GetCellData()
+    
+    birthArray = cellData.GetArray("Birth")
+    persistenceArray = cellData.GetArray("Persistence")
+    isFiniteArray = cellData.GetArray("IsFinite")
+    
+    if birthArray is None or persistenceArray is None:
+        raise ValueError(f"VTK file {pdFilename} does not contain required 'Birth' and 'Persistence' arrays")
+    
+    pairs = []
+    numCells = output.GetNumberOfCells()
+    
+    for i in range(numCells):
+        isFinite = isFiniteArray.GetTuple1(i) if isFiniteArray else 1
+        if isFinite:
+            birth = birthArray.GetTuple1(i)
+            persistence = persistenceArray.GetTuple1(i)
+            death = birth + persistence
+            pairs.append((birth, death))
+    
+    return np.array(pairs)
+
+
+# ====== PERSISTENCE DIAGRAM WASSERSTEIN SCORE ======
+
+def persistenceDiagramWassersteinScore(gtFilename : str, reconFilename : str, verbose : bool = False) -> int:
+    """
+    Compute a similarity score (0-10) between two persistence diagrams stored in VTK files using Wasserstein distance.
+    
+    Args:
+        gtFilename: Path to the ground truth persistence diagram VTK file.
+        reconFilename: Path to the reconstructed persistence diagram VTK file.
+        verbose: Whether to print error messages.
+        
+    Returns:
+        An integer score from 0-10 indicating similarity (10 is best).
+    """
+    try:
+        gtDiagram = _loadPersistenceDiagramFromVTK(gtFilename)
+    except Exception as e:
+        if verbose:
+            print(f"Error loading GT diagram: {e}")
+        return 0
+    
+    try:
+        reconDiagram = _loadPersistenceDiagramFromVTK(reconFilename)
+    except Exception as e:
+        if verbose:
+            print(f"Error loading recon diagram: {e}")
+        return 0
+    
+    if len(gtDiagram) == 0 and len(reconDiagram) == 0:
+        return 10
+    elif len(gtDiagram) == 0 or len(reconDiagram) == 0:
+        return 0
+    
+    # Normalize using GT's min-max
+    minFunctionValue = np.min(gtDiagram)
+    maxFunctionValue = np.max(gtDiagram)
+    
+    gtDiagram = (gtDiagram - minFunctionValue) / (maxFunctionValue - minFunctionValue)
+    reconDiagram = (reconDiagram - minFunctionValue) / (maxFunctionValue - minFunctionValue)
+    
+    wassersteinDistance = gudhi.wasserstein.wasserstein_distance(gtDiagram, reconDiagram, order=wassersteinOrder, internal_p=wassersteinGroundMetric)
+    
+    numAverage = (gtDiagram.shape[0] + reconDiagram.shape[0]) / 2
+    wassersteinDistance /= numAverage
+    
+    if wassersteinDistance == 0:
+        return 10
+    
+    score = round(10 * (maximumAverageWassersteinDistance - wassersteinDistance) / maximumAverageWassersteinDistance)
+    
+    if not canImperfectPredictionsScore10 and score == 10:
+        return 9
+    
+    if score < 0:
+        return 0
+    
+    return score
+
+
+def evaluateNoisyTerrainPersistenceDiagram(gtFilename : str, reconFilename : str, verbose : bool = False):
+    """
+    Given two persistence diagrams, return a similarity score from 0-10.
+    
+    A score of 0 is considered bad and a score of 10 is considered good.
+
+    Args:
+        gtFilename: The name of a file in legacy VTK format (.vtk) that stores the persistence diagram of the ground truth data.
+        reconFilename: The name of a file in legacy VTK format (.vtk) that stores the persistence diagram of the reconstructed data.
+        verbose: Should error messages be printed if there are issues with the input files.
+    """
+    return persistenceDiagramWassersteinScore(gtFilename, reconFilename, verbose)
+
+if __name__ == "__main__":
+
+    if len(sys.argv) != 3:
+        print(f"{os.path.basename(__file__)}: usage is 'python3 {os.path.basename(__file__)} gt_points.vtk recon_points.vtk'")
+        exit(1)
+
+    score = evaluateNoisyTerrainPersistenceDiagram(sys.argv[1], sys.argv[2], verbose=True)
+
+    print(f"These critical points scored: {score}")

topology/noisyTerrain/GS/noisyTerrain_gs.vtk

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4382b8fbaaa83b299a8cae5257734f66b8380edce9c9b0febd58e988ec9d209
+size 3603

topology/noisyTerrain/data/noisyTerrain.vtu

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a07febd5f3230c45220d7718fff4a8020b8c6318186fea15cc960f794da502bf
+size 10291578

topology/noisyTerrain/task_description.txt

@@ -0,0 +1,9 @@
+1. Load the dataset from "noisyTerrain/data/noisyTerrain.vtu".
+2. Compute the persistence diagram on the scalar field named "Blend".
+3. Apply a threshold to filter out pairs with persistence value less than 1.
+4. Save the persistence diagram as "noisyTerrain/results/{agent_mode}/noisyTerrain.vtk" in legacy VTK format.
+- The output should contain the points in the persistence diagram as point data, and each persistence pair is represented as a cell.
+- Include the following three scalar arrays with the given names and purposes:
+    * "Birth" array: store the birth value of each pair.
+    * "Persistence" array: store the persistence value of each pair.
+    * "IsFinite" array: use 1 to mark finite persistence and 0 to mark infinite persistence.

topology/ocean/task_description.txt

@@ -14,4 +14,14 @@ It should have a point array called "Partition" that stores the region identifie
 
 6. Save the partition information from the eigenvalue partition as "ocean/results/{agent_mode}/ocean_eigenvalue.vti" as VTK image data. 
 It should have a point array called "Partition" that stores the region identifiers as follows:
-0: positive scaling. 1: counterclockwise rotation. 2: negative scaling. 3: clockwise rotation. 4: anisotropic stretching.
+0: positive scaling. 1: counterclockwise rotation. 2: negative scaling. 3: clockwise rotation. 4: anisotropic stretching.
+
+7. Analyze the visualization and answer the following questions:
+Q1: Are there more trisectors than wedges? (yes/no)
+
+Q2: How many points have the most common classification in the eigenvector partition?
+(A) 752342 (B) 802842 (C) 826348 (D) 994682
+
+Q3: Which is the least common classification in the eigenvalue partition?
+(A) Positive scaling (B) counterclockwise rotation (C) negative scaling (D) clockwise rotation
+Save the answers to the analysis questions in plain text as "ocean/results/{agent_mode}/answers.txt".