C binding interface improvements

glue-codes/labview/CMakeLists.txt

@@ -17,7 +17,14 @@
 add_library(wavetanktestinglib SHARED 
     src/WaveTank.f90
 )
-target_link_libraries(wavetanktestinglib aerodyn_inflow_c_binding moordyn_c_binding seastate_c_binding nwtclibs versioninfolib)
+target_link_libraries(
+    wavetanktestinglib
+        aerodyn_inflow_c_binding
+        moordyn_c_binding
+        seastate_c_binding
+        nwtclibs
+        versioninfolib
+)
 if(APPLE OR UNIX)
     target_compile_definitions(wavetanktestinglib PRIVATE IMPLICIT_DLLEXPORT)
 endif()

glue-codes/python/WaveTankDriver.py

@@ -37,33 +37,28 @@ def __init__(self, library_path: str, input_file_names: dict):
         super().__init__(library_path)
 
         self.input_file_names = {
-            k: create_string_buffer(str(Path(v).absolute() ).encode('utf-8'))
-            for k,v in input_file_names.items()
+            k: str(Path(v).absolute()).encode('utf-8') for k,v in input_file_names.items()
         }
 
         self._initialize_routines()
 
-        # Create buffers for class data
         self.ended = False   # For error handling at end
 
-        # This buffer for the channel names and units is set arbitrarily large
-        # to start. Channel name and unit lengths are currently hard
-        # coded to 20 (this must match ChanLen in NWTC_Base.f90).
-        # self._channel_names_c = create_string_buffer(20 * 4000 + 1)
-        # self._channel_units_c = create_string_buffer(20 * 4000 + 1)
-
-        self.dt                = c_double(0)
-        self.total_time        = c_double(0)
-        self.numTimeSteps      = c_int(0)
+        # Create buffers for class data
+        # These will generally be overwritten by the Fortran code
+        self.num_outs_c = c_int(0)
+        self.output_channel_names = []
+        self.output_channel_units = []
+        self.output_values = None
 
     def _initialize_routines(self):
         self.WaveTank_Init.argtypes = [
-            POINTER(c_char),        #  intent(in   ) :: MD_InputFile_c(IntfStrLen)
-            POINTER(c_char),        #  intent(in   ) :: SS_InputFile_c(IntfStrLen)
-            POINTER(c_char),        #  intent(in   ) :: AD_InputFile_c(IntfStrLen)
-            POINTER(c_char),        #  intent(in   ) :: IfW_InputFile_c(IntfStrLen)
-            POINTER(c_int),         #  intent(in   ) :: IfW_InputFile_c(IntfStrLen)
+            POINTER(c_char_p),      #  intent(in   ) :: MD_InputFile_c(IntfStrLen)
+            POINTER(c_char_p),      #  intent(in   ) :: SS_InputFile_c(IntfStrLen)
+            POINTER(c_char_p),      #  intent(in   ) :: AD_InputFile_c(IntfStrLen)
+            POINTER(c_char_p),      #  intent(in   ) :: IfW_InputFile_c(IntfStrLen)
             POINTER(c_int),         #  intent(in   ) :: n_camera_points_c
+            POINTER(c_int),         #  intent(  out) :: ErrStat_C
             POINTER(c_char),        #  intent(  out) :: ErrMsg_C(ErrMsgLen_C)
         ]
         self.WaveTank_Init.restype = c_int
@@ -80,23 +75,21 @@ def _initialize_routines(self):
         ]
         self.WaveTank_CalcOutput.restype = c_int
 
+        self.WaveTank_End.argtypes = [
+            POINTER(c_int),         # integer(c_int),         intent(  out) :: ErrStat_C
+            POINTER(c_char),        # character(kind=c_char), intent(  out) :: ErrMsg_C(ErrMsgLen_C)
+        ]
+        self.WaveTank_End.restype = c_int
 
     def init(self, n_camera_points):
         _error_status = c_int(0)
         _error_message = create_string_buffer(self.ERROR_MSG_C_LEN)
 
-        # Convert the string into a c_char byte array
-        # input_string = '\x00'.join(input_string_array)
-        # input_string = input_string.encode('utf-8')
-        # input_string_length = len(input_string)
-
         # # Convert the initial positions array into c_float array
         # init_positions_c = (c_float * 6)(0.0, )
         # for i, p in enumerate(platform_init_pos):
         #     init_positions_c[i] = c_float(p)
 
-        # self._numChannels = c_int(0)
-
         # gravity = c_float(9.80665)
         # water_density = c_float(1025)
         # water_depth = c_float(200)
@@ -107,10 +100,10 @@ def init(self, n_camera_points):
         # time_interval = c_float(0.125)
         # wave_elevation_series_flag = c_int(0)
         self.WaveTank_Init(
-            self.input_file_names["MoorDyn"],
-            self.input_file_names["SeaState"],
-            self.input_file_names["AeroDyn"],
-            self.input_file_names["InflowWind"],
+            c_char_p(self.input_file_names["MoorDyn"]),
+            c_char_p(self.input_file_names["SeaState"]),
+            c_char_p(self.input_file_names["AeroDyn"]),
+            c_char_p(self.input_file_names["InflowWind"]),
             byref(c_int(n_camera_points)),
             # create_string_buffer(outrootname),
             # byref(gravity),
@@ -127,6 +120,10 @@ def init(self, n_camera_points):
         if self.fatal_error(_error_status):
             raise RuntimeError(f"Error {_error_status.value}: {_error_message.value}")
 
+        # self.output_channel_names = [n.decode('UTF-8') for n in _channel_names.value.split()] 
+        # self.output_channel_units = [n.decode('UTF-8') for n in _channel_units.value.split()] 
+        # self.output_values = np.zeros( self.num_outs_c.value, dtype=c_float, order='C' )
+
     def calc_output(
         self,
         frame_number: int,
@@ -152,21 +149,16 @@ def calc_output(
         if self.fatal_error(_error_status):
             raise RuntimeError(f"Error {_error_status.value}: {_error_message.value}")
 
-    @property
-    def output_channel_names(self):
-        if len(self._channel_names.value.split()) == 0:
-            return []
-        output_channel_names = self._channel_names.value.split()
-        output_channel_names = [n.decode('UTF-8') for n in output_channel_names]
-        return output_channel_names
+    def end(self):
+        _error_status = c_int(0)
+        _error_message = create_string_buffer(self.ERROR_MSG_C_LEN)
 
-    @property
-    def output_channel_units(self):
-        if len(self._channel_units.value.split()) == 0:
-            return []
-        output_channel_units = self._channel_units.value.split()
-        output_channel_units = [n.decode('UTF-8') for n in output_channel_units]
-        return output_channel_units
+        self.WaveTank_End(
+            byref(_error_status),
+            _error_message,
+        )
+        if self.fatal_error(_error_status):
+            raise RuntimeError(f"Error {_error_status.value}: {_error_message.value}")
 
 
 if __name__=="__main__":
@@ -196,3 +188,5 @@ def output_channel_units(self):
             rotation_matrix=rotation_matrix,
             loads=loads,
         )
+
+    wavetanklib.end()