[#1164] Fix Monte Carlo nested dispersion application

Apply Monte Carlo modifications through a nested path resolver instead of
using setattr() on the full path string. Support dotted attributes, integer
list indices, and existing zero-argument accessor paths such as
get_DynModel().scObject.hub.r_CN_NInit without using eval or exec.

Parse archived string values back into Python values before applying them,
route saved RNGSeed updates through the same helper, and only record seed
modifications for models that expose RNGSeed.

Add focused unit coverage for nested attribute updates, method-call accessor
paths, archived RNGSeed application before configureFunction, and generated
UniformDispersion values reaching the live simulation object.

Author: schaubh

src/utilities/MonteCarlo/Controller.py

@@ -899,11 +899,11 @@ def __call__(cls, params):
     @staticmethod
     def _parseAttributePath(attributeString):
         """
-        Split a nested attribute path into attribute names and integer indices.
+        Split a nested attribute path into accessors and integer indices.
 
         :param attributeString: Attribute path to parse.
         :type attributeString: str
-        :return: Parsed attribute names and list indices.
+        :return: Parsed attribute names, zero-argument method calls, and list indices.
         :rtype: list
         """
         if not isinstance(attributeString, str) or attributeString == "":
@@ -948,6 +948,31 @@ def _parseAttributePath(attributeString):
 
         return pathParts
 
+    @staticmethod
+    def _resolvePathPart(currentObj, pathPart):
+        """
+        Resolve one intermediate Monte Carlo path part.
+
+        :param currentObj: Object where this path part starts.
+        :param pathPart: Attribute name, zero-argument method call, or integer index.
+        :return: The object resolved by ``pathPart``.
+        """
+        if isinstance(pathPart, int):
+            return currentObj[pathPart]
+
+        if pathPart.endswith("()"):
+            methodName = pathPart[:-2]
+            if not methodName.isidentifier():
+                raise ValueError(
+                    "Only zero-argument method calls are supported in Monte Carlo paths"
+                )
+            method = getattr(currentObj, methodName)
+            if not callable(method):
+                raise ValueError("Monte Carlo path method part is not callable")
+            return method()
+
+        return getattr(currentObj, pathPart)
+
     @staticmethod
     def parseModificationValue(value):
         """
@@ -981,14 +1006,13 @@ def setNestedAttr(cls, obj, attrString, value):
         currentObj = obj
 
         for pathPart in pathParts[:-1]:
-            if isinstance(pathPart, int):
-                currentObj = currentObj[pathPart]
-            else:
-                currentObj = getattr(currentObj, pathPart)
+            currentObj = cls._resolvePathPart(currentObj, pathPart)
 
         finalPathPart = pathParts[-1]
         if isinstance(finalPathPart, int):
             currentObj[finalPathPart] = value
+        elif finalPathPart.endswith("()"):
+            raise ValueError("Monte Carlo paths cannot assign to method calls")
         else:
             setattr(currentObj, finalPathPart, value)
 

src/utilities/MonteCarlo/README.md

@@ -54,9 +54,11 @@ Statistical dispersions can be applied to initial parameters using the MonteCarl
 monteCarlo.addDispersion(UniformEulerAngleMRPDispersion("taskName.hub.sigma_BNInit"))
 ```
 
-Dispersion names can reference nested simulation attributes with dotted names and integer list
-indices. For example, `TaskList[0].TaskModels[0].hub.sigma_BNInit` updates the
-`sigma_BNInit` attribute on the first model's hub object.
+Dispersion names can reference nested simulation attributes with dotted names, integer list
+indices, and zero-argument accessor methods. For example,
+`TaskList[0].TaskModels[0].hub.sigma_BNInit` updates the `sigma_BNInit` attribute
+on the first model's hub object, while `get_DynModel().scObject.hub.r_CN_NInit`
+resolves the object returned by `get_DynModel()` before applying the dispersion.
 
 If data is being retained, a archive directory to store retained data must be specified. This directory is later used to reload the retained data from an executed Monte Carlo simulation.
 

src/utilities/MonteCarlo/_UnitTests/test_controller.py

@@ -46,10 +46,19 @@ def __init__(self):
         self.values = [0.0, 0.0, 0.0]
 
 
+class DummyDynModel:
+    def __init__(self):
+        self.scObject = DummyModel()
+
+
 class DummySimulation:
     def __init__(self):
         self.TaskList = [DummyTask()]
         self.vectorContainer = DummyVectorContainer()
+        self.dynModel = DummyDynModel()
+
+    def get_DynModel(self):
+        return self.dynModel
 
 
 def test_apply_modification_updates_nested_attributes():
@@ -72,6 +81,12 @@ def test_apply_modification_updates_nested_attributes():
 
     assert sim.vectorContainer.values == [0.0, 7.5, 0.0]
 
+    method_path = "get_DynModel().scObject.hub.mHub"
+    SimulationExecutor.applyModification(sim, method_path, "35.0")
+
+    assert sim.get_DynModel().scObject.hub.mHub == 35.0
+    assert not hasattr(sim, method_path)
+
 
 def test_populate_seeds_applies_before_configure_function():
     """Verify archived RNGSeed modifications are set before configuration."""
@@ -153,6 +168,49 @@ def execute_sim(sim):
         assert observed_mass != DummyHub().mHub
 
 
+def test_uniform_dispersion_randomizes_method_path_parameter():
+    """Verify generated dispersions update a zero-argument method path."""
+    mass_path = "get_DynModel().scObject.hub.mHub"
+    mass_bounds = [34.0, 36.0]  # [kg]
+    observed_masses = []
+    generated_masses = []
+
+    def create_sim():
+        return DummySimulation()
+
+    def execute_sim(sim):
+        observed_masses.append(sim.get_DynModel().scObject.hub.mHub)
+
+    for run_index in range(2):
+        sim_params = SimulationParameters(
+            creationFunction=create_sim,
+            executionFunction=execute_sim,
+            configureFunction=None,
+            retentionPolicies=[],
+            dispersions=[UniformDispersion(mass_path, mass_bounds)],
+            shouldDisperseSeeds=False,
+            shouldArchiveParameters=False,
+            filename="",
+            icfilename="",
+            index=run_index,
+            modifications={}
+        )
+
+        result = SimulationExecutor()([sim_params, None])
+        generated_mass = SimulationExecutor.parseModificationValue(
+            sim_params.modifications[mass_path]
+        )
+
+        assert result == (True, run_index)
+        generated_masses.append(generated_mass)
+
+    assert observed_masses == generated_masses
+    assert observed_masses[0] != observed_masses[1]
+    for observed_mass in observed_masses:
+        assert mass_bounds[0] <= observed_mass <= mass_bounds[1]
+        assert observed_mass != DummyHub().mHub
+
+
 def test_disperse_seeds_only_records_seeded_models():
     """Verify random seed dispersions are recorded only for seeded models."""
     sim = DummySimulation()
@@ -172,4 +230,5 @@ def test_disperse_seeds_only_records_seeded_models():
     test_apply_modification_updates_nested_attributes()
     test_populate_seeds_applies_before_configure_function()
     test_uniform_dispersion_randomizes_nested_sim_parameter()
+    test_uniform_dispersion_randomizes_method_path_parameter()
     test_disperse_seeds_only_records_seeded_models()