Milestone 2 - this version has all the input completed, individually and each tested.

2-Dimensional Frame Analysis - Version 04

This program performs an elastic analysis of 2-dimensional structural frames. It has the following features:

Input is provided by a set of CSV files (and cell-magics exist so you can specifiy the CSV data in a notebook cell). See the example below for an, er, example.
Handles concentrated forces on nodes, and concentrated forces, concentrated moments, and linearly varying distributed loads applied transversely anywhere along the member (i.e., there is as yet no way to handle longitudinal load components).
It handles fixed, pinned, roller supports and member end moment releases (internal pins). The former are handled by assigning free or fixed global degrees of freedom, and the latter are handled by adjusting the member stiffness matrix.
It has the ability to handle named sets of loads with factored combinations of these.
The DOF #'s are assigned by the program, with the fixed DOF #'s assigned after the non-fixed. The equilibrium equation is then partitioned for solution. Among other advantages, this means that support settlement could be easily added (there is no UI for that, yet).
A non-linear analysis can be performed using the P-Delta method (fake shears are computed at column ends due to the vertical load acting through horizontal displacement differences, and these shears are applied as extra loads to the nodes).
A full non-linear (2nd order) elastic analysis will soon be available by forming the equilibrium equations on the deformed structure. This is very easy to add, but it hasn't been done yet. Shouldn't be too long.
There is very little no documentation below, but that will improve, slowly.



In [1]:

    
from __future__ import print_function



In [2]:

    
import salib as sl
sl.import_notebooks()
from Tables import Table
from Nodes import Node
from Members import Member
from LoadSets import LoadSet, LoadCombination
from NodeLoads import makeNodeLoad
from MemberLoads import makeMemberLoad
from collections import OrderedDict, defaultdict
import numpy as np



In [3]:

    
class Object(object):
    pass

class Frame2D(object):
    
    def __init__(self,dsname=None):
        self.dsname = dsname
        self.rawdata = Object()
        self.nodes = OrderedDict()
        self.members = OrderedDict()
        self.nodeloads = LoadSet()
        self.memberloads = LoadSet()
        self.loadcombinations = LoadCombination()
        #self.dofdesc = []
        #self.nodeloads = defaultdict(list)
        #self.membloads = defaultdict(list)
        self.ndof = 0
        self.nfree = 0
        self.ncons = 0
        self.R = None
        self.D = None
        self.PDF = None    # P-Delta forces
        
    COLUMNS_xxx = [] # list of column names for table 'xxx'
        
    def get_table(self,tablename,extrasok=False,optional=False):
        columns = getattr(self,'COLUMNS_'+tablename)
        t = Table(tablename,columns=columns,optional=optional)
        t.read(optional=optional)
        reqdl= columns
        reqd = set(reqdl)
        prov = set(t.columns)
        if reqd-prov:
            raise Exception('Columns missing {} for table "{}". Required columns are: {}'\
                            .format(list(reqd-prov),tablename,reqdl))
        if not extrasok:
            if prov-reqd:
                raise Exception('Extra columns {} for table "{}". Required columns are: {}'\
                               .format(list(prov-reqd),tablename,reqdl))
        return t

Test Frame

Nodes



In [4]:

    
%%Table nodes
NODEID,X,Y,Z
A,0,0,5000
B,0,4000,5000
C,8000,4000,5000
D,8000,0,5000



In [5]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_nodes = ('NODEID','X','Y')
        
    def install_nodes(self):
        node_table = self.get_table('nodes')
        for ix,r in node_table.data.iterrows():
            if r.NODEID in self.nodes:
                raise Exception('Multiply defined node: {}'.format(r.NODEID))
            n = Node(r.NODEID,r.X,r.Y)
            self.nodes[n.id] = n
        self.rawdata.nodes = node_table
            
    def get_node(self,id):
        try:
            return self.nodes[id]
        except KeyError:
            raise Exception('Node not defined: {}'.format(id))



In [6]:

    
##test:
f = Frame2D()



In [7]:

    
##test:
f.install_nodes()



In [8]:

    
##test:
f.nodes









    Out[8]:





OrderedDict([('A', Node("A",0,0)),
             ('B', Node("B",0,4000)),
             ('C', Node("C",8000,4000)),
             ('D', Node("D",8000,0))])



In [9]:

    
##test:
f.get_node('C')









    Out[9]:





Node("C",8000,4000)

Supports



In [10]:

    
%%Table supports
NODEID,C0,C1,C2
A,FX,FY,MZ
D,FX,FY



