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

tests/test_IABSE_step2a.py

@@ -0,0 +1,263 @@
+import pytest
+import numpy as np
+from math import isclose
+import dill
+
+# use the local wawi (Github folder) instead of the installed version (remove this when using the installed version)
+import sys
+import os
+sys.path.insert(0, os.path.abspath('C:\\Users\\aksef\\Documents\\GitHub\\wawi'))
+
+from wawi.io import import_folder
+from wawi.model import Windstate
+from wawi.wind import ADs
+from wawi.wind import itflutter_cont_naive
+
+model_folder = './tests/models/model_2a'
+
+def AD_dict(AD_funs):
+    AD_s = dict(
+        A1 = lambda v: -AD_funs['a_fun'][0](v), # sign convention
+        A2 = AD_funs['a_fun'][1],
+        A3 = AD_funs['a_fun'][2],
+        A4 = lambda v: -AD_funs['a_fun'][3](v),
+        A5 = lambda v: -AD_funs['a_fun'][4](v),
+        A6 = lambda v: -AD_funs['a_fun'][5](v),
+        
+        H1 = AD_funs['h_fun'][0],
+        H2 = lambda v: -AD_funs['h_fun'][1](v),
+        H3 = lambda v: -AD_funs['h_fun'][2](v),
+        H4 = AD_funs['h_fun'][3],
+        H5 = AD_funs['h_fun'][4],
+        H6 = AD_funs['h_fun'][5],
+        
+        P1 = AD_funs['p_fun'][0],
+        P2 = lambda v: -AD_funs['p_fun'][1](v),
+        P3 = lambda v: -AD_funs['p_fun'][2](v),
+        P4 = AD_funs['p_fun'][3],
+        P5 = AD_funs['p_fun'][4],
+        P6 = AD_funs['p_fun'][5],
+        )
+    return AD_s
+
+def iabse_2a_windstate(mean_v):
+    windstate = Windstate(mean_v, 
+                                  90, 
+                                  Iu=0.1, 
+                                  Iw=0.05, 
+                                  Au=6.8, Aw=9.4,  # not used in von Karman
+                                  Cuy=10.0, Cwy=6.5,
+                                  Cuz=10.0, Cwz=3.0,
+                                  Lux=200.0, Lwx=20.0,
+                                  x_ref=[0,0,0], rho=1.22,
+                                 spectrum_type='vonKarman'
+                                  )
+
+    return windstate
+
+davenport = lambda fred: 2*(7*fred-1+np.exp(-7*fred))/(7*fred)**2
+
+@pytest.mark.parametrize(
+    'V, expected_f, expected_zeta, tol',
+    [(15, 0.274, 0.008 , 0.1), 
+     (30, 0.267, 0.014, 0.1), 
+     (45, 0.254 , 0.019, 0.1),
+     (60, 0.234, 0.015, 0.1),
+     (68, 0.220 , 0.004, 0.15)],
+)
+
+def test_in_wind_frequencies_and_damping( V, expected_f, expected_zeta, tol):
+    # importing the relevant model
+    model = import_folder(model_folder)
+    model.modal_dry.xi0 = .3e-2
+
+    # assign ADs (BB3 ADs)
+    with open( model_folder + '/AD_funs_BB3_scanlan.pkl', 'rb') as file:
+        AD_funs = dill.load(file)
+    AD_s = AD_dict(AD_funs)
+    for key in model.aero.sections:
+        model.aero.sections[key].ADs = ADs(**AD_s)
+
+    model.aero.windstate = iabse_2a_windstate(V)
+    model.run_eig(w_initial=model.modal_dry.omega_n.tolist(), freq_kind=True, itmax=100)
+    lambd = model.results.lambd
+
+    f9 =  np.abs(lambd[8].imag) / (2*np.pi) 
+    zeta9 =  -lambd[8].real/ np.abs(lambd[8])
+
+    assert isclose(f9, expected_f, rel_tol = tol)
+    assert isclose(zeta9, expected_zeta, rel_tol = tol)
+
+# flutter speed
+def test_flutter():
+    expected_flutter_speed = 69.8 # m/s (reference value from paper)
+    tol = 0.01
+    with open( model_folder + '/AD_funs_BB3_scanlan.pkl', 'rb') as file:
+        AD_funs = dill.load(file)
+    ad_dict = AD_dict(AD_funs)
+
+    # importing the relevant model
+    model = import_folder(model_folder)
+    model.modal_dry.xi0 = .3e-2
+    B = model.aero.sections['girder'].B
+
+    Ms = model.dry_M
+    Cs = model.dry_C
+    Ks = model.dry_K
+    phi = model.get_dry_phi('full')
+
+    # calculate the flutter speed
+    x_coor = [node.coordinates[0] for node in model.eldef.nodes ]
+
+    res = itflutter_cont_naive(Ms, Cs, Ks, phi, x_coor, ad_dict, B, V=0.1, rho=1.22, dV=5, 
+                overshoot_factor=0.5, itmax={}, tol={}, print_progress=True)
+
+    assert isclose(res['V'][-1], expected_flutter_speed, rel_tol = tol)
+
+
+# spectra of vertical and torsional response at 45 m/s
+def test_RS_spectra():
+   
+    V = 45
+
+    # omega_axis 
+    omega = (2*np.pi)*np.array([0.086,	0.1,	0.123,	0.142,	0.151,	0.179,	0.2,	0.236,	0.247,	0.262,	0.278,	0.283,	0.3, 0.379,])
+
+    Sz_midspan_expected = np.array([2.5816E+00	,
+                                    3.9291E+00	,
+                                    1.2792E+00	,
+                                    8.3683E-01	,
+                                    3.6548E-01	,
+                                    6.1153E-02	,
+                                    2.5616E-02	,
+    ])
+    Szeq_midspan_expected = np.array([9.7440E-03	,
+                                    4.1529E-03	,
+                                    1.1582E-02	,
+                                    1.2131E-02	,
+                                    1.2402E-02	,
+                                    1.4801E-02	,
+                                    2.0026E-02	,
+                                    9.3995E-02	,
+                                    3.5115E-01	,
+                                    2.9514E-01	,
+                                    3.1238E-02	,
+                                    2.0048E-02	,
+                                    6.3728E-03	,
+    ])
+    Sz_qspan_expected = np.array([5.7483E+00	,
+                                2.3605E+00	,
+                                7.0894E-01	,
+                                4.9097E-01	,
+                                2.1767E-01	,
+                                3.9699E-02	,
+                                1.7792E-02	,
+    ])
+    Szeq_qspan_expected = np.array([4.0150E-03	,
+                                    3.5677E-03	,
+                                    4.8657E-03	,
+                                    5.4711E-03	,
+                                    5.5522E-03	,
+                                    6.1715E-03	,
+                                    7.8843E-03	,
+                                    3.2631E-02	,
+                                    1.1894E-01	,
+                                    1.0044E-01	,
+                                    1.1859E-02	,
+                                    8.1749E-03	,
+                                    3.9972E-03	,
+                                    1.5413E-02	,
+    ])
+
+    # import the model and assign properties
+    model = import_folder(model_folder)
+    model.modal_dry.xi0 = .3e-2
+
+    # assign ADs (BB3 ADs)
+    with open( model_folder + '/AD_funs_BB3_scanlan.pkl', 'rb') as file:
+        AD_funs = dill.load(file)
+    AD_s = AD_dict(AD_funs)
+    for key in model.aero.sections:
+        model.aero.sections[key].ADs = ADs(**AD_s)
+
+    # assign windstate
+    model.aero.windstate = iabse_2a_windstate(V)
+    # admittance
+    for key in model.aero.sections:
+        model.aero.sections[key].Admittance = lambda fred: np.full((4, 3), davenport(fred))
+
+    # run analysis
+    model.run_freqsim(omega,
+                        include_selfexcited=['aero'], 
+                        include_action=['aero'],
+                        print_progress=False, merge_aero_sections=True,
+                                            ensure_at_peaks=False) # keep the given frequency axis
+
+
+    # extract PSD - at the midpsan
+    global_dof_ix_ms = model.eldef.node_dof_lookup(36) # node 36 is the midspan node
+    S = model.get_result_psd(key='full', 
+                            index=global_dof_ix_ms[1:4])
+    # extract PSD - at the quarter-span
+    global_dof_ix_qs = model.eldef.node_dof_lookup(26) # node 26 is the quarter-span node
+    Sq = model.get_result_psd(key='full', 
+                            index=global_dof_ix_qs[1:4])
+
+    assert np.allclose((2*np.pi)*S[1,1,range(len(Sz_midspan_expected))], Sz_midspan_expected, rtol=1e-1)
+    assert np.allclose((31/2)**2*(2*np.pi)*S[2,2,range(len(Szeq_midspan_expected))], Szeq_midspan_expected, rtol=2e-1)
+
+    assert np.allclose((2*np.pi)*Sq[1,1,range(len(Sz_qspan_expected))], Sz_qspan_expected, rtol=1e-1)
+    assert np.allclose((31/2)**2*(2*np.pi)*Sq[2,2,range(len(Szeq_qspan_expected))], Szeq_qspan_expected, rtol=35e-2)
+
+# buffeting responses (RMS values)
+@pytest.mark.parametrize(
+    'Vbuff, RMS_horz_exp1, RMS_vert_exp1, RMS_tors_exp1, RMS_horz_exp2, RMS_vert_exp2, RMS_tors_exp2',
+    [(15.,   0.019,	0.058,	0.009, 0.015,	0.078,	0.006  ), 
+     (30.,	0.128,	0.238,	0.051, 0.091,	0.296,	0.035  ), 
+     (45.,	0.316,	0.508,	0.150, 0.225,	0.563,	0.103  ),
+     (60.,	0.557,	0.879,	0.417, 0.413,	0.880,	0.273  ),
+    ],
+    )
+
+def test_RMS_response(Vbuff, RMS_horz_exp1, RMS_vert_exp1, RMS_tors_exp1, RMS_horz_exp2, RMS_vert_exp2, RMS_tors_exp2):
+    omega = np.linspace(0.0001, 4, 3000)
+
+    # import the model and assign properties
+    model = import_folder(model_folder)
+    model.modal_dry.xi0 = .3e-2
+
+    # assign ADs (BB3 ADs)
+    with open( model_folder + '/AD_funs_BB3_scanlan.pkl', 'rb') as file:
+        AD_funs = dill.load(file)
+    AD_s = AD_dict(AD_funs)
+    for key in model.aero.sections:
+        model.aero.sections[key].ADs = ADs(**AD_s)
+
+    # assign windstate
+    model.aero.windstate = iabse_2a_windstate(Vbuff)
+    # admittance
+    for key in model.aero.sections:
+        model.aero.sections[key].Admittance = lambda fred: np.full((4, 3), davenport(fred))
+
+    #model.run_eig(w_initial=model.modal_dry.omega_n.tolist(), freq_kind=True, itmax=100) # alters integration 
+
+    # run analysis
+    model.run_freqsim(omega,
+                        include_selfexcited=['aero'], 
+                        include_action=['aero'],
+                        print_progress=False, merge_aero_sections=True) 
+    # RMS responses
+    stds = model.get_result_std(key = 'full')
+    # global dofs
+    global_dof_ix1 = model.eldef.node_dof_lookup(36)[1:4]
+    global_dof_ix2 = model.eldef.node_dof_lookup(26)[1:4]
+
+    assert isclose(stds[global_dof_ix1][0], RMS_horz_exp1, rel_tol = 15e-2) # midspan horizontal 
+    assert isclose(stds[global_dof_ix1][1], RMS_vert_exp1, rel_tol = 15e-2) # midspan vertical 
+    assert isclose(stds[global_dof_ix1][2]*31/2, RMS_tors_exp1, rel_tol = 15e-2) # midspan torsional 
+
+    assert isclose(stds[global_dof_ix2][0], RMS_horz_exp2, rel_tol = 15e-2) # q-span horizontal 
+    assert isclose(stds[global_dof_ix2][1], RMS_vert_exp2, rel_tol = 15e-2) # q-span vertical 
+    assert isclose(stds[global_dof_ix2][2]*31/2, RMS_tors_exp2, rel_tol = 20e-2) # q-span torsional 
+
+

tests/test_wind.py

@@ -0,0 +1,71 @@
+
+# test wind functions 
+
+# wind state 
+
+# from wawi.model import Windstate
+
+# use the local wawi (Github folder) instead of the installed version
+import sys
+import os
+sys.path.insert(0, os.path.abspath('C:\\Users\\aksef\\Documents\\GitHub\\wawi'))
+from wawi.model import Windstate
+
+
+from math import isclose
+
+
+def test_windstate():
+
+    V0 = 40.0 # these could be also parametrized
+
+    dir = 45 
+    Iu=2.0/V0
+    Iw=1.0/V0 
+    Au=30 
+    Aw=3 
+    Cuy=10.0
+    Cwy=8.0
+    Cuz=10.0
+    Cwz=8.0
+    Lux=60
+    Lwx=60
+    x_ref=[0,0,0]
+    rho=1.25
+
+    tol = 1e-5
+
+    # Act
+    windstate = Windstate(V0, 
+                        dir, 
+                        Iu=Iu, 
+                        Iw=Iw, 
+                        Au=Au, Aw=Aw, 
+                        Cuy=Cuy, Cwy=Cwy,
+                        Cuz=Cuz, Cwz=Cwz,
+                        Lux=Lux, Lwx=Lwx,
+                        x_ref=x_ref, rho=rho)
+
+    # Assert
+    assert isclose(windstate.V0, V0, rel_tol = tol)
+    assert isclose(windstate.direction, dir, rel_tol = tol)
+    assert isclose(windstate.Iu, Iu, rel_tol = tol)
+    assert isclose(windstate.Iw, Iw, rel_tol = tol)
+    assert isclose(windstate.Au, Au, rel_tol = tol)
+    assert isclose(windstate.Aw, Aw, rel_tol = tol)
+
+    assert isclose(windstate.Cuy, Cuy, rel_tol = tol)
+    assert isclose(windstate.Cwy, Cwy, rel_tol = tol)
+    assert isclose(windstate.Cuz, Cuz, rel_tol = tol)
+    assert isclose(windstate.Cwz, Cwz, rel_tol = tol)
+
+    assert isclose(windstate.Lux, Lux, rel_tol = tol)
+    assert isclose(windstate.Lwx, Lwx, rel_tol = tol)
+    assert isclose(windstate.rho, rho, rel_tol = tol)
+
+    assert all(abs(a - b) <= tol for a, b in zip(windstate.x_ref, x_ref))
+
+
+
+
+

wawi/__init__.py

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

wawi/ext/abq.py

@@ -0,0 +1,259 @@
+import numpy as np
+import numpy as np
+import pdb
+
+from abaqus import *
+from abaqus import session
+from abaqusConstants import *
+import __main__
+import section
+import regionToolset
+import displayGroupMdbToolset as dgm
+import step
+import part
+import material
+import assembly
+import interaction
+import load
+import mesh
+import optimization
+import job
+import sketch
+import visualization
+import xyPlot
+import displayGroupOdbToolset as dgo
+import connectorBehavior
+import symbolicConstants
+import odbAccess
+import shutil
+
+import regionToolset
+
+import csv
+from copy import deepcopy
+
+
+def get_db(db_type):
+    """
+    Return the current database (either a model or an odb object).
+
+    If a model db is wanted and no model is active, the model in the mdb is selected regardless,
+    as long as there is only one model open in the mdb. If no database fits the requirements, None is returned.
+
+    Args:
+        db_type: 'odb' or 'model'
+    Returns:
+        db: database
+
+    NTNU / Knut Andreas Kvaale, 2018
+    """
+    if db_type is 'model' or db_type is 'mdb':
+        if not session_is_odb():
+            db = mdb.models[session.viewports['Viewport: 1'].displayedObject.modelName]
+        elif len(mdb.models.keys()) is 1:
+            db = mdb.models[mdb.models.keys()[0]]
+        elif len(mdb.models.keys()) > 1:
+            raise AttributeError('No model is not active, and more than one model is available in model database. Impossible to select correct.')
+        else:
+            db = None
+    else:
+        if session_is_odb():
+            db = session.viewports[session.currentViewportName].displayedObject
+        else:
+            db = None
+
+    return db
+
+def session_is_odb():
+    """
+    Check if current session is ODB.
+
+    Returns:
+        is_odb: boolean indicating if the session is odb or not
+    """    
+    is_odb =(('session' in locals() or 'session' in globals()) and
+        session.viewports['Viewport: 1'].displayedObject is not None and
+        hasattr(session.viewports['Viewport: 1'].displayedObject, 'jobData'))
+
+    return is_odb
+
+def sort_nodes(nodes, sort_nodes_fun=lambda node: node.label):
+    if sort_nodes_fun is not None:
+        sort_val = [sort_nodes_fun(node) for node in nodes]
+        sort_ix = np.argsort(sort_val)
+        nodes_new = [None] * len(nodes)
+        for node,ix in zip(nodes,sort_ix):
+            nodes_new[ix] = node
+
+        return nodes_new
+    else:
+        return nodes
+
+def get_element_matrices(region, obj=None, sort_nodes_fun=lambda node: node.label):
+    
+    if region.nodes is None:    #element region
+        if obj is None:
+            raise ValueError('If region is of element type, `obj` must be given as input. This is either an `instance` object or a `rootAssembly`')
+
+        elements = region.elements
+        element_labels = [el.label for el in elements]
+        element_matrix = np.zeros([len(element_labels), 3])
+
+        node_labels = []
+        for ix,el in enumerate(elements):
+            element_matrix[ix,0] = el.label
+            nodes = list(el.connectivity)
+            if len(nodes)==3:
+                __ = nodes.pop(1)    #remove middle node
+            element_matrix[ix, 1:] = nodes
+
+            for node in nodes:
+                if node not in node_labels:
+                    node_labels.append(node)
+
+        nodes = [obj.getNodeFromLabel(node) for node in node_labels]  
+        nodes = sort_nodes(nodes, sort_nodes_fun=sort_nodes_fun)
+        node_matrix = create_node_matrix(nodes)
+        return node_matrix, element_matrix
+        
+    else: # node region
+        if type(region.nodes) is tuple:
+            nodes = region.nodes[0]
+        else:
+            nodes = region.nodes
+        nodes = sort_nodes(nodes, sort_nodes_fun=sort_nodes_fun)
+        node_matrix = create_node_matrix(nodes)
+
+        return node_matrix
+
+
+def create_list_of_nodes(region, node_labels):
+    return [region.getNodeFromLabel(int(label)) for label in node_labels]
+
+def create_list_of_elements(region, element_labels):
+    return [region.getElementFromLabel(int(label)) for label in element_labels]
+
+def create_node_matrix(nodes):
+    labels = np.hstack([node.label for node in nodes])[:,np.newaxis]
+    coordinates = np.vstack([node.coordinates for node in nodes])
+    node_matrix = np.hstack([labels, coordinates])
+
+    return node_matrix
+
+def get_nodal_phi(step_obj, nodes, field_outputs=['U', 'UR'], flatten_components=True, return_base_disp=False):
+
+    if step_obj.domain != MODAL:   #MODAL is a variable in abaqusConstants
+        raise TypeError('Type of input step is not modal!')
+
+    n_nodes = len(nodes)
+    n_modes = len(step_obj.frames) - 1
+
+    phi = dict()
+    basedisp = dict()
+    n_dofs = dict()
+
+    for iout, field_output in enumerate(field_outputs):
+        foobj0 = step_obj.frames[0].fieldOutputs[field_output]
+        
+        n_dofs[field_output] = len(foobj0.values[0].data)
+        phio = np.zeros([n_dofs[field_output]*n_nodes, n_modes])
+
+        # Get correct data indices to get correct order (as given in node_labels)
+        basedisp[field_output] = np.array([foobj0.getSubset(region=node).values[0].data for node in nodes]).flatten()
+
+        for mode in range(0, n_modes):
+            foobj = step_obj.frames[mode+1].fieldOutputs[field_output]
+            phio[:, mode] = np.array([foobj.getSubset(region=node).values[0].data for node in nodes]).flatten()
+
+        phi[field_output] = phio*1
+    
+    if flatten_components:
+        phi_merged = [None]*n_modes
+        
+        for mode in range(n_modes):
+            phi_merged[mode] = np.hstack([np.array(phi[key][:, mode]).reshape([-1,n_dofs[key]]) for key in field_outputs]).flatten()
+        
+        basedisp = np.hstack([np.array(basedisp[key]).reshape([-1,n_dofs[key]]) for key in field_outputs]).flatten()
+        phi = np.vstack(phi_merged).T
+
+    if return_base_disp:
+        return phi, basedisp
+    else:
+        return phi
+
+
+def get_element_phi(step_obj, elements, field_outputs=['SF', 'SM'], flatten_components=True, return_integration_points=False):
+    if step_obj.domain != MODAL:   #MODAL is a variable in abaqusConstants
+        raise TypeError('Type of input step is not modal!')
+
+    n_modes = len(step_obj.frames) - 1
+    n_dofs = dict()
+    phi = dict()
+    integration_points = dict()
+
+    for iout, field_output in enumerate(field_outputs):
+        foobj0 = step_obj.frames[0].fieldOutputs[field_output]
+        n_dofs[field_output] = len(foobj0.values[0].data)
+
+        # Get correct data indices to get correct order (as given in node_labels)
+        all_integration_points = [value.integrationPoint for value in foobj0.values]
+
+        n_int = len(elements) # number of integration points (same element label might appear multiple times if multiple integration points in element)
+        phio = np.zeros([n_dofs[field_output]*n_int, n_modes])        
+
+        data_indices = [None]*n_int
+        
+        for mode in range(0, n_modes):
+            foobj = step_obj.frames[mode+1].fieldOutputs[field_output]
+            phio[:, mode] = np.array([foobj.getSubset(region=el)[0].data for el in elements]).flatten()
+
+        integration_points[field_output] = [all_integration_points[ix] for ix in data_indices]
+        phi[field_output] = phio*1
+    
+    if flatten_components:
+        phi_merged = [None]*n_modes
+        
+        for mode in range(n_modes):
+            phi_merged[mode] = np.hstack([np.array(phi[key][:, mode]).reshape([-1,n_dofs[key]]) for key in field_outputs]).flatten()
+            
+        integration_points = np.hstack([np.array(integration_points[key]).reshape([-1,n_dofs[key]]) for key in field_outputs]).flatten()
+        phi = np.vstack(phi_merged).T
+
+
+    if return_integration_points:
+        return phi, integration_points
+    else:
+        return phi
+
+    return phi, integration_points
+
+
+def get_modal_parameters(frequency_step):
+    '''
+    Output the modal parameters from frequency step of current output database.
+
+    Parameters
+    -------------
+    frequency_step : str
+        name of step containing the modal results (frequency step)
+
+    Returns
+    --------------
+    f : float
+        numpy array with undamped natural frequencies in Hz of all modes computed
+    m : float
+        numpy array with modal mass for all modes computed
+    '''
+
+    odb = get_db('odb')
+    history_region_key = odb.steps[frequency_step].historyRegions.keys()[0]
+
+    ftemp = odb.steps[frequency_step].historyRegions[history_region_key].historyOutputs['EIGFREQ'].data
+    f = np.array([x[1] for x in ftemp])
+
+    if 'GM' in odb.steps[frequency_step].historyRegions[history_region_key].historyOutputs.keys():
+        mtemp = odb.steps[frequency_step].historyRegions[history_region_key].historyOutputs['GM'].data
+        m = np.array([x[1] for x in mtemp])
+    else:
+        m = np.ones(np.shape(f))    #if no GM field is available, mass normalization is assumed used on eigenvalues
+    return f, m