Clean up examples, link 04 and 05. Commented where incomplete code begins (in IM.run function).

Author: RyanDavies19

.gitignore

@@ -14,61 +14,58 @@
 
 import matplotlib.pyplot as plt
 import os
-from fadesign.conceptual.conceptDesign import ConceptDesign
-import numpy as np
-from famodel.project import Project
-from famodel.mooring.mooring import Mooring
-from fadesign.conceptual import metrics as mtr
 import yaml
-import networkx as nx
 import pickle 
-from . import install_helpers as inst
-
+from . import vessel as V
 
 # FILE LOCATIONS
 filePath     = os.path.dirname(os.path.abspath(__file__))
 itemFile     = os.path.join(filePath, "temp_files", "mtrlPkgs.pkl")
 
+# Load package info
 with open(itemFile, 'rb') as f:
     pkgs = pickle.load(f)
 
-vesselFile   = os.path.join(filePath, "input_files/agent_yamls", "vesselDesc.yaml")
+# Load vessel info
+vesselsFile   = os.path.join(filePath, "input_files/agent_yamls", "vesselDesc.yaml")
 vesselNames = ['AHTS']
 
-with open(vesselFile) as file:
+with open(vesselsFile) as file:
     vesselDisc = yaml.load(file, Loader=yaml.FullLoader)
 
+# Create a dictionary to hold vessel objects with the vessel names as keys
+vesselDict = {name: V.Vessel(vesselDisc = vesselDisc[name]) for name in vesselNames}  # Filter vessel descriptions to only include specified names
+
+
+# Action list: for each vessel
+for name in vesselNames:
+    vessel = vesselDict[name] # Get the vessel object
+
+    # Mobilization (needs to initialize before transport because transport depends on mobilization ActionItems)
+    pkg = pkgs[0] # example
+    mobilize = vessel.get_mobilize_action(pkg = pkg)
+    print("Vessel State: \n", vessel.state)
+
+    # Transport
+    distance2port = 250  # km [not sure where this information would be handled]
+    transit_to = vessel.get_transit_to_action(distance2port = distance2port)
+    print("Vessel State: \n", vessel.state)
+
+    # Installation
+    pkg = pkgs[0] # example
+    install = vessel.get_install_action(pkg = pkg)
+    print("Vessel State: \n", vessel.state)
+
+    mobilize.visualize()
+    plt.show() 
+
+    transit_to.visualize()
+    plt.show() 
+
+    install.visualize()
+    plt.show()
 
-for vesselName in vesselNames:
-    vessel = vesselDisc[vesselName]
-    vessel['state'] = {
-        'remaining_cargo': vessel['storage_specs']['max_cargo'],
-        'remaining_deck_space': vessel['storage_specs']['max_deck_space'],
-        'remaining_spool_capacity': vessel['storage_specs']['max_spool_capacity'],
-        'assigned_materials': []
-        }
-    
-# Action list:
-# Transport
-distance2port = 250  # km [not sure where this information would be handled]
-transport_V1 = inst.tranportTo_actionItem(vessel, distance2port)
-# Mobilization
-pkg = pkgs[0] # example
-mobilize_V1, vessel = inst.mobilizeM_actionItem(vessel, pkg)
-
-# TODO: This seems like the same as vessel.mobilize? Are these two different approaches that are duplicates? How do we map this out? 
-
-print(vessel['state'])
-# Installation
-pkg = pkgs[0] # example
-install_V1, vessel = inst.install_actionItem(vessel, pkg)
-print(vessel['state'])
-
-inst.visualizeAction(transport_V1)
-plt.show() 
-
-inst.visualizeAction(mobilize_V1)
-plt.show() 
-
-inst.visualizeAction(install_V1)
-plt.show()
+# Pickle the vessels for loading later
+output = os.path.join(filePath, "temp_files", "vessels.pkl")
+with open(output, 'wb') as f:
+    pickle.dump(vesselDict, f)

famodel/installation/04_step2_actionItems.py