In [11]:

    
def isnan(x):
    if x is None:
        return True
    try:
        return np.isnan(x)
    except TypeError:
        return False



In [12]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_supports = ('NODEID','C0','C1','C2')
    
    def install_supports(self):
        table = self.get_table('supports')
        for ix,row in table.data.iterrows():
            node = self.get_node(row.NODEID)
            for c in [row.C0,row.C1,row.C2]:
                if not isnan(c):
                    node.add_constraint(c)
        self.rawdata.supports = table



In [13]:

    
##test:
f.install_supports()



In [14]:

    
vars(f.get_node('D'))









    Out[14]:





{'constraints': {'FX', 'FY'},
 'dofnums': [None, None, None],
 'id': 'D',
 'x': 8000L,
 'y': 0L}

Members



In [15]:

    
%%Table members
MEMBERID,NODEJ,NODEK
AB,A,B
BC,B,C
DC,D,C



In [16]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_members = ('MEMBERID','NODEJ','NODEK')
    
    def install_members(self):
        table = self.get_table('members')
        for ix,m in table.data.iterrows():
            if m.MEMBERID in self.members:
                raise Exception('Multiply defined member: {}'.format(m.MEMBERID))
            memb = Member(m.MEMBERID,self.get_node(m.NODEJ),self.get_node(m.NODEK))
            self.members[memb.id] = memb
        self.rawdata.members = table
            
    def get_member(self,id):
        try:
            return self.members[id]
        except KeyError:
            raise Exception('Member not defined: {}'.format(id))



In [17]:

    
##test:
f.install_members()
f.members









    Out[17]:





OrderedDict([('AB', Member("AB","Node("A",0,0)","Node("B",0,4000)")),
             ('BC', Member("BC","Node("B",0,4000)","Node("C",8000,4000)")),
             ('DC', Member("DC","Node("D",8000,0)","Node("C",8000,4000)"))])



In [18]:

    
##test:
m = f.get_member('BC')
m.id, m.L, m.dcx, m.dcy









    Out[18]:





('BC', 8000.0, 1.0, 0.0)

Releases



In [19]:

    
%%Table releases
MEMBERID,RELEASE
AB,MZK



In [20]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_releases = ('MEMBERID','RELEASE')
    
    def install_releases(self):
        table = self.get_table('releases',optional=True)
        for ix,r in table.data.iterrows():
            memb = self.get_member(r.MEMBERID)
            memb.add_release(r.RELEASE)
        self.rawdata.releases = table



In [21]:

    
##test:
f.install_releases()



In [22]:

    
##test:
vars(f.get_member('AB'))









    Out[22]:





{'A': None,
 'Ix': None,
 'KG': None,
 'KL': None,
 'L': 4000.0,
 'Tm': None,
 'dcx': 0.0,
 'dcy': 1.0,
 'fefsl': None,
 'id': 'AB',
 'mefs': None,
 'nodej': Node("A",0,0),
 'nodek': Node("B",0,4000),
 'releases': {'MZK'}}

Properties

If the SST module is loadable, member properties may be specified by giving steel shape designations (such as 'W310x97') in the member properties data. If the module is not available, you may still give $A$ and $I_x$ directly (it only tries to lookup the properties if these two are not provided).



In [23]:

    
try:
    from sst import SST
    __SST = SST()
    get_section = __SST.section
except ImportError:
    def get_section(dsg,fields):
        raise ValueError('Cannot lookup property SIZE because SST is not available.  SIZE = {}'.format(dsg))
        ##return [1.] * len(fields.split(',')) # in case you want to do it that way



In [24]:

    
%%Table properties
MEMBERID,SIZE,IX,A
BC,W460x106,,
AB,W310x97,,
DC,,



In [25]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_properties = ('MEMBERID','SIZE','IX','A')
    
    def install_properties(self):
        table = self.get_table('properties')
        table = self.fill_properties(table)
        for ix,row in table.data.iterrows():
            memb = self.get_member(row.MEMBERID)
            memb.size = row.SIZE
            memb.Ix = row.IX
            memb.A = row.A
        self.rawdata.properties = table
        
    def fill_properties(self,table):
        data = table.data
        for ix,row in data.iterrows():
            if type(row.SIZE) in [type(''),type(u'')]:
                if isnan(row.IX) or isnan(row.A):
                    Ix,A = get_section(row.SIZE,'Ix,A')
                    if isnan(row.IX):
                        data.loc[ix,'IX'] = Ix
                    if isnan(row.A):
                        data.loc[ix,'A'] = A
            elif isnan(row.SIZE):
                data.loc[ix,'SIZE'] = ''
        table.data = data.fillna(method='ffill')
        return table



