wawi 0.0.3__py3-none-any.whl → 0.0.7__py3-none-any.whl

wawi/abq.py

@@ -1,1128 +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 csv
-from copy import deepcopy
-
-import numpy as np
-import os
-
-from .general import merge_tr_phi
-
-'''
-Abaqus interaction module
-'''
-
-## Functions to retrieve data from ODB
-
-def modalparameters(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 modeshapes_from_region(regionobjs, frequency_step, field_outputs):
-    """
-    Get modes (shape, frequency and modal mass) from "Frequency step" (eigenvalue analysis) in active Abaqus ODB.
-
-    Args:
-        regionobjs: Abaqus region objects in list
-        frequency_step: name of frequency step
-        field_outputs: list of strings with field output quantities, e.g., ['U', 'UR']
-    Returns:
-        phi: mode shape transformation matrix, ordered as NumPy matrices in list for each specified outputs
-        f: undamped natural frequencies
-        m: modal mass
-        output_dict: dictionary to access correct index in output phi
-
-    AAJ / Knut Andreas Kvaale, 2017
-    Further developed NTNU / Knut Andreas Kvaale, 2018
-    """
-    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 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
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-    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
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-    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
-
-
-def modeshapes_from_set_xydata(field_output, components, output_position, instance_name, set_name, region_type):
-    """
-    Get mode shapes from "Frequency step" (eigenvalue analysis) in active Abaqus ODB from specified sets.
-
-    Args: NOT FINISHED
-        field_output:
-        components:
-        data_position:
-        output_position:
-        set_name:
-        region_type:
-    Returns:
-        phi: mode shape transformation matrix (Numpy array)
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-
-    set_names = [(instance_name + '.' +set_name)]
-
-    odb = get_db('odb')
-    n_components = len(components)
-    xy_data = [None]*n_components
-
-    if region_type == 'element':
-        data_position = INTEGRATION_POINT
-    elif region_type == 'node':
-        data_position = NODAL
-
-    if output_position == 'element':
-        output_position = ELEMENT_NODAL
-
-    for ix, component in enumerate(components):
-        refinement = [[COMPONENT, component]]
-        variable = [[field_output, data_position, refinement]]
-        
-        if region_type == 'element':
-            xy_data[ix] = session.xyDataListFromField(odb=odb, outputPosition=output_position, variable=variable, elementSets=set_names) 
-        else:
-            xy_data[ix] = session.xyDataListFromField(odb=odb, outputPosition=output_position, variable=variable, nodeSets=set_names)
-
-    n_elements = len(xy_data[0])
-    n_modes = len(xy_data[0][0])
-
-    phi = np.zeros([n_components*n_elements, n_modes])
-    for compix, component in enumerate(xy_data):
-        for elix, element in enumerate(component):
-            for mode in range(0, n_modes):
-                phi[elix*n_components + compix, mode] = element[mode][1]
-
-
-    return phi, xy_data
-
-## MODIFY ODB OR MDB
-def set_view_variable(var, component):
-    """
-    Set a new view variable and component in current odb session.
-    
-    Args:
-        var: variable name
-        component: component to display
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """   
-    position = {NODAL}
-    session.viewports['Viewport: 1'].odbDisplay.setPrimaryVariable(variableLabel=var, outputPosition=NODAL, refinement=(COMPONENT, component),)
-
-
-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
-
-
-
-## MODIFY ODB
-def unlock_odb():
-    """
-    Unlock current ODB file.
-
-    Returns:
-        odb: database (odb) object
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """   
-    odb = session.viewports[session.currentViewportName].displayedObject
-
-    if odb.isReadOnly:
-        load_path = odb.path
-        odb.close()
-        odb = odbAccess.openOdb(load_path, readOnly=False)
-        session.viewports['Viewport: 1'].setValues(displayedObject=session.odbs[load_path])
-
-    return odb
-
-
-def copy_and_unlock_odb():
-    """
-    Copy and unlock current ODB file.
-
-    Returns:
-        odb: database (odb) object
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """   
-    odb = session.viewports[session.currentViewportName].displayedObject
-    old_file_path = odb.path
-    new_file_path = odb.path.split('.odb')[0]+'_org.odb'
-
-    shutil.copyfile(old_file_path, new_file_path)   #copy the old file
-
-    odb.close()
-    odb = odbAccess.openOdb(old_file_path, readOnly=False)
-    session.viewports['Viewport: 1'].setValues(displayedObject=session.odbs[old_file_path])
-
-    return odb
-
-
-def session_is_odb():
-    """
-    Check if current session is ODB.
-
-    Returns:
-        is_odb: boolean indicating if the session is odb or not
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """    
-    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 save_and_reopen_odb():
-    """
-    Save and reopen database (odb) as read-only.
-
-    Returns:
-        odb: odb object
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-    odb = get_db('odb')
-    odb.save()
-    load_path = odb.path
-    odb.close()
-
-    odb = odbAccess.openOdb(load_path, readOnly=True)
-
-    return odb
-
-
-def add_response_step_from_modal(phi_response, field_outputs, modal_var, frequency_step, step_name, region_strings, region_type, instance_name, description):
-    """
-    Add an artificial step in Abaqus ODB for response data.
-
-    Args:
-        phi_response: phi of the requested response quantities (list with one matrix for each response quantities)
-        field_outputs: names of field output variables
-        modal_var: covariance matrix for the generalized (modal) DOFs
-        frequency_step: name of the new artificial step_name
-        step_name: node set name or region object that define what nodes / DOFs phi refers to
-        regionobjs: Abaqus region objects in list
-        instance_name: name of the instance
-        description: frame description
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-
-    odb = copy_and_unlock_odb()
-    regionobjs = str2region(instance_name, region_strings, region_type, 'odb')
-    instance = odb.rootAssembly.instances[instance_name]
-
-    step_data = odb.Step(name=step_name, description='Response step', domain=TIME, timePeriod=0)
-    frame = step_data.Frame(incrementNumber=0, description='Response', frameValue=0)
-
-    type_dict = {'SF': [TENSOR_3D_SURFACE, INTEGRATION_POINT, 'Section forces'], 'SM': [TENSOR_3D_SURFACE, INTEGRATION_POINT, 'Section moments'], 'U': [VECTOR, NODAL, 'Spatial displacement'], 'UR': [VECTOR, NODAL, 'Rotational displacement'] }
-
-    for ix, field_output in enumerate(field_outputs):
-        foobj_ref = odb.steps[frequency_step].frames[0].fieldOutputs[field_output]
-        phi = phi_response[ix]
-        region_type = type_dict[field_output][1]
-        comps = len(odb.steps[frequency_step].frames[0].fieldOutputs[field_output].componentLabels)
-
-        sigma = np.sqrt(np.sum((np.dot(phi, modal_var) * phi), axis=1))   # Calculate sigma (square root of covariance matrix) from modal coordinates
-        sigma_comp = np.reshape(sigma, [-1, 3]).astype('float')
-        data = [list(this) for this in sigma_comp]
-
-        foobj = frame.FieldOutput(name=field_output, description=type_dict[field_output][2], type=type_dict[field_output][0], validInvariants=())
-
-        N = len(odb.steps[frequency_step].frames[0].fieldOutputs[field_output].values)
-        Ndofs, point_ranges, dof_ranges = count_region(regionobjs, field_output, odb.steps[frequency_step].frames[0])
-
-        for regix,regionobj in enumerate(regionobjs):
-            good_ix, good_entries = good_element_ix(foobj_ref, regionobj)
-            point_range = range(point_ranges[regix],point_ranges[regix+1])
-
-            foobj.addData(position=region_type, instance=instance, labels=good_entries, data=data)
-
-        step_data.setDefaultField(foobj)
-
-    odb = save_and_reopen_odb()
-
-    return odb
-
-
-def add_std_to_frame(odb, frame, instance_name, modal_var, phi, regionobj, field_output, reference_step):
-    '''
-    Under development. Not verified.
-    '''
-    if odb.isReadOnly:
-        raise TypeError('ODB is read only. Unable to add data.')
-
-    type_dict = {'SF': [TENSOR_3D_SURFACE, INTEGRATION_POINT, 'Section forces'], 'SM': [TENSOR_3D_SURFACE, INTEGRATION_POINT, 'Section moments'], 'U': [VECTOR, NODAL, 'Spatial displacement'], 'UR': [VECTOR, NODAL, 'Rotational displacement'] }
-    foobj_ref = odb.steps[reference_step].frames[0].fieldOutputs[field_output]
-
-    region_type = type_dict[field_output][1]
-    comps = len(odb.steps[reference_step].frames[0].fieldOutputs[field_output].componentLabels)
-
-    sigma = np.sqrt(np.sum((np.dot(phi, modal_var) * phi), axis=1))   # Calculate sigma (square root of covariance matrix) from modal coordinates
-    sigma_comp = np.reshape(sigma, [-1, comps]).astype('float')
-    data = [list(this) for this in sigma_comp]
-
-    # If already exists, don't create new, but assign to that.
-    if field_output not in frame.fieldOutputs.keys():
-        foobj = frame.FieldOutput(name=field_output, description=type_dict[field_output][2], type=type_dict[field_output][0], validInvariants=())
-    else:
-        foobj = frame.fieldOutputs[field_output]
-
-    N = len(odb.steps[reference_step].frames[0].fieldOutputs[field_output].values)
-    good_ix, good_entries = good_element_ix(foobj_ref, regionobj)
-    instance = odb.rootAssembly.instances[instance_name]
-
-    foobj.addData(position=region_type, instance=instance, labels=good_entries, data=data)
-    step_data.setDefaultField(foobj)
-
-
-
-def add_complex_mode_step(phi, eigvals, instance_name, step_name, region):
-    """
-    Add an artificial step in Abaqus ODB for complex modes.
-
-    Args:
-        phi: complex eigenvector matrix
-        eigvals: complex eigenvalues
-        instance_name: name of the instance
-        step_name: name of the new artificial step_name
-        regionobj: Abaqus region object
-
-    Knut Andreas Kvaale, 2018
-    """
-
-    odb = unlock_odb()
-    complex_step = odb.Step(name=step_name, description='Complex modes', domain=MODAL)
-    frame0 = complex_step.Frame(incrementNumber=0, description='Base state', frameValue=0)
-    frame_data = frame0.FieldOutput(name='U', description='Spatial displacement', type=VECTOR, validInvariants=(MAGNITUDE,))
-    instance = odb.rootAssembly.instances[instance_name]
-
-    for m, lambdam in enumerate(eigvals):
-        phim = np.reshape(phi[:, m], (-1, 3)).astype('float')
-        xim = -np.real(lambdam)/abs(lambdam)
-
-        freqm_ud_rad = abs(lambdam)
-        freqm_d_rad = abs(np.imag(lambdam))
-        freqm_ud_Hz = freqm_ud_rad/(2*np.pi)
-
-        periodm_ud = 2*np.pi/abs(lambdam)
-
-        description_m = 'Mode ' + str(m+1) + ':  f = ' + str(freqm_ud_Hz) + 'Hz  |  om = ' + str(freqm_ud_rad) + 'rad/s   |   T = ' + str(periodm_ud) + 's  |  xi = ' + str(xim*100) + '%'
-
-        frame_m = complex_step.Frame(incrementNumber=m+1, description=description_m, frameValue=freqm_ud_Hz)
-        frame_data = frame_m.FieldOutput(name='U', description='Spatial displacement', type=VECTOR, validInvariants=(MAGNITUDE,))
-        nodelabels = np.array([node.label for node in regionobj.nodes[0]]).astype('int')
-
-        frame_data.addData(position=NODAL, instance=instance, labels=nodelabels, data=np.real(phim), conjugateData=np.imag(phim))
-
-    odb.save()
-    load_path = odb.path
-    odb.close()
-    odb = odbAccess.openOdb(load_path, readOnly=True)
-
-## MODIFY MDB
-def mass_and_stiffness_input(stiffness,mass,pontoon_set_names,pont_nodes,trans_mats,filename):
-    pontoons = len(pontoon_set_names)
-    if len(pont_nodes) != pontoons or len(trans_mats)!=pontoons:
-        raise ValueError('Mismatch between dimensions for input variables: pontoon_set_names, pont_nodes and trans_mats')
-    f = open(filename, 'w')
-
-    for pontoon in range(0,pontoons):
-        f.write('********************************PONTOON NUMBER {0} ************************************* \n'.format(str(pontoon+1)))
-        f.write('*USER ELEMENT, LINEAR, NODES=1, UNSYM, TYPE=U{0}00 \n'.format(str(pontoon+1))) 	# Defines a linear user element
-        f.write('1, 2, 3, 4, 5, 6 \n')                                               # The element has one node with 6 DOFS
-
-        T = trans_mats[pontoon]
-
-        K = np.dot(np.dot(T.transpose(), stiffness),T)
-        M = np.dot(np.dot(T.transpose(), mass),T)
-
-        f.write('*MATRIX, TYPE=MASS \n')                                            # Defines the mass matrix in GLOBAL coordinate system
-        for n in range(0,6):
-            string1 = ','.join(map(str, M[n, 0:4]))
-            string2 = ','.join(map(str, M[n, 4:6])) 
-            f.write(string1 + '\n' + string2 +'\n')
-            
-        f.write('*MATRIX, TYPE=STIFFNESS \n')
-        for n in range(0,6):
-            string1 = ','.join(map(str, K[n, 0:4]))
-            string2 = ','.join(map(str, K[n, 4:6]))
-            f.write(string1 + '\n' + string2 +'\n')
-
-        f.write('*ELEMENT, TYPE=U{0}00, ELSET={1} \n'.format(str(pontoon+1),pontoon_set_names[pontoon])) 				#Introduce one user element into the FE model
-        f.write('800{0}, {1} \n'.format(str(pontoon+1),pont_nodes[pontoon]))     					#Numbering elements as 8001,8002,...,8007, followed by first node number forming the element
-        f.write('*UEL PROPERTY, ELSET={0} \n'.format(pontoon_set_names[pontoon]))
-
-
-def update_input(freq,wadam_file,input_file,pontoon_set_names,pont_nodes,trans_mats):
-    from .io import import_wadam_mat
-    static_mass, stiffness, added_mass, damping, frequency = import_wadam_mat(wadam_file)
-    mass = freq_sysmat(added_mass,frequency,freq)+static_mass
-    mass_and_stiffness_input(stiffness,mass,pontoon_set_names,pont_nodes,trans_mats,input_file)
-    print('Input file '+ input_file + ' is modified to correspond to added mass at f = ' + str(freq) + ' Hz.')
-
-
-def imperfection_input(node_labels, displacement_vector, input_file=None, rotations=False):
-    
-    d = np.array(displacement_vector)
-
-    if rotations is True:
-        n_nodes = len(d)/6
-        d_trans = np.zeros([n_nodes*3])
-        for node in range(0, n_nodes):
-            d_trans[node*3:node*3+3] = d[node*6:node*6+3]
-
-        d = d_trans
-    else: 
-        n_nodes = len(d)/3
-
-    mat = np.hstack([np.array(node_labels)[:, np.newaxis], d.reshape(-1, 3)])
-
-    if input_file != None:
-        open(input_file, 'w').close()
-
-        with open(input_file, 'a') as f:
-            f.write('*IMPERFECTION \n')
-            np.savetxt(f, mat, delimiter=',', fmt='%i,%.8e,%.8e,%.8e')
-
-    return mat
-
-
-def add_input_file(model, input_file_path, pos, target_string=None, relative_pos=0):
-
-    if target_string != None:
-        pos = model.keywordBlock.sieBlocks.index(target_string)
-
-    model.keywordBlock.insert(pos+relative_pos, '*INCLUDE, INPUT={0}'.format(input_file_path))
-
-
-def add_springs(assem, Kh, region, name):
-    
-    ON = symbolicConstants.AbaqusBoolean(1)
-
-    Kpos = (Kh+abs(Kh))/2
-    Krem = (Kh-abs(Kh))/2
-
-    for dof in range(2, 5):
-        if Kpos[dof, dof] != 0:
-            assem.engineeringFeatures.SpringDashpotToGround(name=name+'_K%i%i' % (dof+1, dof+1), region=region, orientation=None, dof=dof+1, springBehavior=ON, springStiffness=Kpos[dof, dof])
-
-    return Krem
-
-
-def add_inertia(assem, M0, region, name, specify_rot=False):
-    if specify_rot is True:
-        assem.engineeringFeatures.PointMassInertia(alpha=0.0, composite=0.0, i11=M0[3, 3], i12=M0[3, 4], i13=M0[3, 5], i22=M0[4, 4], i23=M0[4, 5],
-                                                   i33=M0[5, 5], mass1=M0[0, 0], mass2=M0[1, 1], mass3=M0[2, 2], name=name+'_M0', region=region)
-        comps = range(0, 6)
-    elif specify_rot is False:
-        assem.engineeringFeatures.PointMassInertia(alpha=0.0, composite=0.0, mass1=M0[0, 0], mass2=M0[1, 1], mass3=M0[2, 2], name=name+'_M0', region=region)
-        comps = range(0, 3)
-
-    Mrem = deepcopy(M0)
-
-    for comp in comps:
-        Mrem[comp, comp] = 0
-
-    return Mrem
-
-
-#%% USEFUL FUNCTIONS FOR DEALING WITH REGIONS IN DATABASE
-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)
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """   
-    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 good_element_ix(foobj, regionobj):
-    """
-    Get the indices of the good (??) elements.
-
-    Args:
-        foobj: field object
-        regionobj: region object
-    Returns:
-        good_ix: ?
-        good_entries: ?
-                
-    NTNU / Knut Andreas Kvaale, 2018
-    """   
-    foobj_values = foobj.getSubset(region=regionobj).values
-    region_type = obtain_region_types([regionobj])[0]
-
-    if region_type is 'elements':
-        rootobj = regionobj.elements
-        label_string = 'elementLabel'
-    elif region_type is 'nodes':
-        rootobj = regionobj.nodes
-        label_string = 'nodeLabel'
-
-    if type(rootobj) is tuple:
-        rootobj = rootobj[0]
-
-    good_entries = [getattr(val, label_string) for val in foobj_values]
-    all_entries = [obj.label for obj in rootobj]
-
-    good_ix = [all_entries.index(this_entry) for this_entry in good_entries]
-
-    return good_ix, good_entries
-
-
-def obtain_region_types(regionobjs):
-    """
-    Get the region types of list of region objects.
-
-    Args:
-        regionobjs: list of region objects
-    Returns:
-        region_type: list of region types
-                
-    NTNU / Knut Andreas Kvaale, 2018
-    """   
-    elementsets = [regionobj.nodes is None for regionobj in regionobjs]    # true if regionobjects are element sets
-    settypedict = {False: 'nodes', True: 'elements'}
-    region_type = [settypedict[elementset] for elementset in elementsets]
-
-    return region_type
-
-
-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
-
-    AAJ / Knut Andreas Kvaale, 2017
-    Further developed NTNU / Knut Andreas Kvaale, 2018
-    """
-
-    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 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 region2elnodes(regionobj, avoid_central_nodes=True, db_type='odb'):
-    """
-    Give node labels (indices) for each node in specified element set.
-
-    Args:
-        regionobj: region object to query for 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)
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-    
-    db = get_db(db_type)
-    objstr = regionobj.__repr__()
-    if 'instances' in objstr:
-        instance_name = objstr.split(".instances['")[1].split("'].")[0]
-    else:
-        instance_name = None
-
-    if instance_name is None:
-        instance = db.rootAssembly
-    else:
-        instance = db.rootAssembly.instances[instance_name]
-
-    # Get the elements object root
-    if len(np.shape(regionobj.elements))>1:
-        elements = regionobj.elements[0]
-    else:
-        elements = regionobj.elements
-
-    # Get all element labels and corresponding connectivity (node labels)
-    element_labels = np.array([element.label for element in elements])
-    node_labels = [el.connectivity for el in elements]
-
-    if avoid_central_nodes:
-        node_labels = np.unique([item for sublist in node_labels for item in sublist[:1]+sublist[-1:]])
-    else:
-        node_labels = [item for sublist in node_labels for item in sublist]
-
-    element_matrix = None
-    
-    return element_labels, node_labels, element_matrix
-
-
-def get_element_matrix(element_labels=None):    #if None is specified, full model is exported
-    pass
-
-def get_node_matrix(node_labels=None):    #if None is specified, full model is exported
-    pass
-
-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)
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-
-    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
-
-
-#%% RETRIEVE THINGS FROM DATABASE
-def element_orientations(element_labels, instance_name):
-    """
-    Provide transformation matrices describing the three unit vectors of the local CSYS of all elements in element_labels.
-
-    Args:
-        element_labels: element labels to query
-        instance_name: name of instance to find beam orientations
-
-    Returns:
-        element_orientations: array of numpy 2d-arrays with transformation matrices of all elements in element_labels
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-    db_type = 'odb' # may consider mdb option later
-    db = get_db(db_type)
-    
-    all_elements = db.rootAssembly.elementSets[' ALL ELEMENTS'].elements[0]
-    all_nodes = db.rootAssembly.nodeSets[' ALL NODES'].nodes[0]
-    all_element_labels = [value.label for value in all_elements]   
-    all_node_labels = [value.label for value in all_nodes]   
-    element_orientations = [None]*len(element_labels)
-     
-    beam_orientations = db.rootAssembly.instances[instance_name].beamOrientations
-
-    for beam_orientation in beam_orientations:
-        bo_elements = [value.label for value in beam_orientation.region.elements]
-        for this_element_label in bo_elements:
-            if this_element_label in element_labels:
-                n1_temp = np.array(beam_orientation.vector)
-                node_labels = all_elements[all_element_labels.index(this_element_label)].connectivity
-
-                node_start_coor = all_nodes[all_node_labels.index(node_labels[0])].coordinates
-                node_end_coor = all_nodes[all_node_labels.index(node_labels[-1])].coordinates
-                t = (node_end_coor-node_start_coor) 
-                t = t/np.linalg.norm(t)
-
-                n2 = np.cross(t, n1_temp)
-                n2 = n2/np.linalg.norm(n2)
-
-                n1 = np.cross(n2, t)        #does this actually work?
-
-                element_orientations[np.where(element_labels == this_element_label)[0]] = np.array([t,n1,n2])
-
-    return element_orientations
-
-
-def freq_sysmat(mat,freqs,freq):
-    """
-    Interpolate frequency dependent matrix, for given frequency value. !! Deprecated - use numpy functions directly instead !!
-
-    Args:
-        mat: 3D matrix (Numpy array)
-        freqs: frequency axis (Numpy array)
-        freq: selected frequency value (scalar)
-    Returns:
-        mat_sel: 2D matrix corresponding to queried frequency value (Numpy array)
-
-    NTNU / AAJ / Knut Andreas Kvaale, 2018
-    """   
-    from .general import interp1z
-    
-    if freq == []:
-        mat_sel = 0
-    else:
-        mat_sel = interp1z(freqs[:,0,0],mat,freq)
-    return mat_sel
-
-
-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 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)
-
-    NTNU / Knut Andreas Kvaale, 2018
-    """
-    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
-
-#%% EXPORT THINGS
-def save_nodes_and_elements(folder, element_labels, element_node_indices, node_labels, node_coordinates, element_orientations=None, set_strings=None):
-    for ix, element_labels_i in enumerate(element_labels):
-        element_info = np.column_stack([element_labels[ix], element_node_indices[ix]])
-        node_info = np.column_stack([node_labels[ix], node_coordinates[ix]])
-        np.savetxt(os.path.join(folder, 'node_info_%i.dat' % (ix)), node_info)
-        np.savetxt(os.path.join(folder, 'element_info_%i.dat' % (ix)), element_info)
-
-        if element_orientations:
-            np.savetxt(os.path.join(folder, 'element_orientations_%i.dat' % (ix)), element_orientations)
-
-        if set_strings:
-            np.savetxt(os.path.join(folder, 'node_and_element_sets.txt'), set_strings, fmt='%s', delimiter=',')
-
-
-def save_pontoon_info(folder, node_labels, node_coordinates, pontoon_labels=None, pontoon_angles=None):
-    if pontoon_labels==None:    # standard if no pontoon_labels are provided (integers!)
-        pontoon_labels = np.linspace(1, len(node_labels), len(node_labels)).astype(int)
-
-    if pontoon_angles==None:
-        pontoon_angles = np.zeros(len(node_labels))    #if no angles are given, output zero for all pontoon angles
-
-    pontooninfo = np.column_stack([pontoon_labels, node_coordinates,  node_labels, pontoon_angles])
-    np.savetxt(os.path.join(folder, 'pontoon_info.dat'), pontooninfo)
-
-
-def save_all_modal(folder, phi, suffix='', f=None, m=None, set_strings=None):
-
-    if isinstance(phi, list):
-        for ix, phi_i in enumerate(phi):
-            np.savetxt(os.path.join(folder, 'phi_%s_%i.dat' % (suffix, ix)), phi_i)
-        
-        if set_strings:
-            np.savetxt(os.path.join(folder, 'phi_%s_sets.txt' % (suffix)), set_strings, fmt='%s', delimiter=',')
-
-    elif isinstance(phi, np.ndarray):
-        np.savetxt(os.path.join(folder, 'phi_%s_%i.dat' % (suffix, 0)), phi)
-
-    if f is not None:
-        np.savetxt(os.path.join(folder, 'f.dat'), f)
-    if m is not None:
-        np.savetxt(os.path.join(folder, 'm.dat'), m)
-
-
-#%% ONLY DEBUGGED IN BRIGADE
-def mode2df(model, node_labels, phi, name, instance_name):
-    nodes = tuple(np.repeat(node_labels,6).tolist())
-    dofs = np.tile(np.arange(1,6+1), len(node_labels))
-
-    dofs_and_mags = np.empty([np.shape(dofs)[0],2])
-    dofs_and_mags[:, 0::2] = dofs[:, np.newaxis]
-    dofs_and_mags[:, 1::2] = phi[:, np.newaxis]
-
-    data = ((instance_name, 2, nodes, tuple(dofs_and_mags.flatten().tolist())),)
-    df = model.DiscreteField(data=data, dataWidth=2, defaultValues=(0.0, 0.0, 0.0, 0.0, 0.0, 0.0), description='Mode displacement', fieldType=PRESCRIBEDCONDITION_DOF, location=NODES, name=name)
-
-    return df
-
-
-def apply_nodal_load(model, node_labels, step_name, loads, instance_name, prefix=''):
-    instance = model.rootAssembly.instances[instance_name]
-    all_node_labels = [node.label for node in instance.nodes]
-    ndof = 6            # assumes 6 DOFs for all nodes - be aware!
-    for node_ix, node_label in enumerate(node_labels):
-        if all_node_labels.count(node_label) != None:   # if in node labels
-            global_node_ix = all_node_labels.index(node_label)
-            node_set = model.rootAssembly.Set(name='node_%i' % (node_label), nodes=instance.nodes[global_node_ix:global_node_ix+1])
-            nodeloads = loads[node_ix*6:node_ix*6+6]
-
-            if not np.all(nodeloads[0:3]==0):
-                model.ConcentratedForce(cf1=nodeloads[0], cf2=nodeloads[1], cf3=nodeloads[2], createStepName=step_name, distributionType=UNIFORM, field='', localCsys=None, name='%sforces_node_%i' % (prefix, node_label), region=node_set)
-            
-            if not np.all(nodeloads[3:6]==0):
-                model.Moment(cm1=nodeloads[3], cm2=nodeloads[4], cm3=nodeloads[5], createStepName=step_name, distributionType=UNIFORM, field='', localCsys=None, name='%smoments_node_%i' % (prefix, node_label), region=node_set)
-
-        else:
-            raise ValueError('Node %i does not exist in selected instance.' % (node_label))
-
-
-def assign_modal_constraint_equation(model, instance_name, name, node_labels, displacement):
-    ndof = 6            # assumes 6 DOFs for all nodes - be aware!
-    instance = model.rootAssembly.instances[instance_name]
-    all_node_labels = [node.label for node in instance.nodes]
-    terms = []
-    for node_ix, node_label in enumerate(node_labels):
-        if all_node_labels.count(node_label) != None:   # if in node labels
-            global_node_ix = all_node_labels.index(node_label)
-            node_set_name = 'node_%i' % (node_label)
-            node_set = model.rootAssembly.Set(name=node_set_name, nodes=instance.nodes[global_node_ix:global_node_ix+1])
-            displacement_of_node = displacement[node_ix*ndof:node_ix*ndof+ndof]
-            non_zero = np.where(displacement_of_node !=0 )[0]
-            terms.append([(displacement_of_node[ldof], node_set_name, ldof+1) for ldof in non_zero])
-
-    terms = tuple([term for sublist in terms for term in sublist])
-    model.Equation(name=name, terms=terms)
-