h2lib 13.1.3101__py3-none-win_amd64.whl → 13.1.3103__py3-none-win_amd64.whl

h2lib/_h2lib.py

@@ -52,6 +52,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             if os.path.isdir(os.path.join(f, 'Library/bin')):
                 os.add_dll_directory(os.path.join(f, 'Library/bin'))
         DLLWrapper.__init__(self, filename, cwd=cwd, cdecl=True)
+        self.stop_on_error(False)
         self.suppress_output = suppress_output
         self._initialized = False
         self.time = 0
@@ -116,19 +117,53 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
     def get_time(self):
         return np.round(H2LibSignatures.get_time(self, time=0.)[0][0], 6)
 
-    def read_input(self, htc_path='htc/input_hawc.htc', model_path='.'):
-        self._model_path = model_path
-        self.cwd = self.model_path
-        return H2LibSignatures.read_input(self, htc_path)
+    def read_input(self, htc_path, model_path='.'):
+        if htc_path is not None:
+            self._model_path = model_path
+            self.cwd = self.model_path
+            return H2LibSignatures.read_input(self, htc_path)
 
     def init(self, htc_path=None, model_path='.'):
-        assert not hasattr(self, '_init_result'), "init called twice"
-        if htc_path is not None:
-            self.read_input(htc_path, model_path)
+        assert not self._initialized, "h2lib already initialized via init, init_AD or init_AL"
+        self.read_input(htc_path, model_path)
         r = H2LibSignatures.init(self)
         self._initialized = True
         return r
 
+    def init_AD(self, htc_path=None, model_path='.', tiploss_method=2, tiploss_shen_c2=21, rotor=0):
+        """Initialize HAWC2 for Actuator Disc workflow, where wind speeds including induction at the aerodynamic sections
+        are passed from e.g. CFD to HAWC2 via set_aerosections_windspeed.
+        This function will:
+        - Disable wind speed update at blade sections (wind speeds must be set via set_aerosections_windspeed)
+        - Disable HAWC2 induction (induction_method=0).
+        - set GetWindSpeedData%u_mean=nan to avoid unintended use of the free wind module in HAWC2
+        - set the tiploss_method. The default method is 2, which works with the AD workflow, but the tiploss_shen_c2
+          parameter must be tuned to give sensible results, see tiploss_method in the HAWC2 manual
+        """
+        assert not self._initialized, "h2lib already initialized via init, init_AD or init_AL"
+        self.read_input(htc_path, model_path)
+        r = H2LibSignatures.init_AD(self, rotor + 1, int(tiploss_method), float(tiploss_shen_c2))
+        self._initialized = True
+        return r
+
+    def init_AL(self, epsilon_smearing, htc_path=None, model_path='.', rotor=0):
+        """Initialize HAWC2 for Actuator Line workflow, where wind speeds including induction at the aerodynamic sections
+        are passed from e.g. CFD to HAWC2 via set_aerosections_windspeed.
+        This function will:
+        - Disable wind speed update at blade sections (wind speeds must be set via set_aerosections_windspeed)
+        - Enable viscous core correction which compensates for the missing induction due to smearing of the forces.
+          The method calculates the missing induction as a smearing factor times the normal near wake induction
+          (induction_method=2) while disregarding the BEM farwake contribution.
+          The smearing factor is based on the smearing size given by epsilon_smearing [m].
+        - set GetWindSpeedData%u_mean=nan to avoid unintended use of the free wind module in HAWC2
+        - set the tiploss_method to 0, to avoid unintended additional tiploss correction
+        """
+        assert not self._initialized, "h2lib already initialized via init, init_AD or init_AL"
+        self.read_input(htc_path, model_path)
+        r = H2LibSignatures.init_AL(self, rotor=rotor + 1, epsilon_smearing=float(epsilon_smearing))
+        self._initialized = True
+        return r
+
     def step(self):
         self.time = np.round(H2LibSignatures.step(self, restype=np.float64)[1], 6)
         return self.time