@@ -1,6 +1,6 @@
 """
 an example of how install manager is used to register a vessel and port, and schedule an event and run (not finished yet).
-This is independent of 04_step2_actionItems.py and 03_step1_materialItems.py
+This is loads in the vessels from 04 and their respective actions.
 
 Steps
 -----
@@ -15,24 +15,32 @@
 # from fadesign.conceptual.installation.vessel import Vessel
 # from fadesign.conceptual.installation.port import Port
 from .install_manager import InstallManager as IM
-from pyproj import Proj, Transformer
-import pandas as pd
 import os
+import pickle 
 
 # FILE LOCATIONS
-filePath     = os.path.dirname(os.path.abspath(__file__))
-vessel1_file = os.path.join(filePath, "ahts.yaml")
-port1_file   = os.path.join(filePath, "humboldt_bay.yaml")
+filePath     = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+port1_file   = os.path.join(filePath, "input_files/agent_yamls", "humboldt_bay.yaml")
+vesselsFile = os.path.join(filePath, "temp_files", "vessels.pkl")
+
+# Load vessel info
+with open(vesselsFile, 'rb') as f:
+    vesselDict = pickle.load(f)
 
 # Initialize
 im = IM()
 
 # Register Port
 im.registerPort(port1_file)
-# Register Vessels
-im.registerVessel(vessel1_file)
 
-# Register vessel mob activity
-im.scheduleEvent(im.now, im.vesselList['3gs'], action='mob', params={"portLocation": [0, 0]}) # TODO: how does this relate to 04? In 04 you create actions. Here you schedule events and it seems like the action is defined as a method of the class (not a separate object).
+# Register Vessels (set up for a list of vessels, currently only one)
+for keys in vesselDict.keys():
+    vessel = vesselDict[keys]
+    # Register the vessel with the InstallManager
+    im.registerVessel(vessel)
+
+# Register vessel action (INCOMPLETE) - have not finished how to call the actions in a time loop, how time is handled, and stnadard action input/outputs. Have not considered port locations. 
+# im.scheduleEvent(im.now, im.vesselList['AHTS'], action='mob', params={"portLocation": [0, 0]}) # Incomplete. This calls vessel.mob(), which is a function that's decoupled from the other actions in the class. 
+im.scheduleEvent(im.now, im.vesselList['AHTS'], action=vessel.mobilize, params={"portLocation": [0, 0]}) # Incomplete. This calls vessel.mob(), which is a function that's decoupled from the other actions in the class. 
 # Register 
 im.run()

famodel/installation/05_install_ex.py

@@ -1,3 +1,6 @@
+import matplotlib.pyplot as plt
+import networkx as nx
+
 "Action base class"
 
 __author__ = "Rudy Alkarem"
@@ -122,14 +125,15 @@ def addItem(self, name, duration, cost=0, dependencies=None):
         -------
         None
         """
-        deps = []
-        if dependencies:
-            for dep_action, dep_item in dependencies:
-                action = self.name if dep_action == "self" else dep_action
-                deps.append((action, dep_item))
+        # Old code from when dependencies were tuples of (action, item). Now are just items themselves.
+        # deps = []
+        # if dependencies:
+        #     for dep_action, dep_item in dependencies:
+        #         action = self.name if dep_action == "self" else dep_action
+        #         deps.append((action, dep_item))
 
-        item = ActionItem(name, duration, cost, deps)
-        self.item[name] = item
+        item = ActionItem(name, duration, cost, dependencies)
+        self.items[name] = item
 
     def get_dependencies(self, item_name):
         """
@@ -160,4 +164,48 @@ def __repr__(self):
         out = f"Action({self.name}):\n"
         for name, item in self.items.items():
             out += f"  {name}: duration={item.duration}, cost={item.cost}, deps={item.dependencies}\n"
-        return out
+        return out
+    
+
+    def visualize(self):
+        """
+        Visualizes the action items as a directed graph.
+
+        Parameters
+        ----------
+        action : dict
+            The action items to be visualized.
+
+        Returns
+        -------
+        None
+        """
+        # Create the graph
+        G = nx.DiGraph()
+        for key in self.items.keys():
+            item = self.items[key]
+            for dep in item.dependencies:
+                G.add_edge(dep, item, duration=item.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(node.duration for node in longest_path)
+
+        if len(longest_path)>=1:
+            last_node = longest_path[-1]  # Identify last node of the longest path
+            # Define layout
+            pos = nx.shell_layout(G)        
+            # Draw all nodes and edges (default gray)
+            nx.draw(G, pos, with_labels=True, labels = {node: node.name for node in G.nodes()}, node_size=500, node_color='skyblue', font_size=10, font_weight='bold', font_color='black', edge_color='gray')
+
+            # Highlight longest path in red
+            nx.draw_networkx_edges(G, pos, edgelist=longest_path_edges, edge_color='red', width=2)
+
+            # Annotate last node with total duration in red
+            plt.text(pos[last_node][0], pos[last_node][1] - 0.1, f"{total_duration:.2f} hr", fontsize=12, color='red', fontweight='bold', ha='center') 
+
+            plt.suptitle(f"Action: {self.name} - Total Duration: {total_duration:.2f} hr")         
+
+        else:
+            pass