mobilize duration hard-coded based on vessel used, sequence yaml file ability in task, assign asset for task 1 instead of just evaluating them:

- mobizilize calcDuration is hardcoded based on the vessel used.
- extract sequence yaml file from task.py so the user can edit things like durations.
- update from the sequence yaml in task.py to enable user-defined durations.
- changing site_distance_m to route_length_m to avoid confusion.
- calwave main task1 example assigns assets to actions instead of just evaluating them.

Author: Yuksel-Rudy

famodel/irma/calwave_action.py

@@ -868,9 +868,29 @@ def calcDurationAndCost(self):
 
         # --- Mobilization ---
         if self.type == 'mobilize':
-            pass
+            # Hard-coded example of mobilization times based on vessel type
+            durations = {
+                'crane_barge': 3.0,
+                'research_vessel': 1.0
+            }
+            for role_name, vessel in self.assets.items():
+                vessel_type = vessel['type'].lower()
+                for key, duration in durations.items():
+                    if key in vessel_type:
+                        self.duration += duration
+                        break
+
         elif self.type == 'demobilize':
-            pass
+            # Hard-coded example of demobilization times based on vessel type
+            durations = {
+                'crane_barge': 3.0,
+                'research_vessel': 1.0
+            }
+            for role_name, vessel in self.assets.items():
+                vessel_type = vessel['type'].lower()
+                for key, duration in durations.items():
+                    if key in vessel_type:
+                        self.duration += duration
         elif self.type == 'load_cargo':
             pass
 
@@ -893,7 +913,7 @@ def calcDurationAndCost(self):
                     tr = vessel['transport']
 
                     # distance
-                    dist_m = float(tr['site_distance_m'])
+                    dist_m = float(tr['route_length_m'])
 
                     # speed: linehaul uses transport.cruise_speed_mps
                     speed_mps = float(tr['cruise_speed_mps'])
@@ -925,7 +945,7 @@ def calcDurationAndCost(self):
                     tr_t = tug.get('transport', {})
 
                     # distance: prefer barge’s transport
-                    dist_m = float(tr_b.get('site_distance_m', tr_t['site_distance_m']))
+                    dist_m = float(tr_b.get('route_length_m', tr_t['route_length_m']))
 
                     # speed for convoy linehaul: barge (operator) cruise speed
                     operator = self.assets.get('operator') or self.assets.get('vessel')

famodel/irma/calwave_chart.py

@@ -84,7 +84,7 @@ def view_from_task(sched_task, sc, title: str | None = None):
         if dur <= 0.0:
             continue
 
-        aa = getattr(a, 'assigned_assets', {}) or {}
+        aa = getattr(a, 'assets', {}) or {}
 
         # collect ALL candidate roles → multiple lanes allowed
         lane_keys = set()

famodel/irma/calwave_task.py

