wawi 0.0.5__py3-none-any.whl → 0.0.8__py3-none-any.whl

wawi/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.5"
+__version__ = "0.0.8"
 
 __pdoc__ = dict()
 __pdoc__['wawi.abq'] = False

wawi/io.py

@@ -355,25 +355,25 @@ def import_wadam_hydro_transfer(wadam_file):
         6-by-len(theta)-by-len(omega)
     '''
 
-    string = ('.+W A V E  P E R I O D.+=\s+(?P<period>.+):.+\n.+'
-              'H E A D I N G   A N G L E.+=\s+(?P<theta>.+):(?:.*\n){5,10}'
+    string = (r'.+W A V E  P E R I O D.+=\s+(?P<period>.+):.+\n.+'
+              r'H E A D I N G   A N G L E.+=\s+(?P<theta>.+):(?:.*\n){5,10}'
               
-              '.+EXCITING FORCES AND MOMENTS FROM THE HASKIN RELATIONS(?:.*\n){4,6}\s+'
+              r'.+EXCITING FORCES AND MOMENTS FROM THE HASKIN RELATIONS(?:.*\n){4,6}\s+'
               
-              '-F1-\s+(?P<F1_real>[-?.E\d+]+)\s+(?P<F1_imag>[-?.E\d+]+)\s.+\n\s+'
-              '-F2-\s+(?P<F2_real>[-?.E\d+]+)\s+(?P<F2_imag>[-?.E\d+]+)\s.+\n\s+'
-              '-F3-\s+(?P<F3_real>[-?.E\d+]+)\s+(?P<F3_imag>[-?.E\d+]+)\s.+\n\s+'
-              '-F4-\s+(?P<F4_real>[-?.E\d+]+)\s+(?P<F4_imag>[-?.E\d+]+)\s.+\n\s+'
-              '-F5-\s+(?P<F5_real>[-?.E\d+]+)\s+(?P<F5_imag>[-?.E\d+]+)\s.+\n\s+'
-              '-F6-\s+(?P<F6_real>[-?.E\d+]+)\s+(?P<F6_imag>[-?.E\d+]+)\s.+\n')
+              r'-F1-\s+(?P<F1_real>[-?.E\d+]+)\s+(?P<F1_imag>[-?.E\d+]+)\s.+\n\s+'
+              r'-F2-\s+(?P<F2_real>[-?.E\d+]+)\s+(?P<F2_imag>[-?.E\d+]+)\s.+\n\s+'
+              r'-F3-\s+(?P<F3_real>[-?.E\d+]+)\s+(?P<F3_imag>[-?.E\d+]+)\s.+\n\s+'
+              r'-F4-\s+(?P<F4_real>[-?.E\d+]+)\s+(?P<F4_imag>[-?.E\d+]+)\s.+\n\s+'
+              r'-F5-\s+(?P<F5_real>[-?.E\d+]+)\s+(?P<F5_imag>[-?.E\d+]+)\s.+\n\s+'
+              r'-F6-\s+(?P<F6_real>[-?.E\d+]+)\s+(?P<F6_imag>[-?.E\d+]+)\s.+\n')
     regex = re.compile(string) 
     
-    nondim_string = ('\s+NON-DIMENSIONALIZING FACTORS:\n(?:.*\n)+'
-                     '\s+RO\s+=\s+(?P<rho>[-?.E\d+]+)\n'
-                     '\s+G\s+=\s+(?P<g>[-?.E\d+]+)\n'
-                     '\s+VOL\s+=\s+(?P<vol>[-?.E\d+]+)\n'
-                     '\s+L\s+=\s+(?P<l>[-?.E\d+]+)\n'
-                     '\s+WA\s+=\s+(?P<wa>[-?.E\d+]+)')
+    nondim_string = (r'\s+NON-DIMENSIONALIZING FACTORS:\n(?:.*\n)+'
+                     r'\s+RO\s+=\s+(?P<rho>[-?.E\d+]+)\n'
+                     r'\s+G\s+=\s+(?P<g>[-?.E\d+]+)\n'
+                     r'\s+VOL\s+=\s+(?P<vol>[-?.E\d+]+)\n'
+                     r'\s+L\s+=\s+(?P<l>[-?.E\d+]+)\n'
+                     r'\s+WA\s+=\s+(?P<wa>[-?.E\d+]+)')
     
     regex_nondim = re.compile(nondim_string) 
     

wawi/modal.py

@@ -17,7 +17,7 @@ def maxreal(phi):
         complex-valued modal transformation matrix, with vectors rotated to have maximum real parts
     """   
 
-    angles = np.expand_dims(np.arange(0,np.pi/2, 0.01), axis=0)
+    angles = np.expand_dims(np.arange(0,np.pi, 0.01), axis=0)
     phi_max_real = np.zeros(np.shape(phi)).astype('complex')
     for mode in range(0,np.shape(phi)[1]):
         rot_mode = np.dot(np.expand_dims(phi[:, mode], axis=1), np.exp(angles*1j))

wawi/plot.py

@@ -9,9 +9,9 @@ from scipy.interpolate import RectBivariateSpline, interp1d
 
 def plot_ads(ad_dict, v, terms='stiffness', num=None, test_v=dict(), test_ad=dict(), zasso_type=False, ranges=None):
     # v: v or K
-    if terms is 'stiffness':
+    if terms == 'stiffness':
         terms = [['P4', 'P6', 'P3'], ['H6', 'H4', 'H3'], ['A6', 'A4', 'A3']]
-    elif terms is 'damping':
+    elif terms == 'damping':
         terms = [['P1', 'P5', 'P2'], ['H5', 'H1', 'H2'], ['A5', 'A1', 'A2']]
 
     # Create exponent defs for K_normalized plotting
@@ -60,9 +60,9 @@ def plot_ads(ad_dict, v, terms='stiffness', num=None, test_v=dict(), test_ad=dic
     
     for col_ix in range(len(terms)):
         if zasso_type:
-            ax[-1, col_ix].set_xlabel('$K$')
+            ax[-1, col_ix].set_xlabel(r'$K$')
         else:
-            ax[-1, col_ix].set_xlabel('$V/(B\cdot \omega)$')
+            ax[-1, col_ix].set_xlabel(r'$V/(B\cdot \omega)$')
     
     fig.tight_layout()
     return fig, ax
@@ -98,7 +98,7 @@ def plot_dir_and_crests(theta0, Tp, arrow_length=100, origin=np.array([0,0]),
     wave_length = 2*np.pi/get_kappa(2*np.pi/Tp, U=0.0)
 
     plt.arrow(origin[0],origin[1], arrow_length*v[0], arrow_length*v[1], **arr_opts)
-    plt.text(origin[0], origin[1], f'$\\theta_0$ = {theta0}$^o$\n $T_p$={Tp} s\n $\lambda=${wave_length:.0f} m')
+    plt.text(origin[0], origin[1], f'$\\theta_0$ = {theta0}$^o$\n $T_p$={Tp} s\n $\\lambda=${wave_length:.0f} m')
 
     dv = v*wave_length
     for n in range(n_repeats):
@@ -317,7 +317,10 @@ def _set_axes_radius(ax, origin, radius):
     ax.set_ylim3d([y - radius, y + radius])
     ax.set_zlim3d([z - radius, z + radius])
 
-def equal_3d(ax=plt.gca()):
+def equal_3d(ax=None):
+    if ax is None:
+        ax = plt.gca()
+
     x_lims = np.array(ax.get_xlim())
     y_lims = np.array(ax.get_ylim())
     z_lims = np.array(ax.get_zlim())

wawi/wind.py

@@ -526,7 +526,7 @@ def kaimal_auto(omega, Lx, A, sigma, V):
 
     return S/(2*np.pi)
 
-def von_Karman_auto(omega, Lx, sigma, V):
+def von_karman_auto(omega, Lx, sigma, V):
    
     A1 = [
         0.0,
@@ -552,7 +552,7 @@ def von_Karman_auto(omega, Lx, sigma, V):
     
     return S/(2*np.pi)
 
-def generic_kaimal_matrix(omega, nodes, T_wind, A, sigma, C, Lx, U, options=None):
+def generic_kaimal_matrix(omega, nodes, T_wind, A, sigma, C, Lx, U, spectrum_type='kaimal'):
     # Adopted from MATLAB version. `nodes` is list with beef-nodes.        
     V = np.zeros(len(nodes))      # Initialize vector with mean wind in all nodes
     Su = np.zeros([len(nodes), len(nodes)])     # One-point spectra for u component in all nodes
@@ -560,22 +560,16 @@ def generic_kaimal_matrix(omega, nodes, T_wind, A, sigma, C, Lx, U, options=None
     Sw = np.zeros([len(nodes), len(nodes)])     # One-point spectra for w component in all nodes
     xyz = np.zeros([len(nodes), 3])  # Nodes in wind coordinate system
 
-    if options is None:
-        options = {
-            'spectra_type': 'Kaimal'
-            }
-
     for node_ix, node in enumerate(nodes):
         xyz[node_ix,:] = (T_wind @ node.coordinates).T #Transform node coordinates to the wind coordinate system
         V[node_ix] = U(node.coordinates) # Mean wind velocity in the nodes
 
-        if 'spectra_type' in options:
-            if options['spectra_type'] == 'vonKarman':
-                Su[node_ix,:], Sv[node_ix,:], Sw[node_ix,:] = von_Karman_auto(omega, Lx, sigma, V[node_ix]) 
-            elif options['spectra_type'] == 'Kaimal':
-                Su[node_ix,:], Sv[node_ix,:], Sw[node_ix,:] = kaimal_auto(omega, Lx, A, sigma, V[node_ix]) # One point spectra for u component in all nodes
-        else: # use Kaimal (default)
-            Su[node_ix,:], Sv[node_ix,:], Sw[node_ix,:] = kaimal_auto(omega, Lx, A, sigma, V[node_ix])
+        if 'karman' in spectrum_type.lower():
+            Su[node_ix,:], Sv[node_ix,:], Sw[node_ix,:] = von_karman_auto(omega, Lx, sigma, V[node_ix]) 
+        elif spectrum_type.lower() == 'kaimal':
+            Su[node_ix,:], Sv[node_ix,:], Sw[node_ix,:] = kaimal_auto(omega, Lx, A, sigma, V[node_ix]) # One point spectra for u component in all nodes
+        else:
+            raise ValueError('spectrum_type must either be defined as "vonKarman"/"Karman" or "Kaimal"')
 
     x = xyz[:, 0]
     y = xyz[:, 1]
@@ -822,7 +816,7 @@ def windaction_static(load_coefficients, elements, T_wind,
             mean_wind = U(el.get_cog())         
             Vn = normal_wind(T_wind, el.T0)*mean_wind        # Find the normal wind
             BqBq = loadmatrix_fe_static(Vn, lc_fun(el), rho, B_fun(el), D_fun(el))
-            R1, R2 = loadvector(el.T0, BqBq, T_wind, el.L, static = True) # Obtain the load vector for each element
+            R1, R2 = loadvector(el.T0, BqBq, T_wind, el.L, static=True) # Obtain the load vector for each element
 
             RG[node1_dofs] = RG[node1_dofs] + R1[:,0]   # Add the contribution from the element (end 1) to the system
             RG[node2_dofs] = RG[node2_dofs] + R2[:,0]    # Add the contribution from the element (end 2) to the system
@@ -833,12 +827,11 @@ def windaction_static(load_coefficients, elements, T_wind,
         for node in nodes:
             ix = node.index
             n = np.r_[6*ix:6*ix+6]
-            RG_block[np.ix_(n)] = RG[n]     #verified with MATLAB version for beam example
+            RG_block[np.ix_(n)] = RG[n]
             
-               
-        genSqSq = phi.T @ RG_block 
+        genF = phi.T @ RG_block 
     
-    return genSqSq
+    return genF
 
 def K_from_ad(ad, V, w, B, rho):
     if w==0:

{wawi-0.0.5.dist-info → wawi-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wawi
-Version: 0.0.5
+Version: 0.0.8
 Summary: WAve and WInd response prediction
 Author-email: "Knut A. Kvåle" <knut.a.kvale@ntnu.no>, Ole Øiseth <ole.oiseth@ntnu.no>, Aksel Fenerci <aksel.fenerci@ntnu.no>, Øivind Wiig Petersen <oyvind.w.petersen@ntnu.no>
 License: MIT License
@@ -69,6 +69,65 @@ pip install git+https://www.github.com/knutankv/wawi.git@main
 
 Quick start
 =======================
+Assuming a premade WAWI-model is created and saved as `MyModel.wwi´, it can be imported as follows:
+
+```python
+from wawi.model import Model, Windstate, Seastate
+
+model = Model.load('MyModel.wwi')
+model.n_modes = 50                  # number of dry modes to use for computation
+omega = np.arange(0.001, 2, 0.01)   # frequency axis to use for FRF
+```
+
+A windstate (U=20 m/s with origin 90 degrees and other required properties) and a seastate (Hs=2.1m, Tp=8.3s, gamma=8, s=12, heading 90 deg) is created and assigned to the model:
+
+```python
+# Wind state
+U0 = 20.0
+direction = 90.0
+windstate = Windstate(U0, direction, Iu=0.136, Iw=0.072,
+                      Au=6.8, Aw=9.4, Cuy=10.0, Cwy=6.5,  
+                      Lux=115, Lwx=9.58, spectrum_type='kaimal')
+model.assign_windstate(windstate)
+
+# Sea state
+Hs = 2.1
+Tp = 8.3
+gamma = 8
+s = 12
+theta0 = 90.0
+seastate = Seastate(Tp, Hs, gamma, theta0, s)
+model.assign_seastate(seastate)
+```
+
+The model is plotted by envoking this command:
+
+```python
+model.plot()
+```
+
+which gives this plot of the model and the wind and wave states:
+![Model](https://raw.githubusercontent.com/knutankv/wawi/main/docs/model.png)
+
+Then, response predictions can be run by the `run_freqsim` method or iterative modal analysis (combined system) conducted by `run_eig`:
+
+```python
+model.run_eig(include=['hydro', 'aero'])
+model.run_freqsim(omega)
+```
+
+The results are stored in `model.results`, and consists of modal representation of the response (easily converted to relevant physical counterparts using built-in methods) or modal parameters of the combined system (natural frequencies, damping ratio, mode shapes). 
+
+The resulting first mode shape is plotted as follows:
+
+```python
+model.plot_mode(0)
+```
+
+This results in this plot:
+![Mode 1](https://raw.githubusercontent.com/knutankv/wawi/main/docs/mode1.png)
+
+For more details and recommendations regarding the analysis setup, it is referred to the examples provided and the code reference.
 
 Examples
 =======================
@@ -79,7 +138,7 @@ References
 
 Citation
 =======================
-Zenodo research entry:
+Zenodo research entry: [![DOI](https://zenodo.org/badge/921621297.svg)](https://doi.org/10.5281/zenodo.14895014)
 
 Support
 =======================

{wawi-0.0.5.dist-info → wawi-0.0.8.dist-info}/RECORD

@@ -1,10 +1,10 @@
-wawi/__init__.py,sha256=UmlmJ1lvY8_pmiLPeP6iSfUoh1tH7dgtviM54FItU8Y,158
+wawi/__init__.py,sha256=oZOxto9PG8WxUfEE02tcFY0o5-yLRR8lK8WXH30zxDE,158
 wawi/fe.py,sha256=22QKI1GlfsG7o_TpFXaKJfzmbO2_2zdIMaoJmaIZdmY,4001
 wawi/general.py,sha256=xHRoDkcchrL6Y7pTUqGsjBHh8YBLvX9dYcNXXCjQap8,13787
 wawi/identification.py,sha256=bVB6EVRR6J39OO9ckuzNJ6f0FwIo4cLqfYgrsIN89TE,1748
-wawi/io.py,sha256=5p3q_lQStQR85yo5hZ1Syl25RS2C__zIyV6e_2qRRw4,25308
-wawi/modal.py,sha256=c8cZ98y8BZuFcfrwweE75AAX7QGFDfjLeYK07hzAvCo,20249
-wawi/plot.py,sha256=XVaQjkjXv26Kt-G8xtAULa4KbWcCIErTQfB6euPACLg,19750
+wawi/io.py,sha256=NrziwlebaZUEdu8nWKNXKExHNZZKMzJ0gSHciBTJ4As,25323
+wawi/modal.py,sha256=WjNGFsk0C3tYRy18Q9WNRCatmGJtq1JSv0WrkGV02Eo,20247
+wawi/plot.py,sha256=jllJcjZxTBqjzBoT4k9jLXVUnie8oqNr8371IJvCd3c,19791
 wawi/prob.py,sha256=0nCdKdwkNf4M6sHyCZuYlt06gD0NmqRNfl4KesgySWA,215
 wawi/random.py,sha256=MHPpyTlRJSJFkCmeTAmw4Q5K1BPoFVb0Nxg0jDhkuIM,871
 wawi/signal.py,sha256=9HJs7VUhXOccuYPo12A0IUVoBIAJ2e_9F3rL-q3JuP4,1179
@@ -12,10 +12,10 @@ wawi/structural.py,sha256=t25ohH4uBbzUJ7Hqn_kUfYhxcikZkRp8da-9dn7aEbw,8341
 wawi/time_domain.py,sha256=Oe-jviwDtBgpSmA7ZVmKEqQ5tdvsekXwOakYO1qUsN4,3841
 wawi/tools.py,sha256=-hFBvf0qK4AMn2MQRhrOitDMMMKm2QuRkVfbPBefEkQ,332
 wawi/wave.py,sha256=hhKg3KhKMBhOoCI7g8PFOGUbYgVhDyGmnYdBEdJ8mkY,16064
-wawi/wind.py,sha256=kyDT-CuVoRdyynDWFW4BLxCj08qrz073c5bi3TgMJFs,38451
+wawi/wind.py,sha256=1rUqiEdMaUrhprs87TBdX24l1uDCOINaYkBChMLYWso,38208
 wawi/wind_code.py,sha256=8OKLPpqc84obNNKBoYb2NunKjcn6a3i_pAWpIFEwg4Q,223
-wawi-0.0.5.dist-info/LICENSE,sha256=bH1aWhrNbbPLrYnVFRaoYYzcUr-figHjry-kGB7Tc54,1076
-wawi-0.0.5.dist-info/METADATA,sha256=SM_H-uu51J62GxpCklSaS5af_vanAGTVTrEB23Ws36M,3133
-wawi-0.0.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-wawi-0.0.5.dist-info/top_level.txt,sha256=sE2NH_xVXnDKTGeIYzeX5IyU_j5vYDLl32v5uLiOMT4,5
-wawi-0.0.5.dist-info/RECORD,,
+wawi-0.0.8.dist-info/LICENSE,sha256=bH1aWhrNbbPLrYnVFRaoYYzcUr-figHjry-kGB7Tc54,1076
+wawi-0.0.8.dist-info/METADATA,sha256=nlNip0I5cZlcT3lgLf5lXTysEeQ2y8nSVMapDTvoXlA,5197
+wawi-0.0.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+wawi-0.0.8.dist-info/top_level.txt,sha256=sE2NH_xVXnDKTGeIYzeX5IyU_j5vYDLl32v5uLiOMT4,5
+wawi-0.0.8.dist-info/RECORD,,