Working on new Task-related methods in Scenario:

- Added Scenario methods to add and register Tasks.
- Added a action_sequence input in Task that provides the ordering
  of actions within the task, including parallel/serial bits.
- Started an example "strategy implementer" function in irma that
  sets up one Task for anchor installation to start with.
- Added ti/tf placeholders in Action and Task for future timing.
- All work in progress...

Author: mattEhall

famodel/irma/action.py

@@ -126,6 +126,8 @@ def __init__(self, actionType, name, **kwargs):
 
         self.duration = getFromDict(actionType, 'duration', default=0) # this will be overwritten by calcDurationAndCost. TODO: or should it overwrite any duration calculation?
         self.cost = 0 # this will be overwritten by calcDurationAndCost
+        self.ti = 0  # action start time [h?]
+        self.tf = 0  # action end time [h?]
 
         self.supported_objects = [] # list of FAModel object types supported by the action
 

famodel/irma/irma.py

@@ -237,6 +237,7 @@ def __init__(self):
 
         # Initialize some things
         self.actions = {}
+        self.tasks = {}
 
 
     def registerAction(self, action):
@@ -331,7 +332,35 @@ def visualizeActions(self):
                 i += 1
         plt.legend()
         return G    
+    
+    
+    def registerTask(self, task):
+        '''Registers an already created task'''
+        
+        # this also handles creation of unique dictionary keys
+        
+        if task.name in self.tasks:  # check if there is already a key with the same name
+            raise Warning(f"Action '{task.name}' is already registered.")
+            print(f"Task name '{task.name}' is in the tasks list so incrementing it...")
+            task.name = increment_name(task.name)
+
+        # Add it to the actions dictionary
+        self.tasks[task.name] = task
+        
+        
+    def addTask(self, actions, action_sequence, task_name, **kwargs):
+        '''Creates a task and adds it to the register'''
+        
+        # Create the action
+        task = Task(actions, action_sequence, task_name, **kwargs)        
+        
+        # Register the action
+        self.registerTask(task)
 
+        return task
+    
+    
+    
     def findCompatibleVessels(self):
         '''Go through actions and identify which vessels have the required
         capabilities (could be based on capability presence, or quantitative.
@@ -340,6 +369,101 @@ def findCompatibleVessels(self):
         pass
 
 
+    def figureOutTaskRelationships(self):
+        '''Calculate timing within tasks and then figure out constraints
+        between tasks.
+        '''
+        
+        # Figure out task durations (for a given set of asset assignments?)
+        for task in self.tasks.values():
+            task.calcTiming()
+        
+        # Figure out timing constraints between tasks based on action dependencies
+        n = len(self.tasks)
+        dt_min = np.zeros((n,n))  # matrix of required time offsets between tasks
+        
+        for i1, task1 in enumerate(self.tasks.values()):
+            for i2, task2 in enumerate(self.tasks.values()):
+                # look at all action dependencies from tasks 1 to 2 and
+                # identify the limiting case (the largest time offset)...
+                dt_min_1_2, dt_min_2_1 = findTaskDependencies(task1, task2)
+                
+                # for now, just look in one direction
+                dt_min[i1, i2] = dt_min_1_2
+
+        return dt_min
+    
+
+def findTaskDependencies(task1, task2):
+    '''Finds any time dependency between the actions of two tasks.
+    Returns the minimum time separation required from task 1 to task 2,
+    and from task 2 to task 1. I
+    '''
+    
+    time_1_to_2 = []
+    time_2_to_1 = []
+    
+    # Look for any dependencies where act2 depends on act1:
+    #for i1, act1 in enumerate(task1.actions.values()):
+    #    for i2, act2 in enumerate(task2.actions.values()):
+    for a1, act1 in task1.actions.items():
+        for a2, act2 in task2.actions.items():
+        
+            if a1 in act2.dependencies:  # if act2 depends on act1
+                time_1_to_2.append(task1.actions_ti[a1] + act1.duration
+                                   - task2.actions_ti[a2])
+        
+            if a2 in act1.dependencies:  # if act2 depends on act1
+                time_2_to_1.append(task2.actions_ti[a2] + act2.duration
+                                   - task1.actions_ti[a1])
+    
+    print(time_1_to_2)
+    print(time_2_to_1)
+    
+    dt_min_1_2 = min(time_1_to_2)  # minimum time required from t1 start to t2 start
+    dt_min_2_1 = min(time_2_to_1)  # minimum time required from t2 start to t1 start
+    
+    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
+
+
+def implementStrategy_staged(sc):
+    '''This sets up Tasks in a way that implements a staged installation
+    strategy where all of one thing is done before all of a next thing.
+    '''
+    
+    # ----- Create a Task for all the anchor installs -----
+    
+    # gather the relevant actions
+    acts = []
+    for action in sc.actions.values():
+        if action.type == 'install_anchor':
+            acts.append(action)
+    
+    # create a dictionary of dependencies indicating that these actions are all in series
+    act_sequence = {}  # key is action name, value is a list of what action names are to be completed before it
+    for i in range(len(acts)):
+        if i==0:  # first action has no dependencies
+            act_sequence[acts[i].name] = []
+        else:  # remaining actions are just a linear sequence
+            act_sequence[acts[i].name] = [ acts[i-1].name ]  # (previous action must be done first)
+    
+    sc.addTask(acts, act_sequence, 'install_all_anchors')
+    
+    # ----- Create a Task for all the mooring installs -----
+    
+    
+    
+    
+    # ----- Create a Task for the platform tow-out and hookup -----
+    
+    
+    
+
+
 if __name__ == '__main__':
     '''This is currently a script to explore how some of the workflow could
     work. Can move things into functions/methods as they solidify.
