Updates for NEW dependency-offset matrices

- first off, in irma.py, we need to take the maximum dependency time offset between actions instead of the one closest to zero, which simply makes logical sense
- the task_asset matrix that gets created first calculates the durations of each task-asset group assignment, and then divides them by the time_interval to be in units of periods, not hours
- also, we need to make sure that we are running action.calcDurationAndCost each time a task has a new asset group assigned to it, as task.calcDuration won't recalculate the action durations for a new asset group

- ALL NEW DEPENDENCY OFFSET MATRICES (at the bottom of Irma.py and implemented into the scheduler)
- - we store a dictionary of AxA matrices for each task pair (skipping the same tasks as pairs) initially full of -np.inf, but then populated with offsets depending on which asset group is assigned to each task
- - nothing new; it just calls findTaskDependencies for different task-asset group setups, while also saving them in units of periods instead of hours
- - we also extract the proper task_dependency and dependency_types from these matrices as well and default them to 'start_start' dependencies
- NEW code for calculating the total number of periods to include in the scheduler setup

- The scheduler has been adjusted to account for these new dependency-offset matrices
- - uses a simple _method to check the dependency offset input
- - then we slightly reformat the constraint creation for dependencies and include the proper for loops to reference the proper offset out of the input matrix
- - - for 'finish_start' and 'start_start' this calls for additional terms to the constraint equations that include the task-asset-group assignment as to ensure these correspond to the right offset (meaning, we can't just rely on constraining start times -- we need to include the assignments in order to determine the proper offsets)

- some new updates to the scheduler successful printing (and a return dictionary), and made sure the simple example could still run

- ALSO: UPDATES TO THE SCHEDULER_README AND THE SCHEDULER_TUTORIAL to reflect the new dependency-offset matrices, including more math and detailed explanations of what these constraints are doing

Other small file updates:
- action.py simple bug fixes for more realistic requirements and action durations
- - unit conversions, proper vessel speed, print statements, loading times, etc. - to get more accurate time durations
- 'winch' didn't seem to be used in the anchor_orienting requirement
- task.py time_interval naming
- deleted old task_asset_generator script since it's not being used and we should look at the whole code zoomed out before doing anything like that
- printing/displaying things in the Irma.py run code

Author: shousner

famodel/irma/action.py

@@ -271,7 +271,7 @@ def printNotSupported(st):
                     except:
                         pass
 
-                req['bollard_pull']['max_force'] = 0.0001*mass*t2N  # <<< can add a better calculation for towing force required
+                req['bollard_pull']['max_force'] = 0.001*mass*t2N  # <<< can add a better calculation for towing force required
 
 
             elif reqname == 'chain_storage':  # Storage specifically for chain
@@ -1126,8 +1126,9 @@ def checkAssets(self, assets):
                     break                         # no need to check other capabilities for this requirement
 
             if not requirements_met[req]:
-                print(f"Requirement '{req}' is not met by asset(s):")
-                # print(f"{assets}.")
+                print(f"Action '{self.name}': Requirement '{req}' is NOT met by asset(s):")
+            else:
+                print(f"Action '{self.name}': Requirement '{req}' can be met by asset(s)")
 
         assignable = all(requirements_met.values())
 
@@ -1308,9 +1309,10 @@ def calcDurationAndCost(self):
 
             distance = 2500 # <<< need to eventually compute distances based on positions
 
-            speed = req['assigned_assets'][0]['capabilities']['bollard_pull']['site_speed']
+            #speed = req['assigned_assets'][0]['capabilities']['bollard_pull']['site_speed']
+            speed = req['assigned_assets'][0]['transport']['transit_speed_mps']
 
-            self.durations['tow'] = distance / speed / 60 / 60 # duration [hr]
+            self.durations['tow'] = distance / speed / 60  # duration [hr]
 
         elif self.type == 'transit_linehaul_self':
             # TODO: RA: Needs to be updated based on new format (no roles)! - Note to dev: try to reduce (try/except) statements
@@ -1634,7 +1636,7 @@ def calcDurationAndCost(self):
             req = self.requirements['anchor_onboarding']
 
             if 'crane' in req['selected_capability']:
-                self.durations['load anchor by crane'] = 0.25
+                self.durations['load anchor by crane'] = 0.5
 
             #elif 'windlass' in req['selected_capability']:
                 #self.durations['load anchor by windlass'] = 2.0
@@ -1682,7 +1684,7 @@ def calcDurationAndCost(self):
                         embed_speed = 1E-4*specs['power']/(np.pi/4*anchor.dd['design']['D']**2) # <<< example of more specific calculation
                     else:
                         embed_speed = 0.07 # embedment rate [m/min]
-                    self.durations['anchor embedding'] = L*embed_speed / 60
+                    self.durations['anchor embedding'] = L/embed_speed / 60
 
                 # 4) Connection / release (fixed)
                 self.durations['anchor release'] = 15/60
@@ -1700,6 +1702,9 @@ def calcDurationAndCost(self):
             # previous action, which assets/objects were involved, attachments, etc.).
 
             if 'line_handling' in self.requirements:
+
+                self.durations['mooring handling on deck'] = 0.5
+
                 req = self.requirements['line_handling']  # calculate the time for paying out line
 
                 # note: some of this code is repeated and could be put in a function
@@ -1741,7 +1746,7 @@ def calcDurationAndCost(self):
                     v_mpm = req['assigned_assets'][0]['capabilities']['crane']['speed']*60  # [m/min]
 
                 if v_mpm:  # there is only a lowering time if a winch or crane is involved
-                    self.durations['mooring line retrieval'] = depth/v_mpm /60 # [h]
+                    self.durations['mooring line retrieval'] = depth*2/v_mpm /60 # [h]
 
             # >>> tensioning could be added <<<
             self.durations['generic hookup and tensioning time'] = 1
@@ -1843,7 +1848,7 @@ def calcDurationAndCost(self):
 
         # Add cost of all assets involved for the duration of the action [$]
         for asset in self.assetList:
-            self.costs[f"{asset['name']} day rate"] = self.duration * asset['day_rate']
+            self.costs[f"{asset['name']} day rate"] = self.duration/24 * asset['day_rate']
 
         # Sum up cost
         #self.cost += self.duration * sum([asset['day_rate'] for asset in self.assetList])

famodel/irma/irma.py

@@ -566,21 +566,20 @@ def findTaskDependencies(task1, task2, time_interval=0.5):
 
     # Calculate minimum times (rounded to nearest interval)
     if time_1_to_2:
-        raw_dt_min_1_2 = min(time_1_to_2, key=abs)
+        raw_dt_min_1_2 = max(time_1_to_2)
         dt_min_1_2 = np.round(raw_dt_min_1_2 / time_interval) * time_interval
     else:
         dt_min_1_2 = -np.inf
 
     if time_2_to_1:
-        raw_dt_min_2_1 = min(time_2_to_1, key=abs)
+        raw_dt_min_2_1 = max(time_2_to_1)
         dt_min_2_1 = np.round(raw_dt_min_2_1 / time_interval) * time_interval
     else:
         dt_min_2_1 = -np.inf
 
     if dt_min_1_2 + dt_min_2_1 > 0:
         print(f"The timing between these two tasks seems to be impossible...")
 
-    #breakpoint()
     return dt_min_1_2, dt_min_2_1
 
 
@@ -714,7 +713,7 @@ def implementStrategy_staged(sc):
 
     display = 1
 
-    sc = Scenario()  # class instance holding most of the info
+    sc = Scenario(display=display)  # class instance holding most of the info
 
 
     # ----- Create the interrelated actions (including their individual requirements) -----
@@ -762,7 +761,7 @@ def implementStrategy_staged(sc):
     # ----- Do some graph analysis -----
 
     #G = sc.visualizeActions()
-    G = sc.visualizeActionsHierarchy()
+    #G = sc.visualizeActionsHierarchy()
 
 
     # ----- Generate tasks (sequences of Actions following specific strategies) -----
@@ -771,7 +770,7 @@ def implementStrategy_staged(sc):
     # Call one of the task strategy implementers, which will create the tasks
     implementStrategy_staged(sc)
 
-    sc.tasks['install_all_anchors'].checkAssets([sc.vessels['AHTS_alpha'], sc.vessels['MPSV_01']], display=1)
+    time_interval = 0.25
 
     # ----- Try assigning assets to the tasks -----
     print('===== Assigning Asset Groups to Tasks =====')
@@ -793,7 +792,7 @@ def implementStrategy_staged(sc):
         # Calculation durations of the actions, and then of the task
         for a in task.actions.values():
             a.calcDurationAndCost()
-        task.calcDuration()
+        task.calcDuration(time_interval=time_interval)
 
 
     # Example task time adjustment and plot
@@ -802,17 +801,17 @@ def implementStrategy_staged(sc):
 
 
     # ----- Quantify the dependency offsets between tasks -----
-
-    time_interval = 0.25
 
     dt_min = sc.figureOutTaskRelationships(time_interval=time_interval)
 
 
 
     # ----- Call the scheduler -----
 
+    # TASKS
     tasks_scheduler = list(sc.tasks.keys())
 
+    # ASSETS
     for asset in sc.vessels.values():
         if 'name' in asset:
             if asset['name'] == 'AHTS_alpha':
@@ -823,16 +822,16 @@ def implementStrategy_staged(sc):
             asset['max_weather'] = asset['transport']['Hs_m']
     assets_scheduler = list(sc.vessels.values())
 
+    # ASSET GROUPS
     # >>>>> TODO: make this automated to find all possible combinations of "realistic" asset groups
     asset_groups_scheduler = [
         {'group1': ['AHTS_alpha']},
         {'group2': ['MPSV_01']},
-        #{'group2': ['CSV_A']},
-        #{'group3': ['AHTS_alpha', 'CSV_A', 'HL_Giant']}
         {'group3': ['AHTS_alpha', 'MPSV_01']}
     ]
 
-    task_asset_matrix_scheduler = np.zeros([len(tasks_scheduler), len(asset_groups_scheduler), 2], dtype=int)
+    # TASK-ASSET-MATRIX
+    task_asset_matrix_scheduler = np.zeros([len(tasks_scheduler), len(asset_groups_scheduler), 2])
     for i,task in enumerate(sc.tasks.values()):
         for j,asset_group in enumerate(asset_groups_scheduler):
             # Extract asset list from the dictionary - values() returns a list containing one list
@@ -843,48 +842,138 @@ def implementStrategy_staged(sc):
                 task_asset_matrix_scheduler[i,j] = (-1, -1)
             else:
                 task.assignAssets(asset_list)
-                task.calcDuration(duration_interval=time_interval)
+                for a in task.actions.values():
+                    a.calcDurationAndCost()
+                task.calcDuration(time_interval=time_interval)
                 task.calcCost()
-                duration_int = int(round(task.duration / time_interval))
+                duration_int = int(np.ceil(task.duration / time_interval))
                 task_asset_matrix_scheduler[i,j] = (task.cost, duration_int)
                 task.clearAssets()
+    
+
+    # DEPENDENCIES
+
+    # Create dependency offset matrices for each pair of tasks (not the same task in pairs)
+    # All rows represent the dependent task and all columns represent the prerequisite task
+    # Each individual row or column represents a different asset group
+    # Values in the matrices are the minimum time offset required between those tasks with those asset assignments
+    # For example, if there are 3 tasks and 3 asset groups:
+    #     if task2 depends on task1, if task2 uses the second asset group, and if task1 uses the third asset group,
+    #     then there will be a non-inf value in the [1,2] (python-indexing) spot for the time offset
+    
+    dependency_offset_matrices = {}
+    task_list = list(sc.tasks.values())
+    task_names = list(sc.tasks.keys())
+    
+    # Initialize matrices for each dependency pair ("dependent_task->prerequisite_task")
+    for i, task1 in enumerate(task_list):
+        for k, task2 in enumerate(task_list):
+            if i != k:  # Don't compare a task with itself
+                dep_key = f"{task_names[k]}->{task_names[i]}"  # "task2->task1" = "dependent->prerequisite"
+                dependency_offset_matrices[dep_key] = np.full((len(asset_groups_scheduler), len(asset_groups_scheduler)), -np.inf)
+    
+    # Calculate offsets for each valid task-asset-group combination
+    for i, task1 in enumerate(task_list):
+        for j, ag1 in enumerate(asset_groups_scheduler):
+            # Get the list of vessels for this asset group
+            asset_list1 = [sc.vessels[name] for name in list(ag1.values())[0]]
 
+            # Check if this asset group can perform task1
+            if task1.checkAssets(asset_list1, display=0)[0]:
+                # Temporarily assign assets and calculate durations
+                task1.assignAssets(asset_list1)
+                for a in task1.actions.values():
+                    a.calcDurationAndCost()
+                task1.calcDuration(time_interval=time_interval)
+                
+                # Check dependencies with all other tasks
+                for k, task2 in enumerate(task_list):
+                    if i == k:  # Skip self-comparison
+                        continue
+                        
+                    for l, ag2 in enumerate(asset_groups_scheduler):
+                        asset_list2 = [sc.vessels[name] for name in list(ag2.values())[0]]
+                        
+                        # Check if this asset group can perform task2
+                        if task2.checkAssets(asset_list2, display=0)[0]:
+                            # Temporarily assign assets and calculate durations
+                            task2.assignAssets(asset_list2)
+                            for a in task2.actions.values():
+                                a.calcDurationAndCost()
+                            task2.calcDuration(time_interval=time_interval)
+                            
+                            # Calculate the minimum time offset from task1 to task2
+                            dt_min_1_to_2, dt_min_2_to_1 = findTaskDependencies(task1, task2, time_interval=time_interval)
+                            
+                            # Store in the appropriate matrix (and convert from hours to periods)
+                            dep_key_k_to_i = f"{task_names[k]}->{task_names[i]}"
+                            if dt_min_1_to_2 != -np.inf:
+                                dependency_offset_matrices[dep_key_k_to_i][l, j] = int(np.ceil(dt_min_1_to_2 / time_interval))
+                            else:
+                                dependency_offset_matrices[dep_key_k_to_i][l, j] = -np.inf
+                            
+                            dep_key_i_to_k = f"{task_names[i]}->{task_names[k]}"
+                            if dt_min_2_to_1 != -np.inf:
+                                dependency_offset_matrices[dep_key_i_to_k][j, l] = int(np.ceil(dt_min_2_to_1 / time_interval))
+                            else:
+                                dependency_offset_matrices[dep_key_i_to_k][j, l] = -np.inf
+                            
+                            task2.clearAssets()
+                
+                task1.clearAssets()
+    
+    
 
+    # Calculate task_dependencies and dependency_types from the dependency_offset_matrices
+    
     task_dependencies = {}
     dependency_types = {}
-    offsets = {}
-    for i, task1 in enumerate(sc.tasks.values()):
-        for j, task2 in enumerate(sc.tasks.values()):
-            offset = dt_min[i,j]
-            if i != j and offset != -np.inf:
-                if task2.name not in task_dependencies:
-                    task_dependencies[task2.name] = []
-                task_dependencies[task2.name].append(task1.name)
-                dependency_types[task1.name + '->' + task2.name] = 'start_start'
-                offsets[task1.name + '->' + task2.name] = offset / time_interval
+    
+    for dep_key, matrix in dependency_offset_matrices.items():
+        # Check if there are any valid offsets (non -inf) in this matrix
+        if np.any(matrix != -np.inf):
+            # Parse the dependency key: "dependent_task->prerequisite_task"
+            dependent_task, prerequisite_task = dep_key.split('->')
+            
+            # Add to task_dependencies
+            if dependent_task not in task_dependencies:
+                task_dependencies[dependent_task] = []
+            task_dependencies[dependent_task].append(prerequisite_task)
+            
+            # Set dependency type based on task characteristics (default is 'start_start') - can update this later with other dependency types
+            dependency_types[dep_key] = 'start_start'
 
-    for task in sc.tasks.values():
-        task.calcDuration()     # ensure the durations of each task are calculated
-
-    task_start_times = {}
-    task_finish_times = {}
-    task_list = list(sc.tasks.keys())
-
-    for task_name in task_list:
-        # Find earliest start time based on dependencies
-        earliest_start = 0
-        for i, t1_name in enumerate(task_list):
-            j = task_list.index(task_name)
-            if i != j and dt_min[i, j] != -np.inf:
-                # This task depends on t1
-                earliest_start = max(earliest_start, 
-                                task_finish_times.get(t1_name, 0) + dt_min[i, j])
-        
-        task_start_times[task_name] = earliest_start
-        task_finish_times[task_name] = earliest_start + sc.tasks[task_name].duration
-    
-    weather = np.arange(0, max(task_finish_times.values())+ time_interval, time_interval)
-    weather = [int(x) for x in np.ones(int(max(task_finish_times.values()) / time_interval), dtype=int)]
+
+
+
+    # PERIODS
+    # Calculate total number of periods needed for the scheduler
+    # For each task, find the maximum duration across all valid asset group assignments
+    total_task_duration = 0
+    for i, task in enumerate(sc.tasks.values()):
+        # Get durations for this task across all asset groups (index 1 is duration in periods)
+        task_durations = task_asset_matrix_scheduler[i, :, 1]
+        # Filter out invalid assignments (negative or zero duration)
+        valid_durations = task_durations[task_durations > 0]
+        if len(valid_durations) > 0:
+            max_duration = np.max(valid_durations)
+            total_task_duration += max_duration
+    # Find maximum offset from all dependency matrices (ignoring -inf values and negative values)
+    max_offsets_sum = 0
+    for dep_key, matrix in dependency_offset_matrices.items():
+        valid_offsets = matrix[matrix != -np.inf]
+        if len(valid_offsets) > 0 and max(valid_offsets) >= 0:
+            max_offsets_sum += np.max(valid_offsets)
+
+    total_duration = total_task_duration + max_offsets_sum
+    # total_duration is already in periods, so just convert to integer
+    num_periods = int(np.ceil(total_duration))
+    
+    
+
+    
+
+    weather = [int(x) for x in np.ones(num_periods, dtype=int)]
     '''
     weather = [ 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
@@ -896,9 +985,9 @@ def implementStrategy_staged(sc):
         assets=assets_scheduler,
         asset_groups=asset_groups_scheduler,
         task_asset_matrix=task_asset_matrix_scheduler,
-        task_dependencies=task_dependencies,
-        dependency_types=dependency_types,
-        offsets=offsets,
+        task_dependencies=task_dependencies,  # Derived from dependency_offset_matrices
+        dependency_types=dependency_types,     # Derived from dependency_offset_matrices
+        offsets=dependency_offset_matrices,    # Use asset-group-specific matrices
         weather=weather,
         period_duration=time_interval,
         wordy=1

famodel/irma/requirements.yaml

@@ -119,7 +119,7 @@ anchor_orienting:
   description: "Capability to orient an anchor during installation."
   objects: [anchor]
   capabilities:
-    - winch
+    #- winch
     - rov
     - divers