@@ -7,14 +7,17 @@
 """
 
 from collections import defaultdict
+import yaml 
 
 class Task:
-    def __init__(self, actions, action_sequence, **kwargs):
+    def __init__(self, name, actions, action_sequence, **kwargs):
         '''
         Create a Task from a list of actions and a dependency map.
 
         Parameters
         ----------
+        name : str
+            Name of the task.
         actions : list
             All Action objects that are part of this task.
         action_sequence : dict or None
@@ -32,6 +35,7 @@ def __init__(self, actions, action_sequence, **kwargs):
         resource_roles = kwargs.get('resource_roles', ('vessel', 'carrier', 'operator'))
 
         # ---- core storage ----
+        self.name = name
         self.actions = {a.name: a for a in actions}
         # allow None → infer solely from Action.dependencies
         self.action_sequence = {k: list(v) for k, v in (action_sequence or {}).items()}
@@ -41,12 +45,13 @@ def __init__(self, actions, action_sequence, **kwargs):
         self.ti = 0.0
         self.tf = 0.0
         self.resource_roles = tuple(resource_roles)
-
+        self.enforce_resources = enforce_resources
+        self.strategy = strategy
         # ---- scheduling ----
-        if strategy == 'levels':
+        if self.strategy == 'levels':
             self._schedule_by_levels()
         else:
-            self._schedule_by_earliest(enforce_resources=enforce_resources)
+            self._schedule_by_earliest(enforce_resources=self.enforce_resources)
 
         # ---- roll-ups ----
         self.cost = sum(float(getattr(a, 'cost', 0.0) or 0.0) for a in self.actions.values())
@@ -66,7 +71,7 @@ def _names_from_dependencies(a):
         return clean
 
     @classmethod
-    def from_scenario(cls, sc, **kwargs):
+    def from_scenario(cls, sc, name, **kwargs):
         actions = list(sc.actions.values())
         base = {a.name: cls._names_from_dependencies(a) for a in actions}
         extra = kwargs.pop('extra_dependencies', None) or {}
@@ -75,7 +80,7 @@ def from_scenario(cls, sc, **kwargs):
             for d in v:
                 if d != k and d not in base[k]:
                     base[k].append(d)
-        return cls(actions=actions, action_sequence=base, **kwargs)
+        return cls(name=name, actions=actions, action_sequence=base, **kwargs)
 
     # --------------------------- Resource & Scheduling ---------------------------
 
@@ -224,3 +229,95 @@ def level_of(a, path):
             a.period = (a.start_hr, a.end_hr)
             a.label_time = f'{dur:.1f}'
         self.tf = self.ti + self.duration
+
+    def extractSeqYaml(self, output_file=None):
+        """
+        Extract the sequence of actions into a YAML file for user editing.
+
+        Args:
+            output_file (str): The name of the output YAML file.
+        """
+        # Write the sequence data to a YAML file
+        if output_file is None:
+            output_file = f"{self.name}_sequence.yaml"
+        
+        # Build the YAML:
+        task_data = []
+        for action_name, action in self.actions.items():        
+            roles = list(action.requirements.keys())
+            deps  = list(action.dependencies.keys())
+            asset_types = []
+            for role, asset in action.assets.items():
+                asset_types.append(asset['type'])
+
+            entry = {
+                'action': action_name,
+                'duration': round(float(action.duration), 2),
+                'roles': roles,
+                'assets': asset_types,
+                'dependencies': deps,
+            }
+            task_data.append(entry)            
+        
+        yaml_dict = {self.name: task_data}
+
+        with open(output_file, 'w') as yaml_file:
+            yaml.dump(yaml_dict, yaml_file, sort_keys=False)
+
+        print(f"Task sequence YAML file generated: {output_file}")
+
+    def update_from_SeqYaml(self, input_file=None):
+        """
+        Update the Task object based on a user-edited YAML file.
+
+        Args
+        ----
+        input_file : str, optional
+            The name of the YAML file (default: <task_name>_sequence.yaml).
+        """
+        if input_file is None:
+            input_file = f"{self.name}_sequence.yaml"
+
+        # Load YAML content
+        with open(input_file, "r") as yaml_file:
+            seq_data = yaml.safe_load(yaml_file)
+
+        if self.name not in seq_data:
+            raise ValueError(f"Task name '{self.name}' not found in YAML file.")
+
+        updated_actions = seq_data[self.name]
+
+        # Reset internal attributes
+        self.actions_ti = {}
+        self.duration = 0.0
+        self.cost = 0.0
+        self.ti = 0.0
+        self.tf = 0.0
+
+        # Update each action from YAML
+        for entry in updated_actions:
+            a_name = entry["action"]
+            if a_name not in self.actions:
+                print(f"Skipping unknown action '{a_name}' (not in current task).")
+                continue
+
+            a = self.actions[a_name]
+
+            # Update action duration
+            a.duration = float(entry.get("duration", getattr(a, "duration", 0.0)))
+
+            # TODO: Update dependencies
+            # TODO: Update roles
+            # TODO: Update assets
+            # TODO: Update cost
+
+        # ---- re-scheduling ----
+        if self.strategy == 'levels':
+            self._schedule_by_levels()
+        else:
+            self._schedule_by_earliest(enforce_resources=self.enforce_resources)
+
+        # ---- re-roll-ups ----
+        self.cost = sum(float(getattr(a, 'cost', 0.0) or 0.0) for a in self.actions.values())        
+
+        print(f"Task '{self.name}' successfully updated from YAML file: {input_file}")

famodel/irma/task1_calwave.py famodel/irma/calwave_task1.pyfamodel/irma/task1_calwave.py renamed to famodel/irma/calwave_task1.py

@@ -11,24 +11,6 @@
 
 sc = Scenario()  # now sc exists in *this* session
 
-def eval_set(a, roles, duration=None, **params):
-    """
-    Convenience: call evaluateAssets with roles/params and optionally set .duration.
-    Always stores assigned_assets for plotting/scheduling attribution.
-    """
-    # Your Action.evaluateAssets may return (duration, cost); we still set explicit duration if passed.
-    res = a.evaluateAssets(roles | params)
-    if duration is not None:
-        a.duration = float(duration)
-    elif isinstance(res, tuple) and len(res) > 0 and res[0] is not None:
-        try:
-            a.duration = float(res[0])
-        except Exception:
-            pass
-    # keep roles visible on the action
-    a.assigned_assets = roles
-    return a
-
 # ---------- Core builder ----------
 def build_task1_calwave(sc: Scenario, project: Project):
     """