@@ -436,17 +560,18 @@ def findCompatibleVessels(self):
 
 
     # ----- Generate tasks (groups of Actions according to specific strategies) -----
-    tasks = []
-    t1 = Task(sc.actions, 'install_mooring_system')
-    tasks.append(t1)
+
+    #t1 = Task(sc.actions, 'install_mooring_system')
 
     # ----- Do some graph analysis -----
 
     G = sc.visualizeActions()
 
+    # make some tasks with one strategy...
+    implementStrategy_staged(sc)
 
 
-    
+    # dt_min = sc.figureOutTaskRelationships()
 
 
 
@@ -460,8 +585,8 @@ def findCompatibleVessels(self):
 
     # ----- Generate the task_asset_matrix for scheduler -----
     # UNUSED FOR NOW
-    task_asset_matrix = np.zeros((len(tasks), len(sc.vessels), 2))
-    for i, task in enumerate(tasks):
+    task_asset_matrix = np.zeros((len(sc.tasks), len(sc.vessels), 2))
+    for i, task in enumerate(sc.tasks.values()):
         row = task.get_row(sc.vessels)
         if row.shape != (len(sc.vessels), 2):
             raise Exception(f"Task '{task.name}' get_row output has wrong shape {row.shape}, should be {(2, len(sc.vessels))}")

famodel/irma/task.py

@@ -32,15 +32,19 @@ class Task():
     
     '''
 
-    def __init__(self, actionList, name, **kwargs):
+    def __init__(self, actions, action_sequence, name, **kwargs):
         '''Create an action object...
         It must be given a name and a list of actions.
         The action list should be by default coherent with actionTypes dictionary.
         
         Parameters
         ----------
-        actionList : list
+        actions : list
             A list of all actions that are part of this task.
+        action_sequence : dict
+            A dictionary where each key is the name of each action, and the values are
+            each a list of which actions (by name) must be completed before the current
+            one.
         name : string
             A name for the action. It may be appended with numbers if there
             are duplicate names.
@@ -49,18 +53,35 @@ def __init__(self, actionList, name, **kwargs):
         
         '''
 
-        self.actionList   = actionList  # all actions that are carried out in this task
+        # Make a dict by name of all actions that are carried out in this task
+        self.actions = {}
+        for act in actions:
+            self.actions[act.name] = act
+        
+        
+        # Create a graph of the sequence of actions in this task based on action_sequence
+        
+        # >>> Rudy to do <<<
+        
         self.name = name
+        
         self.status = 0  # 0, waiting;  1=running;  2=finished
 
+        self.actions_ti = {}  # relative start time of each action [h]
+        self.t_actions = {}  # timing of task's actions, relative to t1 [h]
+        # t_actions is a dict with keys same as action names, and entries of [t1, t2]
+        
         self.duration = 0  # duration must be calculated based on lengths of actions
         self.cost     = 0  # cost must be calculated based on the cost of individual actions.
-
+        self.ti =0  # task start time [h?]
+        self.tf =0  # task end time [h?]
+        
         # what else do we need to initialize the task?
 
         # internal graph of the actions within this task.
         self.G = self.getTaskGraph()
 
+    
     def organizeActions(self):
         '''Organizes the actions to be done by this task into the proper order
         based on the strategy of this type of task...
@@ -77,22 +98,33 @@ def calcDuration(self):
         individual actions and their order of operation.'''
 
         # Does Rudy have graph-based code that can do this?
+        
+        
+        
+        
+        
+        
+        
+        
+        
 
     def getTaskGraph(self):
         '''Generate a graph of the action dependencies.
         '''
 
         # Create the graph
         G = nx.DiGraph()
-        for item, data in self.actionList.items():
+        for item, data in self.actions.items():
             for dep in data.dependencies:
                 G.add_edge(dep, item, duration=data.duration)  # Store duration as edge attribute
 
         # Compute longest path & total duration
         longest_path = nx.dag_longest_path(G, weight='duration')
         longest_path_edges = list(zip(longest_path, longest_path[1:]))  # Convert path into edge pairs
-        total_duration = sum(self.actionList[node].duration for node in longest_path)
+
+        total_duration = sum(self.actions[node].duration for node in longest_path)
         return G  
+
 
     def get_row(self, assets):
         '''Get a matrix of (cost, duration) tuples for each asset to perform this task. Will be a row in the task_asset matrix.
@@ -116,14 +148,15 @@ def get_row(self, assets):
         # Could look something like...
         ''' 
         for i, asset in enumerate(assets):
-            for action in self.actionList: # can we do this without the double loop?
+            for action in self.actions: # can we do this without the double loop?
                 if asset in action.roles:
-                    action = self.actionList[asset.name]
+                    action = self.actions[asset.name]
                     matrix[i, 0] = action.cost
                     matrix[i, 1] = action.duration
                 else:
                     matrix[i, 0] = -1 # negative cost/duration means asset cannot perform task
                     matrix[i, 1] = -1
         '''
 
-        return np.zeros((len(assets), 2)) # placeholder, replace with actual matrix
+        return np.zeros((len(assets), 2)) # placeholder, replace with actual matrix
+