In [26]:

    
##test:
f.install_properties()



In [28]:

    
##test:
vars(f.get_member('DC'))









    Out[28]:





{'A': 12300.0,
 'Ix': 222000000.0,
 'KG': None,
 'KL': None,
 'L': 4000.0,
 'Tm': None,
 'dcx': 0.0,
 'dcy': 1.0,
 'fefsl': None,
 'id': 'DC',
 'mefs': None,
 'nodej': Node("D",8000,0),
 'nodek': Node("C",8000,4000),
 'releases': set(),
 'size': ''}

Node Loads



In [ ]:

    
%%Table node_loads
LOAD,NODEID,DIRN,F
Wind,B,FX,-200000.



In [ ]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_node_loads = ('LOAD','NODEID','DIRN','F')
    
    def install_node_loads(self):
        table = self.get_table('node_loads')
        dirns = ['FX','FY','FZ']
        for ix,row in table.data.iterrows():
            n = self.get_node(row.NODEID)
            if row.DIRN not in dirns:
                raise ValueError("Invalid node load direction: {} for load {}, node {}; must be one of '{}'"
                                .format(row.DIRN, row.LOAD, row.NODEID, ', '.join(dirns)))
            l = makeNodeLoad({row.DIRN:row.F})
            self.nodeloads.append(row.LOAD,n,l)
        self.rawdata.node_loads = table



In [ ]:

    
##test:
f.install_node_loads()



In [ ]:

    
##test:
for o,l,fact in f.nodeloads.iterloads('Wind'):
    print(o,l,fact,l*fact)

Member Loads



In [ ]:

    
%%Table member_loads
LOAD,MEMBERID,TYPE,W1,W2,A,B,C
Live,BC,UDL,-50,,,,
Live,BC,PL,-200000,,5000



In [ ]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_member_loads = ('LOAD','MEMBERID','TYPE','W1','W2','A','B','C')
    
    def install_member_loads(self):
        table = self.get_table('member_loads')
        for ix,row in table.data.iterrows():
            m = self.get_member(row.MEMBERID)
            l = makeMemberLoad(m.L,row)
            self.memberloads.append(row.LOAD,m,l)
        self.rawdata.member_loads = table



In [ ]:

    
##test:
f.install_member_loads()



In [ ]:

    
##test:
for o,l,fact in f.memberloads.iterloads('Live'):
    print(o.id,l,fact,l.fefs()*fact)

Load Combinations



In [ ]:

    
%%Table load_combinations
COMBO,LOAD,FACTOR
One,Live,1.5
One,Wind,1.75



In [ ]:

    
@sl.extend(Frame2D)
class Frame2D:
    
    COLUMNS_load_combinations = ('COMBO','LOAD','FACTOR')
    
    def install_load_combinations(self):
        table = self.get_table('load_combinations')
        for ix,row in table.data.iterrows():
            self.loadcombinations.append(row.COMBO,row.LOAD,row.FACTOR)
        self.rawdata.load_combinations = table



In [ ]:

    
##test:
f.install_load_combinations()



In [ ]:

    
##test:
for o,l,fact in f.loadcombinations.iterloads('One',f.nodeloads):
    print(o.id,l,fact)
for o,l,fact in f.loadcombinations.iterloads('One',f.memberloads):
    print(o.id,l,fact,l.fefs()*fact)

Load Iterators



In [ ]:

    
@sl.extend(Frame2D)
class Frame2D:

    def iter_nodeloads(self,comboname):
        for o,l,f in self.loadcombinations.iterloads(comboname,self.nodeloads):
            yield o,l,f
    
    def iter_memberloads(self,comboname):
        for o,l,f in self.loadcombinations.iterloads(comboname,self.memberloads):
            yield o,l,f



In [ ]:

    
##test:
for o,l,fact in f.iter_nodeloads('One'):
    print(o.id,l,fact)
for o,l,fact in f.iter_memberloads('One'):
    print(o.id,l,fact)

Support Constraints



In [ ]:

    
%%Table supports
NODEID,C0,C1,C2
A,FX,FY,MZ
D,FX,FY

Accumulated Cell Data



In [ ]:

    
##test:
Table.CELLDATA