Updates for WEC-Sim v5.0 (#185)

* update read_wecsim for WEC-Sim v5.0

* add cable class

* update notebook with results

* add try-except for Morrison (v4.1) vs Morison (v4.2+)

* add cable check and dataset to wave tests

* update cable dataset

Author: akeeste

examples/data/wave/Cable_matlabWorkspace_structure.mat

@@ -35,7 +35,7 @@ def setUpClass(self):
     def tearDownClass(self):
         pass
 
-    ### WEC-Sim data, mo mooring
+    ### WEC-Sim data, no mooring
     def test_read_wecSim_no_mooring(self):
         ws_output = wave.io.wecsim.read_output(join(datadir, 'RM3_matlabWorkspace_structure.mat'))
         self.assertEqual(ws_output['wave'].elevation.name,'elevation')
@@ -45,6 +45,19 @@ def test_read_wecSim_no_mooring(self):
         self.assertEqual(len(ws_output['mooring']),0)
         self.assertEqual(len(ws_output['moorDyn']),0)
         self.assertEqual(len(ws_output['ptosim']),0)
+        self.assertEqual(len(ws_output['cables']),0)
+    
+    ### WEC-Sim data, with cable
+    def test_read_wecSim_cable(self):
+        ws_output = wave.io.wecsim.read_output(join(datadir, 'Cable_matlabWorkspace_structure.mat'))
+        self.assertEqual(ws_output['wave'].elevation.name,'elevation')
+        self.assertEqual(ws_output['bodies']['body1'].name,'BuoyDraft5cm')
+        self.assertEqual(ws_output['cables'].name,'Cable')
+        self.assertEqual(ws_output['constraints']['constraint1'].name,'Mooring')
+        self.assertEqual(len(ws_output['mooring']),0)
+        self.assertEqual(len(ws_output['moorDyn']),0)
+        self.assertEqual(len(ws_output['ptosim']),0)
+        self.assertEqual(len(ws_output['ptos']),0)
 
     ### WEC-Sim data, with mooring
     def test_read_wecSim_with_mooring(self):
@@ -56,6 +69,7 @@ def test_read_wecSim_with_mooring(self):
         self.assertEqual(len(ws_output['mooring']),40001)
         self.assertEqual(len(ws_output['moorDyn']),0)
         self.assertEqual(len(ws_output['ptosim']),0)
+        self.assertEqual(len(ws_output['cables']),0)
 
     ### WEC-Sim data, with moorDyn
     def test_read_wecSim_with_moorDyn(self):
@@ -67,6 +81,7 @@ def test_read_wecSim_with_moorDyn(self):
         self.assertEqual(len(ws_output['mooring']),40001)
         self.assertEqual(len(ws_output['moorDyn']),7)
         self.assertEqual(len(ws_output['ptosim']),0)
+        self.assertEqual(len(ws_output['cables']),0)
 
 
 if __name__ == '__main__':

examples/data/wave/RM3MoorDyn_matlabWorkspace_structure.mat

@@ -2,6 +2,7 @@
 import numpy as np
 import scipy.io as sio
 
+
 def read_output(file_name):
     """
     Loads the wecSim response class once 'output' has been saved to a `.mat` 
@@ -63,7 +64,7 @@ def read_output(file_name):
     #      forceRadiationDamping: [iterations x 6 double]
     #             forceAddedMass: [iterations x 6 double]
     #             forceRestoring: [iterations x 6 double]
-    #    forceMorrisonAndViscous: [iterations x 6 double]
+    #     forceMorisonAndViscous: [iterations x 6 double]
     #         forceLinearDamping: [iterations x 6 double]
     ######################################    
     try:
@@ -79,7 +80,7 @@ def read_output(file_name):
         forceRadiationDamping = []
         forceAddedMass = []
         forceRestoring = []
-        forceMorrisonAndViscous = []
+        forceMorisonAndViscous = []
         forceLinearDamping = []
         for body in range(num_bodies):
             name.append(bodies[0][0]['name'][0][body][0])   
@@ -92,7 +93,12 @@ def read_output(file_name):
             forceRadiationDamping.append(bodies[0][0]['forceRadiationDamping'][0][body])
             forceAddedMass.append(bodies[0][0]['forceAddedMass'][0][body])
             forceRestoring.append(bodies[0][0]['forceRestoring'][0][body])
-            forceMorrisonAndViscous.append(bodies[0][0]['forceMorrisonAndViscous'][0][body])
+            try:
+                # Format in WEC-Sim responseClass >= v4.2 
+                forceMorisonAndViscous.append(bodies[0][0]['forceMorisonAndViscous'][0][body])
+            except:
+                # Format in WEC-Sim responseClass <= v4.1
+                forceMorisonAndViscous.append(bodies[0][0]['forceMorrisonAndViscous'][0][body])
             forceLinearDamping.append(bodies[0][0]['forceLinearDamping'][0][body])    
     except:
         num_bodies = 0         
@@ -110,7 +116,7 @@ def _write_body_output(body):
             tmp_body[f'forceRadiationDamping_dof{dof+1}'] = forceRadiationDamping[body][:,dof]
             tmp_body[f'forceAddedMass_dof{dof+1}'] = forceAddedMass[body][:,dof]
             tmp_body[f'forceRestoring_dof{dof+1}'] = forceRestoring[body][:,dof]
-            tmp_body[f'forceMorrisonAndViscous_dof{dof+1}'] = forceMorrisonAndViscous[body][:,dof]
+            tmp_body[f'forceMorisonAndViscous_dof{dof+1}'] = forceMorisonAndViscous[body][:,dof]
             tmp_body[f'forceLinearDamping_dof{dof+1}'] = forceLinearDamping[body][:,dof]                            
         return tmp_body
 
@@ -256,7 +262,7 @@ def _write_constraint_output(constraint):
 
 
     ######################################
-    ## import wecSim moopring class
+    ## import wecSim mooring class
     # 
     #         name: ''
     #         time: [iterations x 1 double]
@@ -374,6 +380,67 @@ def _write_mooring_output(mooring):
     except:
         print("ptosim class not used") 
         ptosim_output = []
+    
+    
+    ######################################
+    ## import wecSim cable class
+    # 
+    #       name: ''
+    #       time: [iterations x 1 double]
+    #   position: [iterations x 6 double]
+    #   velocity: [iterations x 6 double]
+    # forcecable: [iterations x 6 double]
+    ######################################
+    try:
+        cables = output['cables']
+        num_cables = len(cables[0][0]['name'][0])   
+        name = []   
+        time = []
+        position = []
+        velocity = []
+        acceleration = []
+        forcetotal = []
+        forceactuation = []
+        forceconstraint = []
+        for cable in range(num_cables):
+            name.append(cables[0][0]['name'][0][cable][0])   
+            time.append(cables[0][0]['time'][0][cable])
+            position.append(cables[0][0]['position'][0][cable])
+            velocity.append(cables[0][0]['velocity'][0][cable])
+            acceleration.append(cables[0][0]['acceleration'][0][cable])
+            forcetotal.append(cables[0][0]['forceTotal'][0][cable])
+            forceactuation.append(cables[0][0]['forceActuation'][0][cable])
+            forceconstraint.append(cables[0][0]['forceConstraint'][0][cable])
+    except:
+        num_cables = 0 
+
+    ######################################
+    ## create cable_output DataFrame
+    ######################################    
+    def _write_cable_output(cable):
+        for dof in range(6):                
+            tmp_cable[f'position_dof{dof+1}'] = position[cable][:,dof]
+            tmp_cable[f'velocity_dof{dof+1}'] = velocity[cable][:,dof]
+            tmp_cable[f'acceleration_dof{dof+1}'] = acceleration[cable][:,dof]
+            tmp_cable[f'forcetotal_dof{dof+1}'] = forcetotal[cable][:,dof]
+            tmp_cable[f'forceactuation_dof{dof+1}'] = forceactuation[cable][:,dof]
+            tmp_cable[f'forceconstraint_dof{dof+1}'] = forceconstraint[cable][:,dof]
+        return tmp_cable
+
+    if num_cables >= 1:   
+        cable_output = {}
+        for cable in range(num_cables):
+            tmp_cable = pd.DataFrame(data = time[0],columns=['time'])   
+            tmp_cable = tmp_cable.set_index('time') 
+            tmp_cable.name = name[cable]
+            if num_cables == 1:   
+                cable_output = _write_cable_output(cable)
+            elif num_cables > 1:   
+                cable_output[f'cable{cable+1}'] = _write_cable_output(cable)
+    else:
+        print("cable class not used") 
+        cable_output = []
+
 
 
     ######################################
@@ -385,6 +452,7 @@ def _write_mooring_output(mooring):
                  'constraints' : constraint_output,                 
                  'mooring' : mooring_output,
                   'moorDyn': moorDyn_output, 
-                  'ptosim' : ptosim_output
+                  'ptosim' : ptosim_output,
+                  'cables': cable_output
                  }
     return ws_output