@@ -144,47 +126,47 @@ def build_task1_calwave(sc: Scenario, project: Project):
         'linehaul_to_home': [linehome_convoy, linehome_by],
         'demobilize': [demob_sd, demob_by]}
 
-# ---------- Evaluation step (assign vessels & durations) ----------
-def evaluate_task1(sc: Scenario, actions: dict):
+# ---------- Assignment step (assign vessels & durations) ----------
+def assign_actions(sc: Scenario, actions: dict):
     """
     Assign vessels/roles and set durations where the evaluator doesn't.
     Keeps creation and evaluation clearly separated.
     """
     V = sc.vessels  # shorthand
 
     # Mobilize
-    eval_set(actions['mobilize'][0], {'operator': V['San_Diego']}, duration=3.0)
-    eval_set(actions['mobilize'][1], {'operator': V['Beyster']},   duration=1.0)
-
+    actions['mobilize'][0].assignAssets({'operator': V['San_Diego']})
+    actions['mobilize'][1].assignAssets({'operator': V['Beyster']})
+    
     # Transit to site
     convoy_to_site, beyster_to_site = actions['linehaul_to_site']
-    eval_set(convoy_to_site,  {'carrier': V['Jag'], 'operator': V['San_Diego']})
-    eval_set(beyster_to_site, {'vessel': V['Beyster']})
+    convoy_to_site.assignAssets({'carrier': V['Jag'], 'operator': V['San_Diego']})
+    beyster_to_site.assignAssets({'vessel': V['Beyster']})
 
     # Onsite convoy (tug+barge)
     for a_tug in actions['onsite_tug']:
-        eval_set(a_tug, {'carrier': V['Jag'], 'operator': V['San_Diego']})
+        a_tug.assignAssets({'carrier': V['Jag'], 'operator': V['San_Diego']})
 
     # Install (Jag carries, San_Diego operates the install)    
     for a_inst in actions['install']:
-        eval_set(a_inst, {'carrier': V['Jag'], 'operator': V['San_Diego']})
+        a_inst.assignAssets({'carrier': V['Jag'], 'operator': V['San_Diego']})
 
     # Onsite self-propelled (Beyster)    
     for a_by in actions['onsite_by']:
-        eval_set(a_by, {'vessel': V['Beyster']})
+        a_by.assignAssets({'vessel': V['Beyster']})
 
     # Monitor (Beyster as support)
     for a_mon in actions['monitor']:
-        eval_set(a_mon, {'support': V['Beyster']})
+        a_mon.assignAssets({'support': V['Beyster']})
 
     # Transit to home
     convoy_to_home, beyster_to_home = actions['linehaul_to_home']
-    eval_set(convoy_to_home,  {'carrier': V['Jag'], 'operator': V['San_Diego']})
-    eval_set(beyster_to_home, {'vessel': V['Beyster']})
+    convoy_to_home.assignAssets({'carrier': V['Jag'], 'operator': V['San_Diego']})
+    beyster_to_home.assignAssets({'vessel': V['Beyster']})
 
     # Demobilize
-    eval_set(actions['demobilize'][0], {'operator': V['San_Diego']}, duration=3.0)
-    eval_set(actions['demobilize'][1], {'operator': V['Beyster']},   duration=1.0)
+    actions['demobilize'][0].assignAssets({'operator': V['San_Diego']})
+    actions['demobilize'][1].assignAssets({'operator': V['Beyster']})
 
 
 if __name__ == '__main__':
@@ -198,19 +180,25 @@ def evaluate_task1(sc: Scenario, actions: dict):
     # 3) Build (structure only)
     actions = build_task1_calwave(sc, project)
 
-    # 4) Evaluate (assign vessels/roles + durations)
-    evaluate_task1(sc, actions)
+    # 4) Assign (assign vessels/roles)
+    assign_actions(sc, actions)
 
     # 5) schedule once, in the Task
     calwave_task1 = Task.from_scenario(
         sc,
-        strategy='levels',               # or 'levels'
+        name='calwave_task1',
+        strategy='earliest',               # 'earliest' or 'levels'
         enforce_resources=False,         # keep single-resource blocking if you want it
         resource_roles=('vessel', 'carrier', 'operator'))
-        
-    # 6) build the chart input directly from the Task and plot
+    
+    # 6) Extract Task1 sequencing info
+    # calwave_task1.extractSeqYaml()
+
+    # 7) update Task1 if needed
+    calwave_task1.update_from_SeqYaml()  # uncomment to re-apply sequencing from YAML
+    # 8) build the chart input directly from the Task and plot
     chart_view = chart.view_from_task(calwave_task1, sc, title='CalWave Task 1 - Anchor installation plan')
-    chart.plot_task(chart_view)
+    chart.plot_task(chart_view, outpath='calwave_task1_chart.png')
 
 
 

famodel/irma/calwave_vessels.yaml

@@ -5,7 +5,7 @@ San_Diego:
   type: crane_barge
   transport:
       homeport: national_city
-      site_distance_m: 41114       # distance to site
+      route_length_m: 41114       # distance to site
       cruise_speed_mps: 2.5       # ~5 kts, from doc
       Hs_m: 3
   station_keeping:
@@ -43,7 +43,7 @@ Jag:
   type: tug
   transport:
       homeport: national_city
-      site_distance_m: 41114      # distance to site
+      route_length_m: 41114      # distance to site
       cruise_speed_mps: 3.1       # 
       Hs_m: 3.5
   station_keeping:
@@ -70,7 +70,7 @@ Beyster:
   type: research_vessel
   transport:
       homeport: point_loma
-      site_distance_m: 30558       # distance to site
+      route_length_m: 30558       # distance to site
       cruise_speed_mps: 12.9       # 25 kts cruise, from doc
       Hs_m: 2.5
   station_keeping:
@@ -109,7 +109,7 @@ Beyster:
   # type: research_vessel
   # transport:
       # homeport: sio_pier
-      # site_distance_m: 555         # distance to site
+      # route_length_m: 555         # distance to site
       # transit_speed_mps: 10.3      # ~20 kts cruise
       # Hs_m: 1.5
   # station_keeping: