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

wawi/__init__.py

@@ -1,7 +1,9 @@
-__version__ = "0.0.9"
+'''
+.. include:: ./../README.md
+'''
+__pdoc__ = {'wawi.ext.abq': False}
 
-__pdoc__ = dict()
-__pdoc__['wawi.abq'] = False
+__version__ = "0.0.11"
 
 # Other packages
 import numpy as np

wawi/io.py

@@ -336,7 +336,7 @@ def load_model(model_path, save_if_nonexistent=False, sort_nodes_by_x=True):
 
 def import_wadam_hydro_transfer(wadam_file):
     '''
-    Import WADAM output file.
+    Import WADAM LIS output file.
 
     Parameters
     -----------

wawi/model/_model.py

@@ -673,6 +673,8 @@ class Model:
         return phi_tot
 
     def get_result_psd(self, key='hydro', index=None, convert_to=None, modes=None):
+        # index: applied after transformation to requested csys (convert_to)
+
         ix, ix_3d = self.get_mode_ix(modes)            
 
         if key is not None:    
@@ -1321,4 +1323,16 @@ class Model:
         if opt == 0:
             return frf
         else:
-            return imp
+            return imp
+        
+    def get_node_ix(self, nodelabel):
+        ix = np.where(self.eldef.get_node_labels()==nodelabel)[0]
+        if len(ix)>0:
+            ix = int(ix[0])
+        else:
+            ix = None
+
+        return ix
+    
+    def get_node_ixs(self, nodelabels):
+        return [self.get_node_ix(nodelabel) for nodelabel in nodelabels]

wawi/time_domain.py

@@ -52,6 +52,51 @@ def simulate_mdof(S, omega, fs=None, tmax=None, reg_factor=None, zero_limit=1e-1
                   phase_angles=None, return_phase_angles=False, interpolation_kind='linear', 
                   component_scaling=None, print_status=False):
     
+    '''
+    Simulate time series from given cross-spectral density matrix.
+
+    Parameters
+    ----------------
+    S : float
+        cross-spectral density matrix (Ndofs x Ndofs x Nfreqs) as complex numpy array
+    omega : float
+        numpy array defining frequencies in rad/s
+    fs : float, optional
+        sampling frequency in Hz; if not given, the value is defined as two times the maximum of `omega`
+    tmax : float, optional
+        duration of realization in seconds
+    reg_factor : float, optional
+        to help the Cholesky decomposition to achieve a numerical solution, 
+        a diagonal matrix with the norm of all frequency components of the matrix S scaled by the given factor
+        - if no value is given (--> None imposed), no regularization is conducted; 
+        used as input to function `spectrum_to_process` which decomposes the spectral density 
+    zero_limit : float, optional
+        frequency components where the norm of S is below this limit is set to zero
+        if no value is given (--> None imposed), no zero limit is applied; 
+        used as input to function `spectrum_to_process` which decomposes the spectral density 
+    phase_angles : float, optional
+        if previously conducted simulations are to be recreated, they can by inputting the phase angles
+        (to get the phase angles from simulation, see `return_phase_angles` input parameter)
+    return_phase_angles : bool, default=False
+        whether or not to return phase angle enabling recreation of the simulation
+    interpolation_kind : optional, default='linear'
+        interpolation type used for interpolation (to ensure that we get defined duration and sampling) prior to ifft
+    component_scaling : float, optional
+        values to use for scaling of components prior to decomposition (and thereafter rescale afterwards);
+        can help if some components are much smaller than others; size should match number of DOFs in S
+    print_status : False, optional
+        whether or not to print status messages
+
+    Returns
+    ----------------
+    p : float
+        time history 
+    t : float
+        numpy array with time axis values corresponding to `p`
+    alpha : float
+        phase angles, only returned if `return_phase_angles` is True
+    '''
+    
     if omega[0] !=0:
         omega = np.insert(omega, 0, 0)
         S = np.dstack([0*S[:,:,0], S])

wawi/wind.py

@@ -6,7 +6,7 @@ from scipy.special import jv as besselj, yv as bessely
 from .general import rodrot, blkdiag
 from .plot import plot_ads
 
-conv_text=''' 
+conv_text = r''' 
 -----------------------------------------------------
 |                                                   |
 | ~ ~ ~~~ ~  ~~ ~ /^^^^^^^^^^^^\ 88ooo...  .  .  .  |

{wawi-0.0.9.dist-info → wawi-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: wawi
-Version: 0.0.9
+Version: 0.0.11
 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
@@ -43,6 +43,7 @@ Requires-Dist: trame
 Requires-Dist: ipywidgets
 Requires-Dist: pyvistaqt
 Requires-Dist: beefpy
+Dynamic: license-file
 
 ![WAWI logo](https://raw.githubusercontent.com/knutankv/wawi/main/wawi-logo-animated.svg)
 =======================
@@ -133,6 +134,13 @@ Examples
 =======================
 Examples are provided as Jupyter Notebooks in the [examples folder](https://github.com/knutankv/wawi/tree/main/examples).
 
+The examples are structured in the following folders based on their topic:
+
+* **0 Model generation and setup** - *Describing how a model is defined, either using input files together with the function `wawi.io.import_folder` or using the classes available in the `wawi.model` module directly (in the latter case, the open source Python library BEEF is used to create the required parameters directly in the notebook).*
+* **1 Modal analysis** - *Describing how to set up iterative (and incremental) modal analyses to represent the contributions from aerodynamics and hydrodynamices. Also, an example showing how to set up a multi-modal flutter analysis is given.*
+* **2 Response prediction** - *Describing how to conduct response analyses using WAWI. This includes assigning wind states, sea states, and the necessary commands to run a frequency domain analysis. Furthermore, more advanced topics such as wave-current interaction, inhomogeneous waves and stochastic linearization to represent quadratic drag damping are given in separate examples. Three models are considered: (i) a simple curved floating bridge, (ii) a single beam, (iii) a suspension bridge.*
+* **3 Software interfacing** - *Describing how to export necessary data from other software (limited to Abaqus for now) to construct a WAWI model.*
+
 References
 =======================
 

{wawi-0.0.9.dist-info → wawi-0.0.11.dist-info}/RECORD

@@ -4,25 +4,24 @@ tests/test_IABSE_step11a.py,sha256=guRsaP9gpERvSp0Ui3hO-WH764BcIe6Qx8vC4QVTAoU,8
 tests/test_IABSE_step11c.py,sha256=U_NcL6BAmnQG7MSjkr8KYk9hH8ZPdZgg17pM9ugUBzo,10412
 tests/test_IABSE_step2a.py,sha256=L5AyTOJZ_sPmcmW_4h-sQfRwvVW71LZkXc1yz33DABM,10203
 tests/test_wind.py,sha256=r4rx6f8Tn-u4fn4gGPBMrL_JJQ2SVHGQiQ9sQuMQCPo,1707
-wawi/__init__.py,sha256=nOz20Bt2hcYkKQG7fG0ogBRbLfEZbIgvU1iZjjjHNZ4,158
+wawi/__init__.py,sha256=rH8H6W3AN1iZb8rU9K_8k-mycRSvQNxFq97Biy0-hzw,183
 wawi/fe.py,sha256=22QKI1GlfsG7o_TpFXaKJfzmbO2_2zdIMaoJmaIZdmY,4001
 wawi/general.py,sha256=xHRoDkcchrL6Y7pTUqGsjBHh8YBLvX9dYcNXXCjQap8,13787
 wawi/identification.py,sha256=bVB6EVRR6J39OO9ckuzNJ6f0FwIo4cLqfYgrsIN89TE,1748
-wawi/io.py,sha256=NrziwlebaZUEdu8nWKNXKExHNZZKMzJ0gSHciBTJ4As,25323
+wawi/io.py,sha256=cr8XLF7bwpTCxpZ84YjOyWjc5uuu-JjGv8vY9UKH-HI,25327
 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
 wawi/structural.py,sha256=t25ohH4uBbzUJ7Hqn_kUfYhxcikZkRp8da-9dn7aEbw,8341
-wawi/time_domain.py,sha256=Oe-jviwDtBgpSmA7ZVmKEqQ5tdvsekXwOakYO1qUsN4,3841
+wawi/time_domain.py,sha256=q8-H2xceP-2BmtOfbRQqYhD1JSb0z7jGq-dL_MzAX40,6122
 wawi/tools.py,sha256=-hFBvf0qK4AMn2MQRhrOitDMMMKm2QuRkVfbPBefEkQ,332
 wawi/wave.py,sha256=hhKg3KhKMBhOoCI7g8PFOGUbYgVhDyGmnYdBEdJ8mkY,16064
-wawi/wind.py,sha256=1rUqiEdMaUrhprs87TBdX24l1uDCOINaYkBChMLYWso,38208
+wawi/wind.py,sha256=VHy07IbrCJxlqR0Z5O5WRc9YE4jb-MqFbULPiXhj0NA,38211
 wawi/wind_code.py,sha256=8OKLPpqc84obNNKBoYb2NunKjcn6a3i_pAWpIFEwg4Q,223
 wawi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wawi/ext/abq.py,sha256=Wo-Zzb6b3lr_z7cNKTW-NdYJuVeAwZgwzlGhF_5Jym0,8905
-wawi/ext/abq_legacy.py,sha256=WVhoPjRAru98NxYqpKp9_G8wwfJiLO4X4xFc-CvI0j4,16494
 wawi/ext/ansys.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wawi/ext/orcaflex.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wawi/ext/sofistik.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,10 +29,10 @@ wawi/model/__init__.py,sha256=u6B-dugP76LBkOUVMs0KAoQ81PeRHwFL0M8MbNeAaJA,218
 wawi/model/_aero.py,sha256=tvWMjMoVi9ZVBc3NZ_s-wSofbEk1cc5jf5s-Swv2RxQ,9337
 wawi/model/_dry.py,sha256=KpmFlSinoY6DrSyc3Y0M8w1-cCC7VCFep-uzcqZsHz4,3940
 wawi/model/_hydro.py,sha256=1tUj19OgvEjItNtBxXuPHf0zWtKv_ioTrOcgl9Ov3dg,26960
-wawi/model/_model.py,sha256=qmQRASu3E3iRqxzAeT3wUxonuADbCxreXiERR9KHwb0,52090
+wawi/model/_model.py,sha256=34qblCqGpIKwbsa38CJ3a8KbHYyX8LDWOFQhdRwK98Q,52504
 wawi/model/_screening.py,sha256=NRYkKq928z2lqMSUTpbQLls04td_9R_4dhkjU3Gv1oQ,3716
-wawi-0.0.9.dist-info/LICENSE,sha256=bH1aWhrNbbPLrYnVFRaoYYzcUr-figHjry-kGB7Tc54,1076
-wawi-0.0.9.dist-info/METADATA,sha256=zoyYWdj03UGEOq7jt7XqUgd0XdV-KmEzI99lBmNJ6cE,5197
-wawi-0.0.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-wawi-0.0.9.dist-info/top_level.txt,sha256=Nk5G_ZwgZRCb9ZMWZdr1M3QIskX6kCnlqeMl67N3zg8,20
-wawi-0.0.9.dist-info/RECORD,,
+wawi-0.0.11.dist-info/licenses/LICENSE,sha256=bH1aWhrNbbPLrYnVFRaoYYzcUr-figHjry-kGB7Tc54,1076
+wawi-0.0.11.dist-info/METADATA,sha256=TPaFfAkztMCRaw4F8U5JT6XqOK2IjY3orqmBmguLoaY,6530
+wawi-0.0.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+wawi-0.0.11.dist-info/top_level.txt,sha256=Nk5G_ZwgZRCb9ZMWZdr1M3QIskX6kCnlqeMl67N3zg8,20
+wawi-0.0.11.dist-info/RECORD,,

{wawi-0.0.9.dist-info → wawi-0.0.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

wawi/ext/abq_legacy.py

@@ -1,462 +0,0 @@
-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
-
-import numpy as np
-import os
-
-from wawi.general import merge_tr_phi
-
-
-def export_wawi(odb_path, path):
-    pass
-
-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
-
-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 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 modeshapes_from_region(regionobjs, frequency_step, field_outputs):
-    """
-    Get modes (shape, frequency and modal mass) from "Frequency step" (eigenvalue analysis) in active Abaqus ODB.
-
-    """
-    odb = get_db('odb')
-
-    if odb.steps[frequency_step].domain != MODAL:   #MODAL is a variable in abaqusConstants
-        raise TypeError('Type of input step is not modal!')
-
-    Nmodes = len(odb.steps[frequency_step].frames)-1
-    phi = [None]*len(field_outputs)
-
-    for iout, field_output in enumerate(field_outputs):
-        Ndofs, point_ranges, dof_ranges = count_region(regionobjs, field_output, odb.steps[frequency_step].frames[0])
-        phio = np.zeros([np.sum(Ndofs), Nmodes])
-        foobj0 = odb.steps[frequency_step].frames[0].fieldOutputs[field_output]
-
-        for ix, regionobj in enumerate(regionobjs):
-            current_dof_range = np.arange(dof_ranges[ix], dof_ranges[ix+1])
-
-            for mode in range(0, Nmodes):
-                foobj = odb.steps[frequency_step].frames[mode+1].fieldOutputs[field_output]
-                phio[:, mode] = np.reshape((np.array([v.data for v in foobj.getSubset(region=regionobj).values])), [np.sum(Ndofs)])
-
-        phi[iout] = phio
-
-    return phi
-
-def str2region(instance_name, setnames, region_type, db_type, *args):
-    """
-    Construct a region object from a string defining the set name or a region object.
-
-    Args:
-        instance_name: string defining the set name (either node or element set) or a region object
-        setnames: name of set asked for
-        region_type: type of set ('elements' or 'nodes')
-        db_type: 'odb' or 'model'
-    Optional args:
-        db: database object, either mdb.model[...] or session.openOdb(...) - will get from viewport 1 if not given
-    Returns:
-        regionobjs: region objects
-
-    """
-
-    is_assembly = instance_name is None
-
-    set_type = settype(region_type, db_type)
-    standard_sets = {'nodes': [' ALL NODES'], 'elements': [' ALL ELEMENTS']}
-
-    if setnames is None:
-        setnames = standard_sets[region_type]
-
-    if len(args)==1:    # a db has been input
-        db = args[0]
-        isodb = hasattr(db,'jobData')   #check if the input db is reffering to result/odb or model
-
-    else:
-        db = get_db(db_type)
-
-    if db is None:
-        raise TypeError('The database is empty. Please input a database object, or input parameters that matches one. Remember that odbs have to be active to get the db automatically!')
-
-    if is_assembly:       # Instance name is given
-        regroot = db.rootAssembly
-    else:
-        regroot = db.rootAssembly.instances[instance_name]
-
-    regionobjs = [None] * np.size(setnames)
-
-    for ix,thisname in enumerate(setnames):
-        regionobjs[ix] = getattr(regroot, set_type)[thisname]
-
-    return regionobjs
-
-
-def settype(region_type, db_type):
-    """
-    Define the string used to get set based on region type and database type.
-
-    Args:
-        region_type: 'element' or 'node'
-        db_type: 'odb' or 'mdb'
-    Returns:
-        set_string: string used to obtain set data from database object (odb or mdb)
-
-    """
-    if db_type is 'odb':
-        if 'element' in region_type.lower():
-            set_string = 'elementSets'
-        elif 'node' in region_type.lower():
-            set_string = 'nodeSets'
-        else:
-            raise TypeError('Wrong input!')
-    elif db_type == 'mdb' or db_type == 'model':
-        set_string = 'sets'
-
-    return set_string
-
-def count_region(regionobjs, field_output, frame):
-    """
-    Count the number of DOFs and points in the specified region objects for given field output and frame object.
-
-    Args:
-        regionobjs: list of region objects to query
-        field_output: string specifying field output
-        frame: frame object (from where fieldOutputs field is accessible)
-    Returns:
-        Ndofs: number of DOFs for each region (list)
-        point_ranges: point/node ranges for each region (list of lists)
-        dof_ranges: dof ranges for each region (list of lists)
-    """   
-    odb = get_db('odb')
-
-    Npoints = [len(frame.fieldOutputs[field_output].getSubset(region=regionobj).values) for regionobj in regionobjs]
-    Ndofs = np.dot(Npoints, len(frame.fieldOutputs[field_output].componentLabels))
-
-    dof_ranges = np.cumsum(np.append([0], Ndofs))
-    point_ranges = np.cumsum(np.append([0], Npoints))
-
-    return Ndofs, point_ranges, dof_ranges
-
-
-def wind_set_data(set_strings, frequency_step, instance, db_type, field_outputs, mode_type='nodes', use_node_region_acronym=False):
-    # use_node_region_acronym: if True, a node set with identical name as the element set given in set_strings is picked and the nodes assumed to correspond to the element. If not the case, the element set is used to establish the nodes (and thus phi)
-    wind_element_regions = str2region(instance, set_strings, 'elements', db_type)  # index 0 is girder, index 1 is columns
-
-    if use_node_region_acronym:
-        wind_node_regions = str2region(instance, set_strings, 'nodes', db_type)
-
-    element_labels = [None]*len(set_strings)
-    element_node_indices = [None]*len(set_strings)
-    node_labels = [None]*len(set_strings)
-    node_coordinates = [None]*len(set_strings)
-    phi_ae = [None]*len(set_strings)
-
-    for set_ix, set_string in enumerate(set_strings):
-        element_labels[set_ix], element_node_indices[set_ix], nl, nc = region2elnodes_legacy(wind_element_regions[set_ix])
-        if use_node_region_acronym:
-            nl, nc = region2nodes(wind_node_regions[set_ix]) 
-            
-        node_labels[set_ix] = nl
-        node_coordinates[set_ix] = nc
-
-    # Establish modal transformation matrix, phi
-    if mode_type=='nodes':
-        for set_ix, set_string in enumerate(set_strings):
-            phi_ae_temp = modeshapes_from_nodelist(node_labels[set_ix], frequency_step, field_outputs)
-            phi_ae[set_ix] = merge_tr_phi(phi_ae_temp[0][0], phi_ae_temp[0][1])
-    elif mode_type=='elements':
-        for set_ix, set_string in enumerate(set_strings):
-            phi_ae_temp, integration_points = modeshapes_from_elementlist(element_labels[set_ix], frequency_step, field_outputs)
-            phi_ae[set_ix] = merge_tr_phi(phi_ae_temp[0], phi_ae_temp[1])   
-
-    return element_labels, element_node_indices, node_labels, node_coordinates, phi_ae
-
-
-def region2elnodes_legacy(regionobjs, avoid_central_nodes=True):
-    """
-    Give node labels (indices) for each node in specified element set.
-
-    Args:
-        regionobjs: region objects to query for node labels
-
-    Returns:
-        element_labels: the labels (indices) of the elements in list
-        element_node_indices: the labels (indices) of the ndoes in each element; list of lists
-        node_labels: all the nodes labels (indices) in a flattened list
-        node_coordinates: node coordinates for each element (list of lists)
-
-    """
-
-    objstr = regionobjs.__repr__()
-    instance_name = objstr.split(".instances['")[1].split("'].")[0]
-
-    if '.odb' in objstr:
-        db = get_db('odb')
-        dbtype = 'odb'
-    else:
-        db = get_db('mdb')
-        dbtype = 'mdb'
-
-    # Get the elements object root
-    if len(np.shape(regionobjs.elements))>1:
-        elements = regionobjs.elements[0]
-    else:
-        elements = regionobjs.elements
-
-    # Get all element labels and corresponding connectivity (node labels)
-    element_labels = np.array([element.label for element in elements])
-
-    # Instance object
-    instance = db.rootAssembly.instances[instance_name]
-
-    # Full arrays labels and coordinates
-    all_node_labels = np.array([node.label for node in instance.nodes]).flatten([-1])
-    all_node_coords = np.array([node.coordinates for node in instance.nodes])
-
-    # Nodes belonging to all the elements
-    if dbtype is 'odb':
-        element_node_labels = [element.connectivity for element in elements]
-    else:
-        element_node_labels = [[all_node_labels[ix] for ix in element.connectivity] for element in elements]
-    
-    if avoid_central_nodes:
-        element_node_labels = [[node_lb[0], node_lb[-1]] for node_lb in element_node_labels]
-
-    node_labels = np.unique(np.array(element_node_labels).flatten())
-
-    nodeixs = np.array([np.where(all_node_labels==node)[0] for node in node_labels]).flatten()
-    node_coordinates = all_node_coords[nodeixs, :]
-    element_node_indices = np.array([np.array([np.where(node_labels==node_label) for node_label in node_labels_for_element]).flatten() for node_labels_for_element in element_node_labels])
-
-    return element_labels, element_node_indices, node_labels, node_coordinates
-
-
-def region2nodes(regionobj, sortfun=None):
-    """
-    Give node labels (indices) of nodes in specified node set(s).
-
-    Args:
-        regionobj: region object to query for node labels
-
-    Optional args:
-        sortfun: function with three inputs (1: x, 2: y, 3:z) to sort nodes by
-                 examples: sortfun = lambda x, y, z: -np.arctan2(y,x)
-                           sortfun = lambda x, y, z: x
-
-    Returns:
-        node_labels: list with nodelabels
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-
-    set_name = regionobj.__repr__().split("ets[")[1].split("'")[1]
-
-    if len(np.shape(regionobj.nodes))>1:
-        nodes = regionobj.nodes[0]
-    else:
-        nodes = regionobj.nodes
-
-    node_labels = np.array([node.label for node in nodes])
-    node_coordinates = np.array([node.coordinates for node in nodes])
-
-    if sortfun != None:
-        vals = sortfun(x=node_coordinates[:,0], y=node_coordinates[:,1], z=node_coordinates[:,2])
-        sort_ix = np.argsort(vals)
-        node_labels = node_labels[:, sort_ix]
-        node_coordinates = node_coordinates[sort_ix, :]
-
-    return node_labels, node_coordinates
-
-def modeshapes_from_nodelist(node_labels, frequency_step, field_outputs):
-    """
-    Get mode shapes from "Frequency step" (eigenvalue analysis) in active Abaqus ODB.
-
-    Args:
-        node_labels:
-        frequency_step:
-        field_outputs:
-    Returns:
-        phi: mode shape transformation matrix, ordered as NumPy matrices in list for each specified outputs
-
-    """
-    odb = get_db('odb')
-
-    if odb.steps[frequency_step].domain != MODAL:   #MODAL is a variable in abaqusConstants
-        raise TypeError('Type of input step is not modal!')
-
-    Nnodes = len(node_labels)
-    Nmodes = len(odb.steps[frequency_step].frames) - 1
-    phi = [None]*len(field_outputs)
-    basedisp = [None]*len(field_outputs)
-
-    for iout, field_output in enumerate(field_outputs):
-        foobj0 = odb.steps[frequency_step].frames[0].fieldOutputs[field_output]
-        
-        Ndofs = len(foobj0.values[0].data)
-        phio = np.zeros([Ndofs*Nnodes, Nmodes])
-
-        # Get correct data indices to get correct order (as given in node_labels)
-        all_nodes = [value.nodeLabel for value in foobj0.values]
-        data_indices = [None]*Nnodes
-
-        for ix, node in enumerate(node_labels):
-            data_indices[ix] = all_nodes.index(node)
-
-        basedisp[iout] = np.array([foobj0.values[data_ix].data for data_ix in data_indices]).flatten()
-
-        for mode in range(0, Nmodes):
-            foobj = odb.steps[frequency_step].frames[mode+1].fieldOutputs[field_output]
-            phio[:, mode] = np.array([foobj.values[data_ix].data for data_ix in data_indices]).flatten()
-
-        phi[iout] = phio
-
-    return phi, basedisp
-
-
-def modeshapes_from_elementlist(element_labels, frequency_step, field_outputs):
-    """
-    Get mode shape from "Frequency step" (eigenvalue analysis) in active Abaqus ODB.
-
-    Args:
-        node_labels:
-        frequency_step:
-        field_outputs:
-    Returns:
-        phi: mode shape transformation matrix, ordered as NumPy matrices in list for each specified outputs
-
-    """
-    odb = get_db('odb')
-
-    if odb.steps[frequency_step].domain != MODAL:   #MODAL is a variable in abaqusConstants
-        raise TypeError('Type of input step is not modal!')
-
-    
-    Nmodes = len(odb.steps[frequency_step].frames) - 1
-    phi = [None]*len(field_outputs)
-    integration_points = [None]*len(field_outputs)
-
-    for iout, field_output in enumerate(field_outputs):
-        foobj0 = odb.steps[frequency_step].frames[0].fieldOutputs[field_output]
-        Ndofs = len(foobj0.values[0].data)
-
-        # Get correct data indices to get correct order (as given in node_labels)
-        all_elements = [value.elementLabel for value in foobj0.values]
-        all_integration_points = [value.integrationPoint for value in foobj0.values]
-
-        Nintpoints = len(element_labels) # number of integration points (same element label might appear multiple times if multiple integration points in element)
-        phio = np.zeros([Ndofs*Nintpoints, Nmodes])        
-
-        data_indices = [None]*Nintpoints
-
-        for ix, element in enumerate(element_labels):
-            data_indices[ix] = all_elements.index(element)
-        
-        for mode in range(0, Nmodes):
-            foobj = odb.steps[frequency_step].frames[mode+1].fieldOutputs[field_output]
-            phio[:, mode] = np.array([foobj.values[data_ix].data for data_ix in data_indices]).flatten()
-
-        integration_points[iout] = [all_integration_points[ix] for ix in data_indices]
-        phi[iout] = phio
-        
-
-    return phi, integration_points