@@ -375,7 +410,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
 
         """
         error_code = -1
-        _, error_code = H2LibSignatures.solver_static_run(self, reset_structure, error_code)[0]
+        _, error_code = H2LibSignatures.solver_static_run(self, reset_structure, error_code, check_stop=False)[0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
 
@@ -588,7 +623,8 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             bool(angles_in_deg),
             reset_orientation,
             np.asfortranarray(mbdy2_ini_rotvec_d1).astype(np.float64),
-            error_code)[0][-1]
+            error_code,
+            check_stop=False)[0][-1]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
 
@@ -775,7 +811,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             ncst,
             error_code,
         ) = H2LibSignatures.get_number_of_bodies_and_constraints(
-            self, nbdy, ncst, error_code
+            self, nbdy, ncst, error_code, check_stop=False
         )[
             0
         ]
@@ -803,7 +839,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         nelem = np.zeros((nbdy, ), dtype=np.int64, order="F")
         error_code = -1
         _, nelem, error_code = H2LibSignatures.get_number_of_elements(
-            self, nbdy, nelem, error_code
+            self, nbdy, nelem, error_code, check_stop=False
         )[0]
 
         if error_code > 0:  # pragma: no cover
@@ -856,10 +892,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
             tes,
             error_code,
         ) = H2LibSignatures.get_timoshenko_location(
-            self, ibdy + 1, ielem + 1, l, r1, r12, tes, error_code
-        )[
-            0
-        ]
+            self, ibdy + 1, ielem + 1, l, r1, r12, tes, error_code, check_stop=False)[0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
         return l, r1, r12, tes
@@ -889,8 +922,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         amat = np.zeros((3, 3), order="F")
         error_code = -1
         _, amat, error_code = H2LibSignatures.get_body_rotation_tensor(
-            self, ibdy + 1, amat, error_code
-        )[0]
+            self, ibdy + 1, amat, error_code, check_stop=False)[0]
         if error_code > 0:
             raise _ERROR_CODES[error_code]
         return amat
@@ -934,8 +966,7 @@ class H2LibThread(H2LibSignatures, DLLWrapper):
         error_code = -1
 
         _, _, M, C, K, R, error_code = H2LibSignatures.get_system_matrices(
-            self, n_tdofs, n_rdofs, M, C, K, R, error_code
-        )[0]
+            self, n_tdofs, n_rdofs, M, C, K, R, error_code, check_stop=False)[0]
 
         if error_code > 0:
             raise _ERROR_CODES[error_code]

h2lib/_version.py

@@ -1,4 +1,4 @@
 # This file is autogenerated and should not be modified manually
-__version__ = '13.1.3101'
-h2lib_version = '13.1.3101'
-hawc2_version = '13.1.31+1-g14e98da'
+__version__ = '13.1.3103'
+h2lib_version = '13.1.3103'
+hawc2_version = '13.1.31+5-g08eea40'

h2lib/dll_wrapper.py

@@ -89,7 +89,7 @@ def cwd(f):
     return wrap
 
 
-def wrap(self, f, *args, **kwargs):
+def wrap(self, f, *args, check_stop=True, **kwargs):
     c_args = []
     args = list(args)
     for i, arg in enumerate(args):
@@ -149,6 +149,12 @@ def wrap(self, f, *args, **kwargs):
                 res = f(*c_args)
         else:
             res = f(*c_args)
+    try:
+        self.check_stop()
+    except BaseException:
+        if check_stop:
+            raise
+
     ret_args = []
     for arg in args:
         c_arg = c_args.pop(0)
@@ -178,6 +184,18 @@ class DLLWrapper(object):
         in_use.append(os.path.abspath(self.filename))
         atexit.register(self.close)
 
+    def check_stop(self):
+        stop_code = 0
+        cstop_code = c_long_p(c_longlong(stop_code))
+        getattr(self.lib, 'get_stop_code')(cstop_code)
+        if cstop_code.contents.value:
+            stop_msg = (" " * 1024).encode('cp1252')
+            cstop_msg = c_char_p(stop_msg)
+            getattr(self.lib, 'get_stop_message')(cstop_msg)
+            stop_msg = cstop_msg.value.decode('cp1252').strip()
+            getattr(self.lib, 'reset_stop_code_and_message')()
+            raise Exception(stop_msg)
+
     @staticmethod
     def find_dll(path, name):
         p = Path(path)

h2lib/h2lib_signatures.py

@@ -4,23 +4,24 @@ from h2lib.dll_wrapper import DLLWrapper
 
 
 class H2LibSignatures():
-    def add_sensor(self, sensor_line, index_start, index_stop):
+    def add_sensor(self, sensor_line, index_start, index_stop, check_stop=True):
         '''subroutine add_sensor(sensor_line, index_start, index_stop) bind(C, name="add_sensor")
       integer*8 :: index_start, index_stop
       character(kind=c_char, len=1), intent(in)       :: sensor_line(1024)
     end subroutine'''
-        return self.get_lib_function('add_sensor')(sensor_line, index_start, index_stop)
+        return self.get_lib_function('add_sensor')(sensor_line, index_start, index_stop, check_stop=check_stop)
 
-    def check_convergence(self, bconv, resq, resg, resd):
+    def check_convergence(self, bconv, resq, resg, resd, check_stop=True):
         '''subroutine check_convergence(bconv, resq, resg, resd) bind(C, name='check_convergence')
       logical(kind=c_bool), intent(out) :: bconv
       real(c_double), intent(out) :: resq
       real(c_double), intent(out) :: resg
       real(c_double), intent(out) :: resd
     end subroutine'''
-        return self.get_lib_function('check_convergence')(bconv, resq, resg, resd)
+        return self.get_lib_function('check_convergence')(bconv, resq, resg, resd, check_stop=check_stop)
 
-    def do_system_eigenanalysis(self, include_damping, n_modes, natural_frequencies, damping_ratios, error_code):
+    def do_system_eigenanalysis(self, include_damping, n_modes, natural_frequencies,
+                                damping_ratios, error_code, check_stop=True):
         '''subroutine do_system_eigenanalysis(include_damping, n_modes, natural_frequencies, damping_ratios, error_code) &
 logical(kind=c_bool), intent(in) :: include_damping
 integer(kind=4), intent(in) :: n_modes
@@ -28,190 +29,192 @@ real(kind=c_double), dimension(n_modes), intent(out) :: natural_frequencies
 real(kind=c_double), dimension(n_modes), intent(out) :: damping_ratios
 integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('do_system_eigenanalysis')(include_damping, n_modes, natural_frequencies, damping_ratios, error_code)
+        return self.get_lib_function('do_system_eigenanalysis')(include_damping, n_modes,
+                                                                natural_frequencies, damping_ratios, error_code, check_stop=check_stop)
 
-    def echo_version(self, ):
+    def echo_version(self, check_stop=True):
         '''subroutine echo_version() BIND(C, NAME='echo_version')
     !DEC$ ATTRIBUTES DLLEXPORT :: echo_version
     !GCC$ ATTRIBUTES DLLEXPORT :: echo_version
     type (tbuildinfo)   :: b
 end subroutine'''
-        return self.get_lib_function('echo_version')()
+        return self.get_lib_function('echo_version')(check_stop=check_stop)
 
-    def extern_write_log(self, c_msg, n, dll_name, error, warning):
+    def extern_write_log(self, c_msg, n, dll_name, error, warning, check_stop=True):
         '''subroutine extern_write_log(c_msg, n, dll_name, error, warning) bind(C, name="extern_write_log")
             integer, intent(in) :: n
             character(kind=c_char, len=1), intent(in) :: c_msg(n)
             character(kind=c_char), intent(in) :: dll_name(50)
             logical(kind=c_bool), intent(in), optional :: error, warning
-    character(kind=c_char, len=1), intent(in) :: c_msg(n_msg)
-    integer, intent(in) :: n_msg
-    character(kind=c_char), intent(in) :: dll_name(50)
-    character(len=50) :: n
-    logical(kind=c_bool), intent(in), optional :: error, warning
+      character(kind=c_char, len=1), intent(in) :: c_msg(n_msg)
+      integer, intent(in) :: n_msg
+      character(kind=c_char), intent(in) :: dll_name(50)
+      character(len=50) :: n
+      logical(kind=c_bool), intent(in), optional :: error, warning
 end subroutine'''
-        return self.get_lib_function('extern_write_log')(c_msg, n, dll_name, error, warning)
+        return self.get_lib_function('extern_write_log')(c_msg, n, dll_name, error, warning, check_stop=check_stop)
 
-    def fail(self, str_arr):  # pragma: no cover
+    def fail(self, str_arr, check_stop=True):
         '''subroutine fail(str_arr) bind(C, name='fail')
     character(kind=c_char, len=1), intent(inout)       :: str_arr(255)
   end subroutine'''
-        return self.get_lib_function('fail')(str_arr)
+        return self.get_lib_function('fail')(str_arr, check_stop=check_stop)
 
-    def finalize(self, ):
+    def finalize(self, check_stop=True):
         '''SUBROUTINE finalize() bind(C, name="finalize")
 !DEC$ ATTRIBUTES DLLEXPORT :: finalize
   integer:: i
   real*4:: T2
 END SUBROUTINE'''
-        return self.get_lib_function('finalize')()
+        return self.get_lib_function('finalize')(check_stop=check_stop)
 
-    def getSquare(self, val, restype):
+    def getSquare(self, val, restype, check_stop=True):
         '''function getSquare(val) result(valSquared) BIND(C, NAME='getSquare')
   !DEC$ ATTRIBUTES DLLEXPORT :: getSquare
         real(RK), intent(in) :: val
         real(RK)             :: valSquared
     end function'''
-        return self.get_lib_function('getSquare')(val, restype=restype)
+        return self.get_lib_function('getSquare')(val, restype=restype, check_stop=check_stop)
 
-    def getState(self, restype):
+    def getState(self, restype, check_stop=True):
         '''function getState() result(val) BIND(C, NAME='getState')
   !DEC$ ATTRIBUTES DLLEXPORT :: getState
         integer             :: val
     end function'''
-        return self.get_lib_function('getState')(restype=restype)
+        return self.get_lib_function('getState')(restype=restype, check_stop=check_stop)
 
-    def get_aerosections_forces(self, rotor, Fxyz):
+    def get_aerosections_forces(self, rotor, Fxyz, check_stop=True):
         '''subroutine get_aerosections_forces(rotor, Fxyz) bind(C, name='get_aerosections_forces')
     integer*8, intent(in) :: rotor
     real(c_double),intent(out)::Fxyz(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
   end subroutine'''
-        return self.get_lib_function('get_aerosections_forces')(rotor, Fxyz)
+        return self.get_lib_function('get_aerosections_forces')(rotor, Fxyz, check_stop=check_stop)
 
-    def get_aerosections_moments(self, rotor, Mxyz):
+    def get_aerosections_moments(self, rotor, Mxyz, check_stop=True):
         '''subroutine get_aerosections_moments(rotor, Mxyz) bind(C, name='get_aerosections_moments')
     integer*8, intent(in) :: rotor
     real(c_double),intent(out):: Mxyz(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
   end subroutine'''
-        return self.get_lib_function('get_aerosections_moments')(rotor, Mxyz)
+        return self.get_lib_function('get_aerosections_moments')(rotor, Mxyz, check_stop=check_stop)
 
-    def get_aerosections_position(self, rotor, position):
+    def get_aerosections_position(self, rotor, position, check_stop=True):
         '''subroutine get_aerosections_position(rotor, position) bind(C, name="get_aerosections_position")
     integer*8, intent(in) :: rotor
     real(c_double),intent(out)   :: position(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
   end subroutine'''
-        return self.get_lib_function('get_aerosections_position')(rotor, position)
+        return self.get_lib_function('get_aerosections_position')(rotor, position, check_stop=check_stop)
 
-    def get_bem_grid(self, rotor, azi, rad):
+    def get_bem_grid(self, rotor, azi, rad, check_stop=True):
         '''subroutine get_bem_grid(rotor, azi, rad) bind(C, name="get_bem_grid")
     integer*8, intent(in)               :: rotor
     real(c_double), intent(out)       :: azi(rotors_gl%rotor(rotor)%dyn_induc%bem%nazi)
     real(c_double), intent(out)       :: rad(rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
   end subroutine'''
-        return self.get_lib_function('get_bem_grid')(rotor, azi, rad)
+        return self.get_lib_function('get_bem_grid')(rotor, azi, rad, check_stop=check_stop)
 
-    def get_bem_grid_dim(self, rotor, nazi, nrad):
+    def get_bem_grid_dim(self, rotor, nazi, nrad, check_stop=True):
         '''subroutine get_bem_grid_dim(rotor, nazi, nrad) bind(C, name="get_bem_grid_dim")
     integer*8, intent(in)               :: rotor
     integer*8, intent(out)              :: nazi, nrad
   end subroutine'''
-        return self.get_lib_function('get_bem_grid_dim')(rotor, nazi, nrad)
+        return self.get_lib_function('get_bem_grid_dim')(rotor, nazi, nrad, check_stop=check_stop)
 
-    def get_body_rotation_tensor(self, ibdy, amat, error_code):
+    def get_body_rotation_tensor(self, ibdy, amat, error_code, check_stop=True):
         '''subroutine get_body_rotation_tensor(ibdy, amat, error_code) &
     integer(kind=8), intent(in) :: ibdy
     real(kind=c_double), dimension(3, 3), intent(out) :: amat
     integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('get_body_rotation_tensor')(ibdy, amat, error_code)
+        return self.get_lib_function('get_body_rotation_tensor')(ibdy, amat, error_code, check_stop=check_stop)
 
-    def get_diameter(self, rotor, restype):
+    def get_diameter(self, rotor, restype, check_stop=True):
         '''function get_diameter(rotor) bind(C, name="get_diameter")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_diameter
     integer*8, intent(in) :: rotor
     Type (Taerorotor),pointer :: rotor_p
     real(c_double)  :: get_diameter
  end function'''
-        return self.get_lib_function('get_diameter')(rotor, restype=restype)
+        return self.get_lib_function('get_diameter')(rotor, restype=restype, check_stop=check_stop)
 
-    def get_induction_axisymmetric(self, rotor, induction):
+    def get_induction_axisymmetric(self, rotor, induction, check_stop=True):
         '''subroutine get_induction_axisymmetric(rotor, induction) bind(C, name="get_induction_axisymmetric")
     integer*8, intent(in)        :: rotor
     real(c_double),intent(out)   :: induction(rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
   end subroutine'''
-        return self.get_lib_function('get_induction_axisymmetric')(rotor, induction)
+        return self.get_lib_function('get_induction_axisymmetric')(rotor, induction, check_stop=check_stop)
 
-    def get_induction_polargrid(self, rotor, induction):
+    def get_induction_polargrid(self, rotor, induction, check_stop=True):
         '''subroutine get_induction_polargrid(rotor, induction) bind(C, name="get_induction_polargrid")
       integer*8, intent(in)        :: rotor
       real(c_double),intent(out)   :: induction(rotors_gl%rotor(rotor)%dyn_induc%bem%nazi, rotors_gl%rotor(rotor)%dyn_induc%bem%nrad)
   end subroutine'''
-        return self.get_lib_function('get_induction_polargrid')(rotor, induction)
+        return self.get_lib_function('get_induction_polargrid')(rotor, induction, check_stop=check_stop)
 
-    def get_induction_rotoravg(self, rotor, induction):
+    def get_induction_rotoravg(self, rotor, induction, check_stop=True):
         '''subroutine get_induction_rotoravg(rotor, induction) bind(C, name="get_induction_rotoravg")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_induction_rotoravg
     integer*8, intent(in)        :: rotor
     real(c_double), intent(out) :: induction
   end subroutine'''
-        return self.get_lib_function('get_induction_rotoravg')(rotor, induction)
+        return self.get_lib_function('get_induction_rotoravg')(rotor, induction, check_stop=check_stop)
 
-    def get_nSections(self, rotor, blade, restype):
+    def get_nSections(self, rotor, blade, restype, check_stop=True):
         '''function get_nSections(rotor, blade) bind(C, name="get_nSections")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_nSections
     integer*8, intent(in) :: rotor, blade
     integer*8             :: get_nSections
   end function'''
-        return self.get_lib_function('get_nSections')(rotor, blade, restype=restype)
+        return self.get_lib_function('get_nSections')(rotor, blade, restype=restype, check_stop=check_stop)
 
-    def get_nblades(self, rotor, restype):
+    def get_nblades(self, rotor, restype, check_stop=True):
         '''function get_nblades(rotor) bind(C, name="get_nblades")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_nblades
     integer*8, intent(in) ::  rotor
     integer*8             :: get_nblades
   end function'''
-        return self.get_lib_function('get_nblades')(rotor, restype=restype)
+        return self.get_lib_function('get_nblades')(rotor, restype=restype, check_stop=check_stop)
 
-    def get_nrotors(self, restype):
+    def get_nrotors(self, restype, check_stop=True):
         '''function get_nrotors() bind(C, name="get_nrotors")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_nrotors
     integer*8 :: get_nrotors
   end function'''
-        return self.get_lib_function('get_nrotors')(restype=restype)
+        return self.get_lib_function('get_nrotors')(restype=restype, check_stop=check_stop)
 
-    def get_number_of_bodies_and_constraints(self, nbdy, ncst, error_code):
+    def get_number_of_bodies_and_constraints(self, nbdy, ncst, error_code, check_stop=True):
         '''subroutine get_number_of_bodies_and_constraints(nbdy, ncst, error_code) &
     integer(kind=8), intent(out) :: nbdy
     integer(kind=8), intent(out) :: ncst
     integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('get_number_of_bodies_and_constraints')(nbdy, ncst, error_code)
+        return self.get_lib_function('get_number_of_bodies_and_constraints')(
+            nbdy, ncst, error_code, check_stop=check_stop)
 
-    def get_number_of_elements(self, nbdy, nelem, error_code):
+    def get_number_of_elements(self, nbdy, nelem, error_code, check_stop=True):
         '''subroutine get_number_of_elements(nbdy, nelem, error_code) &
     integer(kind=8), intent(in) :: nbdy
     integer(kind=8), dimension(nbdy), intent(out) :: nelem
     integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('get_number_of_elements')(nbdy, nelem, error_code)
+        return self.get_lib_function('get_number_of_elements')(nbdy, nelem, error_code, check_stop=check_stop)
 
-    def get_rotor_avg_wsp(self, coo, rotor, wsp):
+    def get_rotor_avg_wsp(self, coo, rotor, wsp, check_stop=True):
         '''subroutine get_rotor_avg_wsp(coo, rotor, wsp) bind(C, name="get_rotor_avg_wsp")
     integer*8, intent(in) :: rotor
     integer*8, intent(in) :: coo ! 1: global, 2: rotor
     real(c_double), dimension(3):: wsp
   end subroutine'''
-        return self.get_lib_function('get_rotor_avg_wsp')(coo, rotor, wsp)
+        return self.get_lib_function('get_rotor_avg_wsp')(coo, rotor, wsp, check_stop=check_stop)
 
-    def get_rotor_orientation(self, rotor, yaw, tilt, azi):
+    def get_rotor_orientation(self, rotor, yaw, tilt, azi, check_stop=True):
         '''subroutine get_rotor_orientation(rotor, yaw, tilt, azi) bind(C, name="get_rotor_orientation")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_orientation
     integer*8, intent(in) :: rotor
     real(c_double), intent(out) :: yaw, tilt, azi
   end subroutine'''
-        return self.get_lib_function('get_rotor_orientation')(rotor, yaw, tilt, azi)
+        return self.get_lib_function('get_rotor_orientation')(rotor, yaw, tilt, azi, check_stop=check_stop)
 
-    def get_rotor_position(self, rotor, position):
+    def get_rotor_position(self, rotor, position, check_stop=True):
         '''subroutine get_rotor_position(rotor, position) bind(C, name="get_rotor_position")
     !DEC$ ATTRIBUTES DLLEXPORT :: get_rotor_position
     integer*8, intent(in) :: rotor
@@ -220,24 +223,38 @@ end subroutine'''
     integer*8, intent(in) :: rotor
     integer*8, intent(in) :: coo ! 1: global, 2: rotor
   end subroutine'''
-        return self.get_lib_function('get_rotor_position')(rotor, position)
+        return self.get_lib_function('get_rotor_position')(rotor, position, check_stop=check_stop)
 
-    def get_sensor_info(self, id, name, unit, desc):
+    def get_sensor_info(self, id, name, unit, desc, check_stop=True):
         '''subroutine get_sensor_info(id, name, unit, desc) bind(C, name="get_sensor_info")
       integer*8, intent(in) :: id
       character(kind=c_char, len=1), intent(out)       :: name(30), unit(10), desc(512)
     end subroutine'''
-        return self.get_lib_function('get_sensor_info')(id, name, unit, desc)
+        return self.get_lib_function('get_sensor_info')(id, name, unit, desc, check_stop=check_stop)
 
-    def get_sensor_values(self, ids, values, n):
+    def get_sensor_values(self, ids, values, n, check_stop=True):
         '''subroutine get_sensor_values(ids, values, n) bind(C, name="get_sensor_values")
       integer*8, intent(in) :: n
       integer*8, intent(in) :: ids(n)
       real(c_double), intent(out)        :: values(n)
     end subroutine'''
-        return self.get_lib_function('get_sensor_values')(ids, values, n)
+        return self.get_lib_function('get_sensor_values')(ids, values, n, check_stop=check_stop)
 
-    def get_system_eigval_eigvec_with_damping(self, n_modes, ny, eigenvalues, eigenvectors, error_code):
+    def get_stop_code(self, stop_code_, check_stop=True):
+        '''subroutine get_stop_code(stop_code_) bind(C, name="get_stop_code")
+  integer*8, intent(out) :: stop_code_
+end subroutine'''
+        return self.get_lib_function('get_stop_code')(stop_code_, check_stop=check_stop)
+
+    def get_stop_message(self, stop_message, check_stop=True):
+        '''subroutine get_stop_message(stop_message) bind(C, name="get_stop_message")
+  !DEC$ ATTRIBUTES DLLEXPORT :: get_stop_message
+  character(kind=c_char, len=1), intent(inout)      :: stop_message(1024)
+end subroutine'''
+        return self.get_lib_function('get_stop_message')(stop_message, check_stop=check_stop)
+
+    def get_system_eigval_eigvec_with_damping(self, n_modes, ny, eigenvalues,
+                                              eigenvectors, error_code, check_stop=True):
         '''subroutine get_system_eigval_eigvec_with_damping(n_modes, ny, eigenvalues, eigenvectors, error_code) &
 integer(kind=4), intent(in) :: n_modes
 integer(kind=4), intent(in) :: ny
@@ -245,9 +262,11 @@ complex(kind=c_double_complex), dimension(n_modes), intent(out) :: eigenvalues
 complex(kind=c_double_complex), dimension(ny, n_modes), intent(out) :: eigenvectors
 integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('get_system_eigval_eigvec_with_damping')(n_modes, ny, eigenvalues, eigenvectors, error_code)
+        return self.get_lib_function('get_system_eigval_eigvec_with_damping')(
+            n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=check_stop)
 
-    def get_system_eigval_eigvec_without_damping(self, n_modes, ny, eigenvalues, eigenvectors, error_code):
+    def get_system_eigval_eigvec_without_damping(
+            self, n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=True):
         '''subroutine get_system_eigval_eigvec_without_damping(n_modes, ny, eigenvalues, eigenvectors, error_code) &
 integer(kind=4), intent(in) :: n_modes
 integer(kind=4), intent(in) :: ny
@@ -255,9 +274,10 @@ real(kind=c_double), dimension(n_modes), intent(out) :: eigenvalues
 real(kind=c_double), dimension(ny, n_modes), intent(out) :: eigenvectors
 integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('get_system_eigval_eigvec_without_damping')(n_modes, ny, eigenvalues, eigenvectors, error_code)
+        return self.get_lib_function('get_system_eigval_eigvec_without_damping')(
+            n_modes, ny, eigenvalues, eigenvectors, error_code, check_stop=check_stop)
 
-    def get_system_matrices(self, n_tdofs, n_rdofs, M, C, K, R, error_code):
+    def get_system_matrices(self, n_tdofs, n_rdofs, M, C, K, R, error_code, check_stop=True):
         '''subroutine get_system_matrices(n_tdofs, n_rdofs, M, C, K, R, error_code) &
 integer(kind=4), intent(in) :: n_tdofs
 integer(kind=4), intent(in) :: n_rdofs
@@ -267,14 +287,15 @@ real(kind=c_double), dimension(n_rdofs, n_rdofs), intent(out) :: K
 real(kind=c_double), dimension(n_tdofs, n_rdofs), intent(out) :: R
 integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('get_system_matrices')(n_tdofs, n_rdofs, M, C, K, R, error_code)
+        return self.get_lib_function('get_system_matrices')(
+            n_tdofs, n_rdofs, M, C, K, R, error_code, check_stop=check_stop)
 
-    def get_time(self, time):
+    def get_time(self, time, check_stop=True):
         '''subroutine
 subroutine'''
-        return self.get_lib_function('get_time')(time)
+        return self.get_lib_function('get_time')(time, check_stop=check_stop)
 
-    def get_timoshenko_location(self, ibdy, ielem, l, r1, r12, tes, error_code):
+    def get_timoshenko_location(self, ibdy, ielem, l, r1, r12, tes, error_code, check_stop=True):
         '''subroutine get_timoshenko_location(ibdy, ielem, l, r1, r12, tes, error_code) &
     integer(kind=8), intent(in) :: ibdy
     integer(kind=8), intent(in) :: ielem
@@ -284,89 +305,112 @@ subroutine'''
     real(kind=c_double), dimension(3,3), intent(out) :: tes
     integer(kind=8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('get_timoshenko_location')(ibdy, ielem, l, r1, r12, tes, error_code)
+        return self.get_lib_function('get_timoshenko_location')(
+            ibdy, ielem, l, r1, r12, tes, error_code, check_stop=check_stop)
 
-    def get_version(self, s):
+    def get_version(self, s, check_stop=True):
         '''subroutine get_version(s) BIND(C, NAME='get_version')
                 character(kind=c_char, len=1), intent(inout)  :: s(255)
             end subroutine'''
-        return self.get_lib_function('get_version')(s)
+        return self.get_lib_function('get_version')(s, check_stop=check_stop)
 
-    def init(self, ):
+    def init(self, check_stop=True):
         '''subroutine init() bind(C, name="init")
      !DEC$ ATTRIBUTES DLLEXPORT :: init
     end subroutine'''
-        return self.get_lib_function('init')()
+        return self.get_lib_function('init')(check_stop=check_stop)
+
+    def init_AD(self, rotor, tiploss_method, tiploss_shen_c2):
+        '''subroutine init_AD(rotor, tiploss_method, tiploss_shen_c2) bind(C, name="init_AD")
+    integer*8, intent(in) :: rotor
+    integer*8, intent(in) :: tiploss_method
+    REAL(c_double), intent(in) :: tiploss_shen_c2
+  end subroutine'''
+        return self.get_lib_function('init_AD')(rotor, tiploss_method, tiploss_shen_c2)
+
+    def init_AL(self, rotor, epsilon_smearing):
+        '''subroutine init_AL(rotor, epsilon_smearing) bind(C, name="init_AL")
+    real(c_double), intent(in) :: epsilon_smearing
+    integer*8, intent(in) :: rotor
+  end subroutine'''
+        return self.get_lib_function('init_AL')(rotor, epsilon_smearing)
 
     def init_windfield(self, Nxyz, dxyz, box_offset_yz, transport_speed):
         '''subroutine init_windfield(Nxyz, dxyz, box_offset_yz, transport_speed) bind(C, name="init_windfield")
       integer*8, dimension(3), intent(in) :: Nxyz
       real*8              :: transport_speed
     end subroutine'''
-        return self.get_lib_function('init_windfield')(Nxyz, dxyz, box_offset_yz, transport_speed)
+        return self.get_lib_function('init_windfield')(
+            Nxyz, dxyz, box_offset_yz, transport_speed)
 
-    def linearize(self, n_tdofs, n_rdofs):
+    def linearize(self, n_tdofs, n_rdofs, check_stop=True):
         '''subroutine linearize(n_tdofs, n_rdofs) bind(C, name="linearize")
 integer(kind=8), intent(out) :: n_tdofs
 integer(kind=8), intent(out) :: n_rdofs
 end subroutine'''
-        return self.get_lib_function('linearize')(n_tdofs, n_rdofs)
+        return self.get_lib_function('linearize')(n_tdofs, n_rdofs, check_stop=check_stop)
 
-    def loop(self, N, restype):
+    def loop(self, N, restype, check_stop=True):
         '''function loop(N) bind(C, Name='loop')
     !DEC$ ATTRIBUTES DLLEXPORT :: loop
     integer*8, intent(in) :: N
     real(c_double) :: loop,a
     integer*8 :: i, j
   end function'''
-        return self.get_lib_function('loop')(N, restype=restype)
+        return self.get_lib_function('loop')(N, restype=restype, check_stop=check_stop)
 
-    def myfunction(self, int, dbl, restype):
+    def myfunction(self, int, dbl, restype, check_stop=True):
         '''function myfunction(int, dbl) bind(C, name='myfunction')
       !DEC$ ATTRIBUTES DLLEXPORT :: myfunction
       integer*8, intent(in) :: int
       real(c_double), intent(in) :: dbl
       real(c_double) :: myfunction
     end function'''
-        return self.get_lib_function('myfunction')(int, dbl, restype=restype)
+        return self.get_lib_function('myfunction')(int, dbl, restype=restype, check_stop=check_stop)
 
-    def mysubroutine(self, str_arr, dbl_arr):
+    def mysubroutine(self, str_arr, dbl_arr, check_stop=True):
         '''subroutine mysubroutine(str_arr, dbl_arr) bind(C, name='mysubroutine')
       character(kind=c_char, len=1), intent(inout)       :: str_arr(20)
       real(c_double), intent(inout), dimension(2) :: dbl_arr
     end subroutine'''
-        return self.get_lib_function('mysubroutine')(str_arr, dbl_arr)
+        return self.get_lib_function('mysubroutine')(str_arr, dbl_arr, check_stop=check_stop)
 
-    def read_input(self, htc_path):
+    def read_input(self, htc_path, check_stop=True):
         '''subroutine read_input(htc_path) bind(C, name="read_input")
       character(kind=c_char, len=1), intent(in)       :: htc_path(1024)
     end subroutine'''
-        return self.get_lib_function('read_input')(htc_path)
+        return self.get_lib_function('read_input')(htc_path, check_stop=check_stop)
 
-    def run(self, time, restype):
+    def run(self, time, restype, check_stop=True):
         '''function run(time) bind(C, name='run')
       !DEC$ ATTRIBUTES DLLEXPORT :: run
       real(c_double), intent(in) :: time
       real(c_double) :: run, eps
     end function'''
-        return self.get_lib_function('run')(time, restype=restype)
+        return self.get_lib_function('run')(time, restype=restype, check_stop=check_stop)
 
-    def setState(self, val):
+    def reset_stop_code_and_message(self, check_stop=True):
+        '''subroutine reset_stop_code_and_message() bind(C, name="reset_stop_code_and_message")
+  !DEC$ ATTRIBUTES DLLEXPORT :: reset_stop_code_and_message
+end subroutine'''
+        return self.get_lib_function('reset_stop_code_and_message')(check_stop=check_stop)
+
+    def setState(self, val, check_stop=True):
         '''subroutine setState(val) BIND(C, NAME='setState')
   integer, intent(in) :: val
  end subroutine'''
-        return self.get_lib_function('setState')(val)
+        return self.get_lib_function('setState')(val, check_stop=check_stop)
 
-    def set_aerosections_windspeed(self, rotor, uvw):
+    def set_aerosections_windspeed(self, rotor, uvw, check_stop=True):
         '''subroutine set_aerosections_windspeed(rotor, uvw) bind(C, name="set_aerosections_windspeed")
     integer*8, intent(in) :: rotor
     real(c_double),intent(in)   :: uvw(rotors_gl%rotor(rotor)%nbld, rotors_gl%rotor(rotor)%blade(1)%nsec, 3)
   end subroutine'''
-        return self.get_lib_function('set_aerosections_windspeed')(rotor, uvw)
+        return self.get_lib_function('set_aerosections_windspeed')(rotor, uvw, check_stop=check_stop)
 
     def set_orientation_base(self, main_body_name,
                              n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1,
-                             error_code):
+                             error_code, check_stop=True):
         '''subroutine set_orientation_base(main_body_name,  &
 character(kind=c_char, len=1), dimension(256), intent(in) :: main_body_name
 real(kind=c_double), dimension(n_rows, 3),   intent(in) :: mbdy_eulerang_table
@@ -376,13 +420,13 @@ real(kind=c_double), dimension(4),   intent(in) :: mbdy_ini_rotvec_d1
 end subroutine'''
         return self.get_lib_function('set_orientation_base')(main_body_name,
                                                              n_rows, mbdy_eulerang_table, angles_in_deg, reset_orientation, mbdy_ini_rotvec_d1,
-                                                             error_code)
+                                                             error_code, check_stop=check_stop)
 
     def set_orientation_relative(self, main_body_1_name, node_1, main_body_2_name, node_2,
                                  n_rows, mbdy2_eulerang_table, angles_in_deg,
                                  reset_orientation,
                                  mbdy2_ini_rotvec_d1,
-                                 error_code):
+                                 error_code, check_stop=True):
         '''subroutine set_orientation_relative(main_body_1_name, node_1, main_body_2_name, node_2,  &
 character(kind=c_char, len=1),   dimension(256),       intent(in   ) :: main_body_1_name  ! Defined as an array of length 1 characters because of bind.
 character(kind=c_char, len=1),   dimension(256),       intent(in   ) :: main_body_2_name  ! Defined as an array of length 1 characters because of bind.
@@ -401,80 +445,80 @@ end subroutine'''
                                                                  n_rows, mbdy2_eulerang_table, angles_in_deg,
                                                                  reset_orientation,
                                                                  mbdy2_ini_rotvec_d1,
-                                                                 error_code)
+                                                                 error_code, check_stop=check_stop)
 
-    def set_variable_sensor_value(self, id, value):
+    def set_variable_sensor_value(self, id, value, check_stop=True):
         '''subroutine set_variable_sensor_value(id, value) bind(C, name="set_variable_sensor_value")
       integer*8, intent(in) :: id
       real(c_double)        :: value
     end subroutine'''
-        return self.get_lib_function('set_variable_sensor_value')(id, value)
+        return self.get_lib_function('set_variable_sensor_value')(id, value, check_stop=check_stop)
 
-    def set_windfield(self, uvw, box_offset_x, time):
+    def set_windfield(self, uvw, box_offset_x, time, check_stop=True):
         '''subroutine set_windfield(uvw, box_offset_x, time) bind(C, name="set_windfield")
       real*4, intent(in) :: uvw(3, gwsd%TMOD%buffer_points_x,gwsd%TMOD%buffer_points_y,gwsd%TMOD%buffer_points_z)
       real*8, intent(in):: box_offset_x, time
     end subroutine'''
-        return self.get_lib_function('set_windfield')(uvw, box_offset_x, time)
+        return self.get_lib_function('set_windfield')(uvw, box_offset_x, time, check_stop=check_stop)
 
-    def solver_static_delete(self, ):
+    def solver_static_delete(self, check_stop=True):
         '''subroutine solver_static_delete() &
     !DEC$ ATTRIBUTES DLLEXPORT :: solver_static_delete
 end subroutine'''
-        return self.get_lib_function('solver_static_delete')()
+        return self.get_lib_function('solver_static_delete')(check_stop=check_stop)
 
-    def solver_static_init(self, ):
+    def solver_static_init(self, check_stop=True):
         '''subroutine solver_static_init() &
     !DEC$ ATTRIBUTES DLLEXPORT :: solver_static_init
 end subroutine'''
-        return self.get_lib_function('solver_static_init')()
+        return self.get_lib_function('solver_static_init')(check_stop=check_stop)
 
-    def solver_static_run(self, reset_structure, error_code):
+    def solver_static_run(self, reset_structure, error_code, check_stop=True):
         '''subroutine solver_static_run(reset_structure, error_code) bind(C, name="solver_static_run")
     logical(c_bool), intent(in) :: reset_structure
     integer(8), intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('solver_static_run')(reset_structure, error_code)
+        return self.get_lib_function('solver_static_run')(reset_structure, error_code, check_stop=check_stop)
 
-    def solver_static_solve(self, error_code):
+    def solver_static_solve(self, error_code, check_stop=True):
         '''subroutine solver_static_solve(error_code) &
     integer*8, intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('solver_static_solve')(error_code)
+        return self.get_lib_function('solver_static_solve')(error_code, check_stop=check_stop)
 
-    def solver_static_update(self, error_code):
+    def solver_static_update(self, error_code, check_stop=True):
         '''subroutine solver_static_update(error_code) &
     integer*8, intent(out) :: error_code
 end subroutine'''
-        return self.get_lib_function('solver_static_update')(error_code)
+        return self.get_lib_function('solver_static_update')(error_code, check_stop=check_stop)
 
-    def sqr2(self, val):
+    def sqr2(self, val, check_stop=True):
         '''subroutine sqr2(val) BIND(C, NAME='sqr2')
   integer, intent(inout) :: val
  end subroutine'''
-        return self.get_lib_function('sqr2')(val)
+        return self.get_lib_function('sqr2')(val, check_stop=check_stop)
 
-    def step(self, restype):
+    def step(self, restype, check_stop=True):
         '''function step() bind(C, name='step')
       !DEC$ ATTRIBUTES DLLEXPORT :: step
       real(c_double) :: step
     end function'''
-        return self.get_lib_function('step')(restype=restype)
+        return self.get_lib_function('step')(restype=restype, check_stop=check_stop)
 
-    def stop_on_error(self, flag):
+    def stop_on_error(self, flag, check_stop=True):
         '''subroutine stop_on_error(flag) bind(C, name="stop_on_error")
-      logical(c_bool), intent(in) :: flag
-    end subroutine'''
-        return self.get_lib_function('stop_on_error')(flag)
+  logical(c_bool), intent(in) :: flag
+end subroutine'''
+        return self.get_lib_function('stop_on_error')(flag, check_stop=check_stop)
 
-    def structure_reset(self, ):
+    def structure_reset(self, check_stop=True):
         '''subroutine structure_reset() bind(C, name="structure_reset")
     !DEC$ ATTRIBUTES DLLEXPORT :: structure_reset
     integer*4 :: i, j
 end subroutine'''
-        return self.get_lib_function('structure_reset')()
+        return self.get_lib_function('structure_reset')(check_stop=check_stop)
 
-    def test_hdf5(self, ):
+    def test_hdf5(self, check_stop=True):
         '''subroutine test_hdf5() BIND(C, NAME='test_hdf5')
   !DEC$ ATTRIBUTES DLLEXPORT :: test_hdf5
   INTEGER     ::   hdferr ! Error flag
@@ -483,22 +527,22 @@ end subroutine'''
   INTEGER(HID_T) :: H5_Create_file,H5_Open_file      ! File identifier
   type(c_ptr) :: x
  end subroutine'''
-        return self.get_lib_function('test_hdf5')()
+        return self.get_lib_function('test_hdf5')(check_stop=check_stop)
 
-    def work(self, time, restype):
+    def work(self, time, restype, check_stop=True):
         '''function work(time) bind(C, Name='work')
     !DEC$ ATTRIBUTES DLLEXPORT :: work
     real(c_double), intent(in) :: time
     real*4 :: start_time, t
     integer*8 :: N, work
   end function'''
-        return self.get_lib_function('work')(time, restype=restype)
+        return self.get_lib_function('work')(time, restype=restype, check_stop=check_stop)
 
-    def write_output(self, ):
+    def write_output(self, check_stop=True):
         '''subroutine write_output() bind(C, name="write_output")
       !DEC$ ATTRIBUTES DLLEXPORT :: write_output
       integer        :: nr, dummy=1
       character*10 :: status = 'close'
       Type (Toutvar) :: ov_dummy
     end subroutine'''
-        return self.get_lib_function('write_output')()
+        return self.get_lib_function('write_output')(check_stop=check_stop)

{h2lib-13.1.3101.dist-info → h2lib-13.1.3103.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: h2lib
-Version: 13.1.3101
-Summary: Python interface to HAWC2 (13.1.31+1-g14e98da)
+Version: 13.1.3103
+Summary: Python interface to HAWC2 (13.1.31+5-g08eea40)
 Download-URL: 
 Author: Mads M. Pedersen, S.G.Horcas and N.G.Ramos
 Author-email: mmpe@dtu.dk

h2lib-13.1.3103.dist-info/RECORD

@@ -0,0 +1,10 @@
+h2lib/HAWC2Lib.dll,sha256=HMQo1hg0o6ppTuQP7IEkXJdzpf6QAr0TTIH_u5s0RWg,30970368
+h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
+h2lib/_h2lib.py,sha256=EOxtjXytUpbQrDxTNORgZlVcZe2msKWwUXtDUGTHycs,39486
+h2lib/_version.py,sha256=R7-1SL_5w4I6GwKVjYprFWCg2X7FF6zxjqQnGTFxIXc,160
+h2lib/dll_wrapper.py,sha256=NtH3wVJ4okYLBXjdRxpllnImRDE7p692OgHuwHkt-WQ,13552
+h2lib/h2lib_signatures.py,sha256=sPCh92WdCc6brPgARZ_QBgSz49Yjq0M5SpWb0or5KvM,29396
+h2lib-13.1.3103.dist-info/METADATA,sha256=ip-gMxWOmrw2KfZAJ5oW4tnb45TxoEsbVWQRF59WCzQ,862
+h2lib-13.1.3103.dist-info/WHEEL,sha256=ovhA9_Ei_7ok2fAych90j-feDV4goiAxbO7REePtvw0,101
+h2lib-13.1.3103.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
+h2lib-13.1.3103.dist-info/RECORD,,

h2lib-13.1.3101.dist-info/RECORD

@@ -1,10 +0,0 @@
-h2lib/HAWC2Lib.dll,sha256=qiYnZFkH4KmFpojGak9B8Kd9rGGpJWQPb3EWldp2aYo,30946304
-h2lib/__init__.py,sha256=f3fO4I6IEFRM9LaV2O3w9Pioj3GPI8qRl7P5Tg5ONtE,528
-h2lib/_h2lib.py,sha256=Neau9z21Cv6UTSUVOxXOCAy_EEw3Ricl7MLMn9ttgn0,36903
-h2lib/_version.py,sha256=PE2MdeTTxKGGEB-pQZrXsw_o_fG0PG6oHUGIzj2T5Oc,160
-h2lib/dll_wrapper.py,sha256=ZkcHog6jdVvzRNbVFza0atmMDTlbErf-42IqYITdVRE,12897
-h2lib/h2lib_signatures.py,sha256=hDefbIIUVPdyc-PqV6_tdzmoJVKUrsTJ8rm1JV24yH0,25073
-h2lib-13.1.3101.dist-info/METADATA,sha256=oQvnzep9gesJ_S4bHgrt1fxJ9AksPpIIqd-gs4Q_YKc,862
-h2lib-13.1.3101.dist-info/WHEEL,sha256=ovhA9_Ei_7ok2fAych90j-feDV4goiAxbO7REePtvw0,101
-h2lib-13.1.3101.dist-info/top_level.txt,sha256=y_a-tUqphEZQ_0nsWSMaSb21P8Lsd8hUxUdE9g2Dcbk,6
-h2lib-13.1.3101.dist-info/RECORD,,