def test_beam_integration_mid_point_w_steel01():
lp_i = 0.1
lp_j = 0.2
op.wipe()
op.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node
section1_id = 1
section2_id = 2
section3_id = 3
uniaxial_steel01_section(section1_id)
uniaxial_steel01_section(section2_id)
uniaxial_steel01_section(section3_id)
integ_tag = 1
op.beamIntegration('HingeMidpoint', integ_tag, section1_id, lp_i,
section2_id, lp_j, section3_id)
with_force_beam_column = 1
if with_force_beam_column:
# Establish nodes
bot_node = 1
top_node = 2
transf_tag = 1
op.geomTransf('Linear', transf_tag, *[])
op.node(bot_node, 0., 0.)
op.node(top_node, 0., 5.)
ele_i = 1
op.element('forceBeamColumn', ele_i, bot_node, top_node, transf_tag,
integ_tag)
def run(arg_1, arg_2, arg_3, arg_4):
ops.reset()
ops.wipe()
ops.model('basic', '-ndm', 3, '-ndf', 6)
ops.node(1, 0.0, 0.0, 0.0)
ops.node(2, 0.0, 3.2, 0.0)
ops.fix(1, 1, 1, 1, 1, 1, 1)
ops.uniaxialMaterial('Concrete01', 1, -80.0e6, -0.002, 0.0, -0.005)
ops.section('Fiber', 1, '-GJ', 1)
ops.patch('rect', 1, 10, 10, -0.8, -0.1, 0.8, 0.1)
ops.geomTransf('Linear', 1, 0, 0, 1)
ops.beamIntegration('Legendre', 1, 1, 10)
ops.element('dispBeamColumn', 1, 1, 2, 1, 1)
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
ops.load(2, 0, -24586.24, 0, 0, 0, 0)
ops.constraints('Plain')
ops.numberer('RCM')
ops.system('UmfPack')
ops.test('NormDispIncr', 1.0e-6, 2000)
ops.algorithm('Newton')
ops.integrator('LoadControl', 0.01)
ops.analysis('Static')
ops.analyze(100)
ops.wipeAnalysis()
ops.loadConst('-time', 0.0)
ops.recorder('Node', '-file', 'disp.out', ' -time',
'-node', 2, '-dof', 1, 'disp')
ops.recorder('Node', '-file', 'react.out', '-time ',
'-node', 2, '-dof', 1, 'reaction')
ops.timeSeries('Linear', 2)
ops.pattern('Plain', 2, 2)
ops.load(2, 11500, 0, 0, 0, 0, 0)
ops.constraints('Plain')
ops.numberer('RCM')
ops.system('UmfPack')
ops.test('NormDispIncr', 1.0, 2000)
ops.algorithm('Newton')
ops.integrator('LoadControl', 0.01)
ops.analysis('Static')
# ops.analyze(100)
step = 100
data = np.zeros((step, 2))
for i in range(step):
ops.analyze(1)
data[i, 0] = ops.nodeDisp(2, 1)
data[i, 1] = ops.getLoadFactor(2) * 11500
return data
def test_beam_integration_lobatto_w_steel01():
op.wipe()
op.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node
section_id = 1
uniaxial_steel01_material(section_id)
int_tag = 1
op.beamIntegration('Lobatto', int_tag, section_id, 8)
assert 1 == 1 # This pass
def define_beam_integration(integ_tag):
lp_i = 0.1
lp_j = 0.2
section1_id = 1
section2_id = 2
section3_id = 3
uniaxial_steel01_section(section1_id)
uniaxial_steel01_section(section2_id)
uniaxial_steel01_section(section3_id)
op.beamIntegration('HingeMidpoint', integ_tag, section1_id, lp_i, section2_id, lp_j, section3_id)
def test_beam_integration_mid_point_w_elastic():
lp_i = 0.1
lp_j = 0.2
op.wipe()
op.model('basic', '-ndm', 2, '-ndf', 3) # 2 dimensions, 3 dof per node
section_id = 1
elastic_section(section_id)
integ_tag = 1
op.beamIntegration('HingeMidpoint', integ_tag, section_id, lp_i,
section_id, lp_j, section_id)
def section_create():
''' section create
'''
ops.section('Fiber', 1, '-GJ', 1)
ops.fiber(-1.250E+002, -2.500E+002, 5.000E+003, 2)
ops.fiber(-7.500E+001, -2.500E+002, 5.000E+003, 2)
ops.fiber(-2.500E+001, -2.500E+002, 5.000E+003, 2)
ops.fiber(2.500E+001, -2.500E+002, 5.000E+003, 2)
ops.fiber(7.500E+001, -2.500E+002, 5.000E+003, 2)
ops.fiber(1.250E+002, -2.500E+002, 5.000E+003, 2)
ops.fiber(-1.250E+002, -1.500E+002, 5.000E+003, 2)
ops.fiber(-7.500E+001, -1.500E+002, 5.000E+003, 2)
ops.fiber(-2.500E+001, -1.500E+002, 5.000E+003, 2)
ops.fiber(2.500E+001, -1.500E+002, 5.000E+003, 2)
ops.fiber(7.500E+001, -1.500E+002, 5.000E+003, 2)
ops.fiber(1.250E+002, -1.500E+002, 5.000E+003, 2)
ops.fiber(-1.250E+002, -5.000E+001, 5.000E+003, 2)
ops.fiber(-7.500E+001, -5.000E+001, 5.000E+003, 2)
ops.fiber(-2.500E+001, -5.000E+001, 5.000E+003, 2)
ops.fiber(2.500E+001, -5.000E+001, 5.000E+003, 2)
ops.fiber(7.500E+001, -5.000E+001, 5.000E+003, 2)
ops.fiber(1.250E+002, -5.000E+001, 5.000E+003, 2)
ops.fiber(-1.250E+002, 5.000E+001, 5.000E+003, 2)
ops.fiber(-7.500E+001, 5.000E+001, 5.000E+003, 2)
ops.fiber(-2.500E+001, 5.000E+001, 5.000E+003, 2)
ops.fiber(2.500E+001, 5.000E+001, 5.000E+003, 2)
ops.fiber(7.500E+001, 5.000E+001, 5.000E+003, 2)
ops.fiber(1.250E+002, 5.000E+001, 5.000E+003, 2)
ops.fiber(-1.250E+002, 1.500E+002, 5.000E+003, 2)
ops.fiber(-7.500E+001, 1.500E+002, 5.000E+003, 2)
ops.fiber(-2.500E+001, 1.500E+002, 5.000E+003, 2)
ops.fiber(2.500E+001, 1.500E+002, 5.000E+003, 2)
ops.fiber(7.500E+001, 1.500E+002, 5.000E+003, 2)
ops.fiber(1.250E+002, 1.500E+002, 5.000E+003, 2)
ops.fiber(-1.250E+002, 2.500E+002, 5.000E+003, 2)
ops.fiber(-7.500E+001, 2.500E+002, 5.000E+003, 2)
ops.fiber(-2.500E+001, 2.500E+002, 5.000E+003, 2)
ops.fiber(2.500E+001, 2.500E+002, 5.000E+003, 2)
ops.fiber(7.500E+001, 2.500E+002, 5.000E+003, 2)
ops.fiber(1.250E+002, 2.500E+002, 5.000E+003, 2)
ops.fiber(-1.150E+002, 2.650E+002, 3.900E+002, 1)
ops.fiber(1.150E+002, 2.650E+002, 3.900E+002, 1)
ops.fiber(-1.150E+002, -2.650E+002, 4.900E+002, 1)
ops.fiber(0.000E+000, -2.650E+002, 4.900E+002, 1)
ops.fiber(1.150E+002, -2.650E+002, 4.900E+002, 1)
ops.beamIntegration('Legendre', 1, 1, 10)
logger.info("section created")
def ops_section():
''' define section '''
# 保护层壳
ops.section('LayeredShell', 1, 4, 2, 50/1000,
2, 50/1000, 2, 50/1000, 2, 50/1000)
# 加强区壳
ops.section('LayeredShell', 2, 10,
2, 20/1000, # 保护层
6, 1.28177/1000, # 箍筋层
2, 26.239/1000, # 核心区混凝土
2, 26.239/1000, # 核心区混凝土
2, 26.239/1000, # 核心区混凝土
2, 26.239/1000, # 核心区混凝土
2, 26.239/1000, # 核心区混凝土
2, 26.239/1000, # 核心区混凝土
6, 1.28177/1000, # 箍筋层
2, 20/1000 # 保护层
)
# 中部壳
ops.section('LayeredShell', 3, 12,
2, 20/1000, # 保护层
6, 0.65345127/1000, # 箍筋层
7, 0.6544985/1000, # 纵筋层
2, 26.2274/1000, # 核心区混凝土
2, 26.2274/1000, # 核心区混凝土
2, 26.2274/1000, # 核心区混凝土
2, 26.2274/1000, # 核心区混凝土
2, 26.2274/1000, # 核心区混凝土
2, 26.2274/1000, # 核心区混凝土
7, 0.6544985/1000, # 纵筋层
6, 0.65345127/1000, # 箍筋层
2, 20/1000 # 保护层
)
ops.section('Fiber', 4, '-GJ', 1)
# 端部 GFRP 拉锁
ops.patch('circ', 3, 10, 10, 0, 0, 0, 0.01414, 0, 360)
# 端部 SFCB 纵筋
ops.patch('circ', 4, 10, 10, 0, 0.015, 0, 0.01414, 0, 360)
ops.beamIntegration('Legendre', 1, 1, 9)
# 0 1 0
# 端部 SFCB 拉锁
ops.section('Fiber', 5, '-GJ', 1)
ops.patch('circ', 4, 10, 10, 0, 0, 0, 0.01414, 0, 360)
ops.beamIntegration('Legendre', 2, 2, 9)
ops.geomTransf('Linear', 1, 0, 1, 0)
def ops_element():
ops.beamIntegration('Legendre', 1, 2, 9)
ops.geomTransf('Linear', 1, 0, -1, 0)
i = 1
for _i in range(0, 56, 6):
for _j in range(_i + 2, _i + 5):
# print(f'element = {i}, node = {_j},{_j + 1},{_j + 7},{_j + 6 }')
ops.element("ShellNLDKGQ", i, _j, _j + 1, _j + 7, _j + 6, 1)
i = i + 1
for _k in range(1, 61, 6):
# print(f'element = {i}, node = {_k},{_k + 6}')
ops.element('dispBeamColumn', i, _k, _k + 6, 1, 1)
i = i + 1
for _l in range(6, 66, 6):
# print(f'element = {i}, node = {_l},{_l + 6}')
ops.element('dispBeamColumn', i, _l, _l + 6, 1, 1)
i = i + 1
def define_geometry(self, nodes, elements, fixities, num_integ=10):
'''
Define geometry of the structure (all dimensions are in mm).
Args:
nodes: A list of nodes in a form [node_tag, coord1, coord2].
elements: A list of elements in a form
[ele_tag, node1, node2, disc].
fixities: A list of fixities in a form [node, x, y, z].
num_integ: Number of integration points along each element
(default=10)
'''
self.nodes = nodes
self.elements = elements
self.fixities = fixities
if self.section == None:
raise Exception('No section is defined.')
ops.geomTransf('PDelta', 1)
ops.beamIntegration('Lobatto', 1, 1, num_integ)
for nd in self.nodes:
ops.node(*nd)
for el in self.elements:
ele_tag, node1, node2, disc = el
DiscretizeMember.DiscretizeMember(node1,
node2,
disc,
'forceBeamColumn',
1,
1,
nodeTag=len(ops.getNodeTags()) +
1,
eleTag=len(ops.getEleTags()) + 1)
for fx in self.fixities:
ops.fix(*fx)
# create combined 3D section
secTag3D = 3
op.section('Aggregator', secTag3D, 3000, 'T', '-section', 1)
#########################################################################################################################################################################
##########################################################################################################################################################################
# elastic pile section
#import elasticPileSection
#----------------------------------------------------------
# create pile elements
#----------------------------------------------------------
op.beamIntegration(
'Legendre', 1, secTag3D, 3
) # we are using gauss-Legendre integration as it is the default integration scheme used in opensees tcl (check dispBeamColumn)
for i in range(201, 201 + nElePile):
op.element('dispBeamColumn', i, i, i + 1, 1, 1)
print("Finished creating all pile elements...")
#----------------------------------------------------------
# create recorders
#----------------------------------------------------------
# record information at specified increments
timeStep = 0.5
# record displacements at pile nodes
ops.section("WFSection2d", colSecTag, matTag, *WSection["W14X90"], 20,
4) # Column section
ops.section("WFSection2d", beamSecTag, matTag, *WSection["W18x76"], 20,
4) # Beam section
# Define elements
# ---------------
colTransTag, beamTransTag = 1, 2
# Linear, PDelta, Corotational
ops.geomTransf("Corotational", colTransTag)
ops.geomTransf("Linear", beamTransTag)
colIntTag, beamIntTag = 1, 2
nip = 5
# Lobatto, Legendre, NewtonCotes, Radau, Trapezoidal, CompositeSimpson
ops.beamIntegration("Lobatto", colIntTag, colSecTag, nip),
ops.beamIntegration("Lobatto", beamIntTag, beamSecTag, nip)
# Column elements
ops.element("forceBeamColumn", 10, 1, 3, colTransTag, colIntTag, "-mass", 0.0)
ops.element("forceBeamColumn", 11, 3, 5, colTransTag, colIntTag, "-mass", 0.0)
ops.element("forceBeamColumn", 12, 2, 4, colTransTag, colIntTag, "-mass", 0.0)
ops.element("forceBeamColumn", 13, 4, 6, colTransTag, colIntTag, "-mass", 0.0)
# Beam elements
ops.element("forceBeamColumn", 14, 3, 4, beamTransTag, beamIntTag, "-mass",
0.0)
ops.element("forceBeamColumn", 15, 5, 6, beamTransTag, beamIntTag, "-mass",
0.0)
# Create a Plain load pattern with a Linear TimeSeries
def runAnalysis(k):
"""
Tests and individual and returns the result of that test.
The user should consider if it's possible for the test not to work.
"""
Fu = 21.1 * 10**3
# k = 2.6*10**6
b = 0.015
R0 = 19
cR1 = .95
cR2 = .15
Fu = 22.3 * 10**3
# k = 2.6*10**6
b = 0.0129
R0 = 3.1
cR1 = .3
cR2 = .01
# 21.1*10**3, 2.6*10**6, 0.015, 19, .95, .15]
# 2.25427928e+04 3.33339323e+06 1.96273081e-02 5.46515829e+00
# 6.98429661e-01 5.28210755e-02
# 2.20833537e+04 3.03336982e+06 1.28872130e-02 3.13990345e+00
# 3.36067251e-01 1.04312516e-01
op.wipe()
op.model('Basic', '-ndm', 2, '-ndf', 3)
## Analysis Parameters material(s)
## ------------------
LoadProtocol = np.array([
0.0017, 0.005, 0.0075, 0.012, 0.018, 0.027, 0.04, 0.054, 0.068, 0.072,
0.
])
# Step size
dx = 0.0001
op.uniaxialMaterial('Steel02', 1, Fu, k, b, R0, cR1, cR2, 0., 1., 0., 1.)
ERelease = 1.
op.uniaxialMaterial('Elastic', 2, ERelease, 0.0)
## Define geometric transformation(s)
## ----------------------------------
#geomTransf('Linear',1)
op.geomTransf('PDelta', 1)
op.beamIntegration('Lobatto', 1, 1, 3)
# Define geometry
# ---------------
op.node(1, 0., 0., '-ndf', 3)
op.node(2, 0., 0., '-ndf', 3)
op.fix(1, 1, 1, 1)
# Define element(s)
# -----------------
op.element("zeroLength", 1, 1, 2, '-mat', 1, 2, 2, '-dir', 1, 2, 3,
'-orient', 1., 0., 0., 0., 1., 0.)
# Define Recorder(s)
# -----------------
op.recorder('Node', '-file', 'RFrc.out', '-time', '-nodeRange', 1, 1,
'-dof', 1, 'reaction')
op.recorder('Node', '-file', 'Disp.out', '-time', '-nodeRange', 2, 2,
'-dof', 1, 'disp')
# Define Analysis Parameters
# -----------------
op.timeSeries('Linear', 1, '-factor', 1.0)
op.pattern('Plain', 1, 1, '-fact', 1.)
op.load(2, 1., 0.0, 0.0)
# op.initialize()
op.constraints("Plain")
op.numberer("Plain")
# System of Equations
op.system("UmfPack", '-lvalueFact', 10)
# Convergence Test
op.test('NormDispIncr', 1. * 10**-8, 25, 0, 2)
# Solution Algorithm
op.algorithm('Newton')
# Integrator
op.integrator('DisplacementControl', 2, 1, dx)
# Analysis Type
op.analysis('Static')
ControlNode = 2
ControlNodeDof = 1
op.record()
ok = 0
# Define Analysis
for x in LoadProtocol:
for ii in range(0, 2):
# op.
op.integrator('DisplacementControl', ControlNode, ControlNodeDof,
dx)
while (op.nodeDisp(2, 1) < x):
ok = op.analyze(1)
if ok != 0:
print('Ending analysis')
op.wipe()
return np.array([0, 0])
op.integrator('DisplacementControl', ControlNode, ControlNodeDof,
-dx)
while (op.nodeDisp(2, 1) > -x):
ok = op.analyze(1)
if ok != 0:
print('Ending analysis')
op.wipe()
return np.array([0, 0])
op.wipe()
fileDispName = os.path.join('Disp.out')
fileForceName = os.path.join('RFrc.out')
disp = np.loadtxt(fileDispName)
RFrc = np.loadtxt(fileForceName)
# try:
x = disp[:, 1]
y = -RFrc[:, 1]
xy = np.column_stack([x, y])
return xy
# geomTransf('PDelta', transfTag, *vecxz, '-jntOffset', *dI, *dJ)
# Transf beamL and beamB
ops.geomTransf("PDelta", 1, *[0, 0, 1])
# Transf columns
ops.geomTransf("PDelta", 2, *[1, 0, 0])
print("\n已创建局部坐标系下的定位向量")
# =============================================================================
# create Gauss-Legendre integration points alone the element
# =============================================================================
# beamIntegration('Legendre', tag, secTag, N)
# Integration for columns from level 01 to 05
ops.beamIntegration("Legendre", 1, 1, 5)
# Integration for columns from level 06 to 10
ops.beamIntegration("Legendre", 2, 2, 5)
# Integration for columns from level 11 to 14
ops.beamIntegration("Legendre", 3, 3, 5)
# Integration for beam from L direction
ops.beamIntegration("Legendre", 4, 4, 5)
# Integration for beam from B direction
ops.beamIntegration("Legendre", 5, 4, 5)
print("\n已创建积分")
# =============================================================================
def RunAnalysis():
AnalysisType = 'Pushover'
# Pushover Gravity
## ------------------------------
## Start of model generation
## -----------------------------
# remove existing model
ops.wipe()
# set modelbuilder
ops.model('basic', '-ndm', 2, '-ndf', 3)
import math
############################################
### Units and Constants ###################
############################################
inch = 1
kip = 1
sec = 1
# Dependent units
sq_in = inch * inch
ksi = kip / sq_in
ft = 12 * inch
# Constants
g = 386.2 * inch / (sec * sec)
pi = math.acos(-1)
#######################################
##### Dimensions
#######################################
# Dimensions Input
H_story = 10.0 * ft
W_bayX = 16.0 * ft
W_bayY_ab = 5.0 * ft + 10.0 * inch
W_bayY_bc = 8.0 * ft + 4.0 * inch
W_bayY_cd = 5.0 * ft + 10.0 * inch
# Calculated dimensions
W_structure = W_bayY_ab + W_bayY_bc + W_bayY_cd
################
### Material
################
# Steel02 Material
matTag = 1
matConnAx = 2
matConnRot = 3
Fy = 60.0 * ksi
# Yield stress
Es = 29000.0 * ksi
# Modulus of Elasticity of Steel
v = 0.2
# Poisson's ratio
Gs = Es / (1 + v)
# Shear modulus
b = 0.10
# Strain hardening ratio
params = [18.0, 0.925, 0.15] # R0,cR1,cR2
R0 = 18.0
cR1 = 0.925
cR2 = 0.15
a1 = 0.05
a2 = 1.00
a3 = 0.05
a4 = 1.0
sigInit = 0.0
alpha = 0.05
ops.uniaxialMaterial('Steel02', matTag, Fy, Es, b, R0, cR1, cR2, a1, a2,
a3, a4, sigInit)
# ##################
# ## Sections
# ##################
colSecTag1 = 1
colSecTag2 = 2
beamSecTag1 = 3
beamSecTag2 = 4
beamSecTag3 = 5
# COMMAND: section('WFSection2d', secTag, matTag, d, tw, bf, tf, Nfw, Nff)
ops.section('WFSection2d', colSecTag1, matTag, 10.5 * inch, 0.26 * inch,
5.77 * inch, 0.44 * inch, 15, 16) # outer Column
ops.section('WFSection2d', colSecTag2, matTag, 10.5 * inch, 0.26 * inch,
5.77 * inch, 0.44 * inch, 15, 16) # Inner Column
ops.section('WFSection2d', beamSecTag1, matTag, 8.3 * inch, 0.44 * inch,
8.11 * inch, 0.685 * inch, 15, 15) # outer Beam
ops.section('WFSection2d', beamSecTag2, matTag, 8.2 * inch, 0.40 * inch,
8.01 * inch, 0.650 * inch, 15, 15) # Inner Beam
ops.section('WFSection2d', beamSecTag3, matTag, 8.0 * inch, 0.40 * inch,
7.89 * inch, 0.600 * inch, 15, 15) # Inner Beam
# Beam size - W10x26
Abeam = 7.61 * inch * inch
IbeamY = 144. * (inch**4)
# Inertia along horizontal axis
IbeamZ = 14.1 * (inch**4)
# inertia along vertical axis
# BRB input data
Acore = 2.25 * inch
Aend = 10.0 * inch
LR_BRB = 0.55
# ###########################
# ##### Nodes
# ###########################
# Create All main nodes
ops.node(1, 0.0, 0.0)
ops.node(2, W_bayX, 0.0)
ops.node(3, 2 * W_bayX, 0.0)
ops.node(11, 0.0, H_story)
ops.node(12, W_bayX, H_story)
ops.node(13, 2 * W_bayX, H_story)
ops.node(21, 0.0, 2 * H_story)
ops.node(22, W_bayX, 2 * H_story)
ops.node(23, 2 * W_bayX, 2 * H_story)
ops.node(31, 0.0, 3 * H_story)
ops.node(32, W_bayX, 3 * H_story)
ops.node(33, 2 * W_bayX, 3 * H_story)
# Beam Connection nodes
ops.node(1101, 0.0, H_story)
ops.node(1201, W_bayX, H_story)
ops.node(1202, W_bayX, H_story)
ops.node(1301, 2 * W_bayX, H_story)
ops.node(2101, 0.0, 2 * H_story)
ops.node(2201, W_bayX, 2 * H_story)
ops.node(2202, W_bayX, 2 * H_story)
ops.node(2301, 2 * W_bayX, 2 * H_story)
ops.node(3101, 0.0, 3 * H_story)
ops.node(3201, W_bayX, 3 * H_story)
ops.node(3202, W_bayX, 3 * H_story)
ops.node(3301, 2 * W_bayX, 3 * H_story)
# ###############
# Constraints
# ###############
ops.fix(1, 1, 1, 1)
ops.fix(2, 1, 1, 1)
ops.fix(3, 1, 1, 1)
# #######################
# ### Elements
# #######################
# ### Assign beam-integration tags
ColIntTag1 = 1
ColIntTag2 = 2
BeamIntTag1 = 3
BeamIntTag2 = 4
BeamIntTag3 = 5
ops.beamIntegration('Lobatto', ColIntTag1, colSecTag1, 4)
ops.beamIntegration('Lobatto', ColIntTag2, colSecTag2, 4)
ops.beamIntegration('Lobatto', BeamIntTag1, beamSecTag1, 4)
ops.beamIntegration('Lobatto', BeamIntTag2, beamSecTag2, 4)
ops.beamIntegration('Lobatto', BeamIntTag3, beamSecTag3, 4)
# Assign geometric transformation
ColTransfTag = 1
BeamTranfTag = 2
ops.geomTransf('PDelta', ColTransfTag)
ops.geomTransf('Linear', BeamTranfTag)
# Assign Elements ##############
# ## Add non-linear column elements
ops.element('forceBeamColumn', 1, 1, 11, ColTransfTag, ColIntTag1, '-mass',
0.0)
ops.element('forceBeamColumn', 2, 2, 12, ColTransfTag, ColIntTag2, '-mass',
0.0)
ops.element('forceBeamColumn', 3, 3, 13, ColTransfTag, ColIntTag1, '-mass',
0.0)
ops.element('forceBeamColumn', 11, 11, 21, ColTransfTag, ColIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 12, 12, 22, ColTransfTag, ColIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 13, 13, 23, ColTransfTag, ColIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 21, 21, 31, ColTransfTag, ColIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 22, 22, 32, ColTransfTag, ColIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 23, 23, 33, ColTransfTag, ColIntTag1,
'-mass', 0.0)
# ### Add linear main beam elements, along x-axis
#element('elasticBeamColumn', 101, 1101, 1201, Abeam, Es, Gs, Jbeam, IbeamY, IbeamZ, beamTransfTag, '-mass', 0.0)
ops.element('forceBeamColumn', 101, 1101, 1201, BeamTranfTag, BeamIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 102, 1202, 1301, BeamTranfTag, BeamIntTag1,
'-mass', 0.0)
ops.element('forceBeamColumn', 201, 2101, 2201, BeamTranfTag, BeamIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 202, 2202, 2301, BeamTranfTag, BeamIntTag2,
'-mass', 0.0)
ops.element('forceBeamColumn', 301, 3101, 3201, BeamTranfTag, BeamIntTag3,
'-mass', 0.0)
ops.element('forceBeamColumn', 302, 3202, 3301, BeamTranfTag, BeamIntTag3,
'-mass', 0.0)
# Assign constraints between beam end nodes and column nodes (RIgid beam column connections)
ops.equalDOF(11, 1101, 1, 2, 3)
ops.equalDOF(12, 1201, 1, 2, 3)
ops.equalDOF(12, 1202, 1, 2, 3)
ops.equalDOF(13, 1301, 1, 2, 3)
ops.equalDOF(21, 2101, 1, 2, 3)
ops.equalDOF(22, 2201, 1, 2, 3)
ops.equalDOF(22, 2202, 1, 2, 3)
ops.equalDOF(23, 2301, 1, 2, 3)
ops.equalDOF(31, 3101, 1, 2, 3)
ops.equalDOF(32, 3201, 1, 2, 3)
ops.equalDOF(32, 3202, 1, 2, 3)
ops.equalDOF(33, 3301, 1, 2, 3)
AllNodes = ops.getNodeTags()
massX = 0.49
for nodes in AllNodes:
ops.mass(nodes, massX, massX, 0.00001)
################
## Gravity Load
################
# create TimeSeries
ops.timeSeries("Linear", 1)
# create a plain load pattern
ops.pattern("Plain", 1, 1)
# Create the nodal load
ops.load(11, 0.0, -5.0 * kip, 0.0)
ops.load(12, 0.0, -6.0 * kip, 0.0)
ops.load(13, 0.0, -5.0 * kip, 0.0)
ops.load(21, 0., -5. * kip, 0.0)
ops.load(22, 0., -6. * kip, 0.0)
ops.load(23, 0., -5. * kip, 0.0)
ops.load(31, 0., -5. * kip, 0.0)
ops.load(32, 0., -6. * kip, 0.0)
ops.load(33, 0., -5. * kip, 0.0)
###############################
### PUSHOVER ANALYSIS
###############################
if (AnalysisType == "Pushover"):
print("<<<< Running Pushover Analysis >>>>")
# Create load pattern for pushover analysis
# create a plain load pattern
ops.pattern("Plain", 2, 1)
ops.load(11, 1.61, 0.0, 0.0)
ops.load(21, 3.22, 0.0, 0.0)
ops.load(31, 4.83, 0.0, 0.0)
ControlNode = 31
ControlDOF = 1
MaxDisp = 0.15 * H_story
DispIncr = 0.1
NstepsPush = int(MaxDisp / DispIncr)
Model = 'test'
LoadCase = 'Pushover'
dt = 0.2
opp.createODB(Model, LoadCase, Nmodes=3)
ops.system("ProfileSPD")
ops.numberer("Plain")
ops.constraints("Plain")
ops.integrator("DisplacementControl", ControlNode, ControlDOF,
DispIncr)
ops.algorithm("Newton")
ops.test('NormUnbalance', 1e-8, 10)
ops.analysis("Static")
# analyze(NstepsPush)
ops.analyze(100)
print("Pushover analysis complete")
def main():
"""
Create a Cantilever Problem
"""
ops.wipe()
ops.model('basic', '-ndm', 2, '-ndf', 3)
height = 5.0
nElem = 20
ElemLength = height / nElem
nodeID = []
Ycoord = 0
for i in range(nElem + 1):
nodeID.append(i)
ops.node(i, 0.0, Ycoord)
Ycoord += ElemLength
IDctrlNode = i
ops.fix(0, 1, 1, 1)
ops.geomTransf('Linear', 1)
concrete = 'Concrete04'
steel = 'Steel02'
matTAGConc = 319
matTAGSteel = 312
fcc = -20000
ec2c = -0.002
ecu2c = -0.0035
Ec = 30000000
fct = 2200
et = 0.001
fy = 500000
E0 = 200000000
b = 0.01
ops.uniaxialMaterial(concrete, matTAGConc, fcc, ec2c, ecu2c, Ec, fct, et)
ops.uniaxialMaterial(steel, matTAGSteel, fy, E0, b, 20, 0.925, 0.15, 0, 1, 0, 1, 0)
# Core Fibers
ops.section('Fiber', 105)
ops.patch('rect', 319, 11, 11, -0.20, -0.20, 0.20, 0.20)
# Cover Fibers
ops.patch('rect', 319, 15, 2, 0.250000, 0.200000, -0.250000, 0.250000)
ops.patch('rect', 319, 15, 2, 0.250000, -0.250000, -0.250000, -0.200000)
ops.patch('rect', 319, 2, 11, -0.250000, -0.200000, -0.200000, 0.200000)
ops.patch('rect', 319, 2, 11, 0.200000, -0.200000, 0.250000, 0.200000)
# create corner bars
ops.layer('straight', 312, 4, 0.00025450, 0.200000, 0.200000, -0.200000, 0.200000)
ops.layer('straight', 312, 4, 0.00025450, 0.200000, -0.200000, -0.200000, -0.200000)
ops.beamIntegration('Lobatto', 100, 105, 3)
for i in range(len(nodeID) - 1):
ops.element('forceBeamColumn', i, nodeID[i], nodeID[i + 1], 1, 100, '-iter', 10, 1e-6)
# Add Vertical Load at Top
ops.timeSeries('Linear', 101)
ops.pattern('Plain', 100, 101)
ops.load(IDctrlNode, 0, -500, 0)
# Solve Gravity First
ops.system('UmfPack')
ops.numberer('Plain')
ops.constraints('Transformation')
ops.integrator('LoadControl', 0.1)
ops.test('RelativeTotalNormDispIncr', 0.001, 100, 2)
ops.algorithm('Newton')
ops.analysis('Static')
LoadControlSubStep(10, 0.1, True)
# Displacement Control Analysis(Pushover)
ops.pattern('Plain', 200, 101)
ops.load(IDctrlNode, 1, 0, 0)
ops.system('UmfPack')
ops.numberer('Plain')
ops.constraints('Transformation')
ops.test('RelativeTotalNormDispIncr', 1e-2, 500, 2)
ops.algorithm('Newton')
ops.analysis('Static')
DispControlSubStep(100, IDctrlNode, 1, 1.0)
def getSections():
op.model('Basic', '-ndm', 2, '-ndf', 3)
# Get material prorpeties
Esteel = 200. * GPa
Eflex = 1.
Erigid = 100. * 10**12
# define materials
op.uniaxialMaterial('Elastic', 1, Esteel)
op.uniaxialMaterial('Elastic', 10, Eflex)
op.uniaxialMaterial('Elastic', 20, Erigid)
# Define Steel Material
Fy = 350. * MPa
E0 = 200. * GPa
b = 0.0005
# uniaxialMaterial('Steel02', matTag, Fy, E0, b)
op.uniaxialMaterial('Steel02', 2, Fy, E0, b)
fpc = -30. * 10**6
fpcu = fpc * 0.1
epsc0 = -0.002
epsU = epsc0 * 8
lam = 0.2
ft = -fpc / 30
Ets = 2 * fpc / (epsc0 * 20)
# Define Concrete Material
# uniaxialMaterial('Concrete02', matTag, fpc, epsc0, fpcu, epsU, lambda, ft, Ets)
op.uniaxialMaterial('Concrete02', 3, fpc, epsc0, fpcu, epsU, lam, ft, Ets)
# Geometry preprocessing
# Get Verticies
h = 600 * mm
w = 400 * mm
vertices = np.array(
[-h / 2, w / 2, -h / 2, -w / 2, h / 2, -w / 2, h / 2, w / 2])
# Define Rebar Info
rebarZ = np.array([-150, 0, 150]) * mm
rebarY = np.array([150, 225]) * mm
Abar = np.pi * (30 * mm / 2)**2
Nbar = len(rebarZ) * len(rebarY)
rebarYZ = np.zeros([Nbar, 2])
for ii, Y in enumerate(rebarY):
for jj, Z in enumerate(rebarZ):
rebarYZ[ii * len(rebarZ) + jj, :] = [Y, Z]
NfibeZ = 1
NfibeY = 100
# Define Sections
# Test Sections
# section('Fiber', secTag)
op.section('Fiber', 1)
# patch('quad', matTag, numSubdivIJ, numSubdivJK, *crdsI, *crdsJ, *crdsK, *crdsL)
op.patch('quad', 1, NfibeZ, NfibeY, *vertices)
for YZ in rebarYZ:
# fiber(yloc, zloc, A, matTag)
op.fiber(*YZ, Abar, 1)
# Actual Section
# section('Fiber', secTag)
op.section('Fiber', 2)
# patch('quad', matTag, numSubdivIJ, numSubdivJK, *crdsI, *crdsJ, *crdsK, *crdsL)
op.patch('quad', 3, NfibeZ, NfibeY, *vertices)
for YZ in rebarYZ:
# fiber(yloc, zloc, A, matTag)
op.fiber(*YZ, Abar, 2)
# Define transform and integration
op.geomTransf('Linear', 1)
op.geomTransf('PDelta', 2)
# beamIntegration('Lobatto', tag, secTag, N)
op.beamIntegration('Lobatto', 1, 1, 4)
op.beamIntegration('Lobatto', 2, 2, 4)
return rebarYZ
beam_id = 2
water_bound_id = -1
water_body_id = -2
# transformation
transfTag = 1
ops.geomTransf('Corotational', transfTag)
# section
secTag = 1
ops.section('Elastic', secTag, E, A, Iz)
# beam integration
inteTag = 1
numpts = 2
ops.beamIntegration('Legendre', inteTag, secTag, numpts)
# beam mesh
beamTag = 6
ndf = 3
ops.mesh('line', beamTag, 2, 12, 13, beam_id, ndf, h, 'dispBeamColumn',
transfTag, inteTag)
ndmass = bmass / len(ops.getNodeTags('-mesh', beamTag))
for nd in ops.getNodeTags('-mesh', beamTag):
ops.mass(nd, ndmass, ndmass, 0.0)
# fluid mesh
fluidTag = 4
ndf = 2
def get_Sections(fc, Es, fy, sec_dims, D, rebar_coords_YZ):
'''
Summary
-------
Parameters
----------
fc : TYPE
DESCRIPTION.
Es : TYPE
DESCRIPTION.
fy : TYPE
DESCRIPTION.
sec_dims : TYPE
DESCRIPTION.
D : TYPE
DESCRIPTION.
rebar_coords_YZ : TYPE
DESCRIPTION.
Returns
-------
None.
'''
# Define standard materials:
E_flex = 1.0
E_rigid = 100.0 * 10**12
ops.uniaxialMaterial('Elastic', 1, Es)
ops.uniaxialMaterial('Elastic', 10, E_flex)
ops.uniaxialMaterial('Elastic', 20, E_rigid)
# Rebar material:
b = 0.02
params = [18.0, 0.925,
0.15] # Recommended values for the Menegotto-Pinto model.
# uniaxialMaterial('Steel02', matTag, Fy, E0, b, *params)
ops.uniaxialMaterial('Steel02', 101, fy, Es, b, *params)
# Concrete material:
fc *= -1 # Value from concrete lab, NTUA.
fcu = 0.2 * fc # Value from concrete lab, NTUA.
eps_c0 = -2 / 10**3 # Value from concrete lab, NTUA.
eps_u = -3.5 / 10**3 # Value from concrete lab, NTUA.
# uniaxialMaterial('Concrete01', matTag, fpc, epsc0, fpcu, epsU)
ops.uniaxialMaterial('Concrete01', 201, fc, eps_c0, fcu, eps_u)
# Geometry preprocessing:
vertices = np.zeros((4, 2))
vertices[:2, :] = -sec_dims / 2
vertices[2:, :] = sec_dims / 2
vertices[0, 0] *= -1
vertices[2, 0] *= -1
N_fiber_Y = 50
N_fiber_Z = 1
A_bar = np.pi * D**2 / 4
#print(vertices)
# Define sections:
# For the rebar/concrete part we use the fiber/patch command
# Define test sections:
# section('Fiber', secTag)
ops.section('Fiber', 1)
# patch('quad', matTag, numSubdivIJ, numSubdivJK, *crdsI, *crdsJ, *crdsK, *crdsL)
ops.patch('quad', 1, N_fiber_Z, N_fiber_Y, *vertices[0, :],
*vertices[1, :], *vertices[2, :], *vertices[3, :])
n = rebar_coords_YZ.shape[0]
# fiber( yloc, zloc, A, matTag)
#ops.fiber(rebar_coords_YZ[i, 0], rebar_coords_YZ[i, 1], A_bar, 1)
[
ops.fiber(rebar_coords_YZ[i, 0], rebar_coords_YZ[i, 1], A_bar, 1)
for i in range(n)
]
# Define actual sections:
# section('Fiber', secTag)
ops.section('Fiber', 10)
# patch('quad', matTag, numSubdivIJ, numSubdivJK, *crdsI, *crdsJ, *crdsK, *crdsL)
ops.patch('quad', 201, N_fiber_Z, N_fiber_Y, *vertices[0, :],
*vertices[1, :], *vertices[2, :], *vertices[3, :])
n = rebar_coords_YZ.shape[0]
# fiber( yloc, zloc, A, matTag)
#ops.fiber(rebar_coords_YZ[i, 0], rebar_coords_YZ[i, 1], A_bar, 101)
[
ops.fiber(rebar_coords_YZ[i, 0], rebar_coords_YZ[i, 1], A_bar, 101)
for i in range(n)
]
# Geometric tranformation:
# geomTransf(transfType, transfTag, *transfArgs)
ops.geomTransf('Linear', 1) # test
ops.geomTransf('PDelta', 10) # actual
# Integrator:
N = 4
# beamIntegration('Lobatto', tag, secTag, N)
ops.beamIntegration('Lobatto', 1, 1, N) # test
ops.beamIntegration('Lobatto', 10, 10, N) # actual
# Sections defined with "canned" section ("WFSection2d"), otherwise use a FiberSection object (ops.section("Fiber",...))
beamSecTag = 1
beamWidth, beamDepth = 10 * cm, 50 * cm
# secTag, matTag, d, tw, bf, tf, Nfw, Nff
ops.section("WFSection2d", beamSecTag, matTag, beamDepth, beamWidth, beamWidth,
0, 20, 0) # Beam section
# Define elements
# ---------------
beamTransTag, beamIntTag = 1, 1
# Linear, PDelta, Corotational
ops.geomTransf("Corotational", beamTransTag)
nip = 5
# Lobatto, Legendre, NewtonCotes, Radau, Trapezoidal, CompositeSimpson
ops.beamIntegration("Legendre", beamIntTag, beamSecTag, nip)
# Beam elements
numEle = 5
meshSize = L / numEle # mesh size
eleType = "dispBeamColumn" # forceBeamColumn, "dispBeamColumn"
# tag, Npts, nodes, type, dofs, size, eleType, transfTag, beamIntTag
ops.mesh("line", 1, 2, *[1, 2], 0, 3, meshSize, eleType, beamTransTag,
beamIntTag)
# Create a Plain load pattern with a Sine/Trig TimeSeries
# -------------------------------------------------------
# tag, tStart, tEnd, period, factor
ops.timeSeries("Trig", 1, 0.0, 1.0, 1.0, "-factor",
1.0) # "Sine", "Trig" or "Triangle"
def RectCFSTSteelHysteretic(length: float, secHeight: float, secWidth: float,
thickness: float, concrete_grade: float,
steel_grade: float, axial_load_ratio: float,
disp_control: Iterable[float]):
'''Peakstress: concrete peak stress \n crushstress: concrete crush stress
'''
#disp input
# dispControl=[3,-3,7,-7,14,-14,14,-14,14,-14,28,-28,28,-28,28,-28,42,-42,42,-42,42,-42,56,-56,0]
dispControl = tuple(disp_control)
#Geometry
# length=740
# secHeight=100
# secWidth=100
# thickness=7
#Materials
##steel_tube
point1Steel, point2Steel, point3Steel = [460, 0.00309], [460, 0.02721
], [530, 0.26969]
point1SteelNegative, point2SteelNegative, point3SteelNegative = [
-460, -0.00309
], [-460, -0.02721], [-736, -0.26969]
pinchX = 0.2
pinchY = 0.7
damagedFactor = 0.01
densitySteel = 7.8 / 1000000000
##concrete
peakPointConcrete, crushPointConcrete = [-221.76, -0.0102], [-195, -0.051]
unloadingLambda = 0.2
tensileStrength = 5.6
tensilePostStiffness = 0.01
densityConcrete = 2.4 / 1000000000
#axialLoadRatio
# axialLoadRatio=0.4
#fix condition
Fixed = 1
#section parameter
areaConcrete = (secHeight - 2 * thickness) * (secWidth - 2 * thickness)
areaSteel = secWidth * secHeight - areaConcrete
# fck,Ec,nuConcrete=128.1,4.34*10000,0.21
# fy,epsilonSteely,Es,nuSteel=444.6,3067/1000000,1.99*100000,0.29
fck = peakPointConcrete[0]
fy = point1Steel[0]
#Computate parameter
axialLoad = (areaConcrete * fck + areaSteel * fy) * axial_load_ratio
#loading control parameter
# for item in dispControlPercentage:
# dispControl.append(item*length)
# dispControl.append(-item*length)
# print('displist:'dispControl)
#wipe and build a model
ops.wipe()
ops.model('basic', '-ndm', 2, '-ndf', 3)
#node coordinates
meshNumLength = 5
meshVerticalSize = length / meshNumLength
meshSteelSize = 10
nodes = [(i + 1, meshVerticalSize * i)
for i in range(int(length / meshVerticalSize) + 1)]
for item in nodes:
ops.node(item[0], 0, item[1])
#boundary condition
ops.fix(1, 1, 1, 1)
# if bool(Fixed):
# ops.fix(int(length/meshVerticalSize)+1,0,0,1) ##uppper constrain condition: free or no-rotation
#mass defination(concentrate mass to nodes)
nodeMassSteel = areaSteel * meshVerticalSize * densitySteel
nodeMassConcrete = areaConcrete * meshVerticalSize * densityConcrete
nodeMass = nodeMassSteel + nodeMassConcrete
for i in range(len(nodes) - 1):
arg = [0., nodeMass, 0.]
ops.mass(i + 2, *arg)
#transformation:
ops.geomTransf('Linear', 1)
#material defination
##steel
ops.uniaxialMaterial('Hysteretic', 1001, *point1Steel, *point2Steel,
*point3Steel, *point1SteelNegative,
*point2SteelNegative, *point3SteelNegative, pinchX,
pinchY, damagedFactor, 0, 0.0)
##concrete
##using concrete01
#peakPointConcrete,crushPointConcrete=[110.6,0.00544],[22.11,0.09145]
#ops.uniaxialMaterial('Concrete01',1,*peakPointConcrete,*crushPointConcrete)
###using concrete02
ops.uniaxialMaterial('Concrete02', 1, *peakPointConcrete,
*crushPointConcrete, unloadingLambda, tensileStrength,
tensilePostStiffness)
#section defination
ops.section('Fiber', 1)
##inner concrete fiber
fiberPointI, fiberPointJ = [
-(secHeight - 2 * thickness) / 2, -(secWidth - 2 * thickness) / 2
], [(secHeight - 2 * thickness) / 2, (secWidth - 2 * thickness) / 2]
ops.patch('rect', 1, 10, 1, *fiberPointI, *fiberPointJ
) # https://opensees.berkeley.edu/wiki/index.php/Patch_Command
##outside steel fiber
steelFiberProperty = {
'height': meshSteelSize,
'area': meshSteelSize * thickness
}
steelFiberPropertyLeftAndRight = {
'height': secWidth,
'area': secWidth * thickness
}
###left and right
leftEdgeFiberY, rightEdgeFiberY = -(
secHeight - 2 * thickness) / 2 - thickness / 2, (
secHeight -
2 * thickness) / 2 + thickness / 2 #rightEdgeFiberY might be wrong
leftandRightEdgeFiberZ = [
-secWidth / 2 + steelFiberPropertyLeftAndRight['height'] * (1 / 2 + N)
for N in range(int(secWidth /
steelFiberPropertyLeftAndRight['height']))
]
###up and down
upEdgeFiberZ, downEdgeFiberZ = -(
secWidth - 2 * thickness) / 2 - thickness / 2, (
secWidth - 2 * thickness) / 2 + thickness / 2
upandDownEdgeFiberY = [
-secHeight / 2 + thickness + steelFiberProperty['height'] * (1 / 2 + N)
for N in range(
int((secHeight - 2 * thickness) / steelFiberProperty['height']))
]
for i in leftandRightEdgeFiberZ:
i = float(i)
ops.fiber(float(leftEdgeFiberY), i,
steelFiberPropertyLeftAndRight['area'], 1001)
ops.fiber(float(rightEdgeFiberY), i,
steelFiberPropertyLeftAndRight['area'], 1001)
for j in upandDownEdgeFiberY:
j = float(j)
ops.fiber(j, float(upEdgeFiberZ), steelFiberProperty['area'], 1001)
ops.fiber(j, float(downEdgeFiberZ), steelFiberProperty['area'], 1001)
#beamInergration defination
ops.beamIntegration('NewtonCotes', 1, 1, 5)
#element defination
for i in range(len(nodes) - 1):
ops.element('dispBeamColumn', i + 1, i + 1, i + 2, 1, 1)
#recorders
ops.recorder('Node', '-file', 'topLateralDisp.txt', '-time', '-node',
int(length / meshVerticalSize + 1), '-dof', 1, 2, 'disp')
ops.recorder('Node', '-file', 'topLateralForce.txt', '-time', '-node',
int(length / meshVerticalSize + 1), '-dof', 1, 2, 'reaction')
ops.recorder('Element', '-file', 'topElementForce.txt', '-time', '-ele',
int(length / meshVerticalSize), 'force')
#gravity load
ops.timeSeries('Linear', 1)
ops.pattern('Plain', 1, 1)
ops.load(int(length / meshVerticalSize + 1), 0, axialLoad, 0)
ops.constraints('Plain')
ops.numberer('RCM')
ops.system('BandGeneral')
##convertage test
tolerant, allowedIteralStep = 1 / 1000000, 6000
ops.test('NormDispIncr', tolerant, allowedIteralStep)
ops.algorithm('Newton')
ops.integrator('LoadControl', 0.1)
ops.analysis('Static')
ops.analyze(10)
ops.loadConst('-time', 0)
#lateraldisp analysis
ops.pattern('Plain', 2, 1)
ops.load(int(length / meshVerticalSize + 1), 100, 0, 0)
for i in range(len(dispControl)):
if i == 0:
ops.integrator('DisplacementControl',
int(length / meshVerticalSize + 1), 1, 0.1)
ops.analyze(int(dispControl[i] / 0.1))
# print('Working on disp round',i)
else:
if dispControl[i] >= 0:
ops.integrator('DisplacementControl',
int(length / meshVerticalSize + 1), 1, 0.1)
ops.analyze(int(
abs(dispControl[i] - dispControl[i - 1]) / 0.1))
# print('Working on disp round',i)
else:
ops.integrator('DisplacementControl',
int(length / meshVerticalSize + 1), 1, -0.1)
ops.analyze(int(
abs(dispControl[i] - dispControl[i - 1]) / 0.1))
def test_EigenFrameExtra():
eleTypes = [
'elasticBeam', 'forceBeamElasticSection', 'dispBeamElasticSection',
'forceBeamFiberSectionElasticMaterial',
'dispBeamFiberSectionElasticMaterial'
]
for eleType in eleTypes:
ops.wipe()
ops.model('Basic', '-ndm', 2)
# units kip, ft
# properties
bayWidth = 20.0
storyHeight = 10.0
numBay = 10
numFloor = 9
A = 3.0 #area = 3ft^2
E = 432000.0 #youngs mod = 432000 k/ft^2
I = 1.0 #second moment of area I=1ft^4
M = 3.0 #mas/length = 4 kip sec^2/ft^2
coordTransf = "Linear" # Linear, PDelta, Corotational
massType = "-lMass" # -lMass, -cMass
nPts = 3 # numGauss Points
# an elastic material
ops.uniaxialMaterial('Elastic', 1, E)
# an elastic section
ops.section('Elastic', 1, E, A, I)
# a fiber section with A=3 and I = 1 (b=1.5, d=2) 2d bending about y-y axis
# b 1.5 d 2.0
y = 2.0
z = 1.5
numFiberY = 2000 # note we only need so many to get the required accuracy on eigenvalue 1e-7!
numFiberZ = 1
ops.section('Fiber', 2)
# patch rect 1 numFiberY numFiberZ 0.0 0.0 z y
ops.patch('quad', 1, numFiberY, numFiberZ, -y / 2.0, -z / 2.0, y / 2.0,
-z / 2.0, y / 2.0, z / 2.0, -y / 2.0, z / 2.0)
# add the nodes
# - floor at a time
nodeTag = 1
yLoc = 0.
for j in range(0, numFloor + 1):
xLoc = 0.
for i in range(numBay + 1):
ops.node(nodeTag, xLoc, yLoc)
xLoc += bayWidth
nodeTag += 1
yLoc += storyHeight
# fix base nodes
for i in range(1, numBay + 2):
ops.fix(i, 1, 1, 1)
# add column element
transfTag = 1
ops.geomTransf(coordTransf, transfTag)
integTag1 = 1
ops.beamIntegration('Lobatto', integTag1, 1, nPts)
integTag2 = 2
ops.beamIntegration('Lobatto', integTag2, 2, nPts)
eleTag = 1
for i in range(numBay + 1):
end1 = i + 1
end2 = end1 + numBay + 1
for j in range(numFloor):
if eleType == "elasticBeam":
ops.element('elasticBeamColumn', eleTag, end1, end2, A, E,
I, 1, '-mass', M, massType)
elif eleType == "forceBeamElasticSection":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M)
elif eleType == "dispBeamElasticSection":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M, massType)
elif eleType == "forceBeamFiberSectionElasticMaterial":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M)
elif eleType == "dispBeamFiberSectionElasticMaterial":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M, massType)
else:
print("BARF")
end1 = end2
end2 = end1 + numBay + 1
eleTag += 1
# add beam elements
for j in range(1, numFloor + 1):
end1 = (numBay + 1) * j + 1
end2 = end1 + 1
for i in range(numBay):
if eleType == "elasticBeam":
ops.element('elasticBeamColumn', eleTag, end1, end2, A, E,
I, 1, '-mass', M, massType)
elif eleType == "forceBeamElasticSection":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M)
elif eleType == "dispBeamElasticSection":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M, massType)
elif eleType == "forceBeamFiberSectionElasticMaterial":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M)
elif eleType == "dispBeamFiberSectionElasticMaterial":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M, massType)
else:
print("BARF")
# element(elasticBeamColumn eleTag end1 end2 A E I 1 -mass M
end1 = end2
end2 = end1 + 1
eleTag += 1
# calculate eigenvalues
numEigen = 3
eigenValues = ops.eigen(numEigen)
PI = 2 * asin(1.0)
# determine PASS/FAILURE of test
testOK = 0
# print table of camparsion
# Bathe & Wilson Peterson SAP2000 SeismoStruct
comparisonResults = [[0.589541, 5.52695, 16.5878],
[0.589541, 5.52696, 16.5879],
[0.589541, 5.52696, 16.5879],
[0.58955, 5.527, 16.588]]
print("\n\nEigenvalue Comparisons for eleType:", eleType)
tolerances = [9.99e-7, 9.99e-6, 9.99e-5]
formatString = '{:>15}{:>15}{:>15}{:>15}{:>15}'
print(
formatString.format('OpenSees', 'Bathe&Wilson', 'Peterson',
'SAP2000', 'SeismoStruct'))
formatString = '{:>15.5f}{:>15.4f}{:>15.4f}{:>15.4f}{:>15.3f}'
for i in range(numEigen):
lamb = eigenValues[i]
print(
formatString.format(lamb, comparisonResults[0][i],
comparisonResults[1][i],
comparisonResults[2][i],
comparisonResults[3][i]))
resultOther = comparisonResults[2][i]
tol = tolerances[i]
if abs(lamb - resultOther) > tol:
testOK = -1
print("failed->", abs(lamb - resultOther), tol)
assert testOK == 0
solverTypes = [
'-genBandArpack', '-fullGenLapack', '-UmfPack', '-SuperLU',
'-ProfileSPD'
]
for solverType in solverTypes:
eleType = 'elasticBeam'
ops.wipe()
ops.model('Basic', '-ndm', 2)
# units kip, ft
# properties
bayWidth = 20.0
storyHeight = 10.0
numBay = 10
numFloor = 9
A = 3.0 #area = 3ft^2
E = 432000.0 #youngs mod = 432000 k/ft^2
I = 1.0 #second moment of area I=1ft^4
M = 3.0 #mas/length = 4 kip sec^2/ft^2
coordTransf = "Linear" # Linear, PDelta, Corotational
massType = "-lMass" # -lMass, -cMass
nPts = 3 # numGauss Points
# an elastic material
ops.uniaxialMaterial('Elastic', 1, E)
# an elastic section
ops.section('Elastic', 1, E, A, I)
# a fiber section with A=3 and I = 1 (b=1.5, d=2) 2d bending about y-y axis
# b 1.5 d 2.0
y = 2.0
z = 1.5
numFiberY = 2000 # note we only need so many to get the required accuracy on eigenvalue 1e-7!
numFiberZ = 1
ops.section('Fiber', 2)
# patch rect 1 numFiberY numFiberZ 0.0 0.0 z y
ops.patch('quad', 1, numFiberY, numFiberZ, -y / 2.0, -z / 2.0, y / 2.0,
-z / 2.0, y / 2.0, z / 2.0, -y / 2.0, z / 2.0)
# add the nodes
# - floor at a time
nodeTag = 1
yLoc = 0.
for j in range(0, numFloor + 1):
xLoc = 0.
for i in range(numBay + 1):
ops.node(nodeTag, xLoc, yLoc)
xLoc += bayWidth
nodeTag += 1
yLoc += storyHeight
# fix base nodes
for i in range(1, numBay + 2):
ops.fix(i, 1, 1, 1)
# add column element
transfTag = 1
ops.geomTransf(coordTransf, transfTag)
integTag1 = 1
ops.beamIntegration('Lobatto', integTag1, 1, nPts)
integTag2 = 2
ops.beamIntegration('Lobatto', integTag2, 2, nPts)
eleTag = 1
for i in range(numBay + 1):
end1 = i + 1
end2 = end1 + numBay + 1
for j in range(numFloor):
if eleType == "elasticBeam":
ops.element('elasticBeamColumn', eleTag, end1, end2, A, E,
I, 1, '-mass', M, massType)
elif eleType == "forceBeamElasticSection":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M)
elif eleType == "dispBeamElasticSection":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M, massType)
elif eleType == "forceBeamFiberSectionElasticMaterial":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M)
elif eleType == "dispBeamFiberSectionElasticMaterial":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M, massType)
else:
print("BARF")
end1 = end2
end2 = end1 + numBay + 1
eleTag += 1
# add beam elements
for j in range(1, numFloor + 1):
end1 = (numBay + 1) * j + 1
end2 = end1 + 1
for i in range(numBay):
if eleType == "elasticBeam":
ops.element('elasticBeamColumn', eleTag, end1, end2, A, E,
I, 1, '-mass', M, massType)
elif eleType == "forceBeamElasticSection":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M)
elif eleType == "dispBeamElasticSection":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag1, '-mass', M, massType)
elif eleType == "forceBeamFiberSectionElasticMaterial":
ops.element('forceBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M)
elif eleType == "dispBeamFiberSectionElasticMaterial":
ops.element('dispBeamColumn', eleTag, end1, end2,
transfTag, integTag2, '-mass', M, massType)
else:
print("BARF")
# element(elasticBeamColumn eleTag end1 end2 A E I 1 -mass M
end1 = end2
end2 = end1 + 1
eleTag += 1
# calculate eigenvalues
numEigen = 3
eigenValues = ops.eigen(solverType, numEigen)
PI = 2 * asin(1.0)
# determine PASS/FAILURE of test
testOK = 0
# print table of camparsion
# Bathe & Wilson Peterson SAP2000 SeismoStruct
comparisonResults = [[0.589541, 5.52695, 16.5878],
[0.589541, 5.52696, 16.5879],
[0.589541, 5.52696, 16.5879],
[0.58955, 5.527, 16.588]]
print("\n\nEigenvalue Comparisons for solverType:", solverType)
tolerances = [9.99e-7, 9.99e-6, 9.99e-5]
formatString = '{:>15}{:>15}{:>15}{:>15}{:>15}'
print(
formatString.format('OpenSees', 'Bathe&Wilson', 'Peterson',
'SAP2000', 'SeismoStruct'))
formatString = '{:>15.5f}{:>15.4f}{:>15.4f}{:>15.4f}{:>15.3f}'
for i in range(numEigen):
lamb = eigenValues[i]
print(
formatString.format(lamb, comparisonResults[0][i],
comparisonResults[1][i],
comparisonResults[2][i],
comparisonResults[3][i]))
resultOther = comparisonResults[2][i]
tol = tolerances[i]
if abs(lamb - resultOther) > tol:
testOK = -1
print("failed->", abs(lamb - resultOther), tol)
assert testOK == 0
def element_create():
''' create element
'''
ops.element('nonlinearBeamColumn', 1, 1, 2, 4, 1001, 1, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 2, 3, 4, 4, 1001, 2, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 3, 5, 6, 4, 1001, 3, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 4, 7, 8, 4, 1001, 4, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 5, 6, 8, 4, 1003, 5, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 6, 4, 2, 4, 1003, 6, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 7, 8, 2, 4, 1004, 7, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 8, 6, 4, 4, 1004, 8, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 9, 9, 3, 4, 1001, 9, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 10, 10, 1, 4, 1001, 10, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 11, 11, 5, 4, 1002, 11, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 12, 12, 7, 4, 1002, 12, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 13, 13, 14, 4, 1002, 13, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 14, 15, 16, 4, 1002, 14, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 15, 7, 1, 4, 1004, 15, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 16, 1, 16, 4, 1004, 16, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 17, 3, 14, 4, 1004, 17, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 18, 5, 3, 4, 1004, 18, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 19, 3, 1, 4, 1003, 19, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 20, 14, 16, 4, 1003, 20, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 21, 5, 7, 4, 1003, 21, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 22, 17, 9, 4, 1001, 22, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 23, 18, 10, 4, 1001, 23, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 24, 19, 11, 4, 1002, 24, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 25, 20, 12, 4, 1002, 25, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 26, 21, 13, 4, 1002, 26, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 27, 22, 15, 4, 1002, 27, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 28, 12, 10, 4, 1004, 28, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 29, 10, 15, 4, 1004, 29, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 30, 9, 13, 4, 1004, 30, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 31, 11, 9, 4, 1004, 31, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 32, 9, 10, 4, 1003, 32, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 33, 13, 15, 4, 1003, 33, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 34, 11, 12, 4, 1003, 34, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 35, 23, 17, 4, 1001, 35, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 36, 24, 18, 4, 1001, 36, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 37, 25, 19, 4, 1002, 37, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 38, 26, 20, 4, 1002, 38, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 39, 27, 21, 4, 1002, 39, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 40, 28, 22, 4, 1002, 40, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 41, 20, 18, 4, 1004, 41, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 42, 18, 22, 4, 1004, 42, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 43, 17, 21, 4, 1004, 43, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 44, 19, 17, 4, 1004, 44, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 45, 17, 18, 4, 1003, 45, "-integration",
'Legendre')
ops.element('nonlinearBeamColumn', 46, 21, 22, 4, 1003, 46, "-integration",
'Legendre')
ops.beamIntegration('Legendre', 1, 1003, 10)
ops.element('dispBeamColumn', 47, 19, 20, 47, 1)
logger.info("element created")
