## Col_RFStiff version 1.00
## Copyright (c) 2006 Bruce Vaughan, BV
Detailing & Design, Inc.
## All rights reserved.
## NOT FOR
############################################################################
""" Add
stiffener/continuity plates to a column and align with a beam.
The default stiffener width based upon beam
flange width: (bfb-twc)/2 + 0.0625 rounded off to the
nearest 1/4".
The default stiffener width based upon
column "A" distance: (bfc-twc)/2 + 0.0625 rounded off to
the nearest 1/4".
The default stiffener thickness
("A" and "bf"): (beam tf + 0.03) rounded off to the nearest
1/8"
The default stiffener length: mem1.depth-2
* mem1.tf - 0.0625 rounded off to the nearest 1/16".
Thickness reference point on the stiffener
material is "NS"
If adding weld is elected, weld is added to
the first stiffener only.
The script performs an
of Mr (0.66FySx/12).
Stiffener offsets (if elected) are with
respect to "Flush Top" at top stiffener and "Flush Bott"
at bottom stiffener.
The script does not account for the
vertical dimensional offset due to beam slope and column depth.
The user can account for it by selecting
the "offset" option for stiffener alignment. The script
does account for the gain in distance
between the stiffeners due to beam slope.
*****************************************************************************************************
DISCLAIMER: The code check is for
information only. Engineering evaluation of the calculations *
is required. *
*****************************************************************************************************
Revision History
R1 -
Allow for thicker top stiffener. Where the top of the column is flush
with the top of the
rigid frame beam, we usually make
the top stiffener 1/4" (re: line 371) thicker and use a
partial penetration groove weld on
3 sides.
R2 -
Add extended shear tabs.
R3 -
If make_top_thicker = "Yes", set condition so weld is added to
first bottom stiffener,
since top stiffener weld
(BTC-P4-GF) will be added in IG.
R4 -
Add option to set stiffener a vertical distance below top. Moved
defaults to line 67.
Edited hole pattern code to work in
"Above
Right">>"Above Left", "FS Face">>"NS
Face", 0.0>>-45.0 group_rot, Slot direction 90.0>>0.0
Create loops for column and beam
members. Each joint gets a dialog box.
R5 -
Update hole pattern code for
-45.0 >> 0.0 group_rot, Slot
direction 0.0 >> 90.0, "Above Left" >> "Below
Right"
The combination of "Above
Right" and "FS Face" also works
Version 1.00 -
Rework dialog boxes for
tabs, group titles, image and organization.
Add support for partial
depth extended shear tabs and stabilizer plates at bottom edge.
Add material usage
descriptions:
Continuity Plate
Extended Shear Tab
Stabilizer
************************************************************
****NOTE: This version is not compatible
with
************************************************************
This script can be executed in plan,
elevation, or isometric.
This source is provided "as
is." All warranties are disclaimed.
Developed in
Developed by Bruce Vaughan, BV Detailing
& Design, Inc. (BVD)
For comments, suggestions or questions call
BVD at the number above.
NOT FOR
Go to line "Defaults section" to
set script defaults.
"""
# startup code begin
import sys
import traceback
import types
from param import *
from math import *
Units("feet")
saved_sds2_version =
'7.002'
saved_python_version =
(2, 1, 1, 'final', 0)
try:
from shape import Shape
from point import Point, PointLocate
from member import Member, MemberLocate
from mtrl_list import MtrlLocate,
HoleLocate
from cons_line import ConsLine
from cons_circle import ConsCircle
from rnd_plate import RndPlate
from rect_plate import RectPlate
from bnt_plate import BntPlate
from rolled_section import RolledSection
from weld_add import Weld
from flat_bar import FlatBar
from hole_add import Hole
from bolt_add import Bolt
from roll_plate import RollPl
from sqr_bar import SqrBar
from rnd_bar import RndBar
from shr_stud import ShrStud
from grate import Grate
from grate_trd import GrateTrd
from deck import Deck
from mtrl_fit import MtrlFit
from version import CurrentVersion,
VersionCompare
curr_version = CurrentVersion()
except ImportError:
curr_version = 'None'
def VersionCompare( v1, v2 ):
return -1
if VersionCompare(
curr_version, '6.311' ) >= 0:
from job import Job
from fab import Fabricator
if VersionCompare(
curr_version, '6.312' ) >= 0:
from plate_layout import PlateLayout
if VersionCompare(
curr_version, '6.314' ) >= 0:
from plate_layout import BntPlateLayout
if VersionCompare(
curr_version, '6.4' ) >= 0:
from mtrl_cut import MtrlCut
try:
from os import path
path_available = 1
except:
path_available = 0
# startup code end
# start of defaults for
stiffener plates xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
#
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Variables section
enable_default_import_export
= "Enable" #
default to enable or disable the importing and exporting of dialog dictionary
variables "Enable" "Disable"
default_file_path =
"C:/ParamDef/Col_RFStiff/"
# system path for defaults file
def_file =
"Col_RFStiff.txt" # defaults file
name
script_name =
"Col_RFStiff_v1.00.py"
image_name1 =
"C:\ParamImg\Col_RFStiff1.gif"
image_name2 =
"C:\ParamImg\Col_RFStiff2.gif"
# Defaults section
add_shr_tab =
"No" # default add extended shear tabs
"Yes", "No"
add_stf_tb =
"Both" #
default add stiffeners "Both", "Top", Bott",
"None"
which_side =
"BS" #
default side(s) for stiffeners "BS" "NS" "FS"
which_stiff =
"User" #
default which stiffener to accept "Beam bf", "Column A",
"User"
stiff_width = 4.75 # default
"user" stiffener width
stiff_thk = 0.75 # default
"user" stiffener thickness
stiff_color =
"None" #
default stiffener finish "None", "Red Oxide", "Yellow
Zinc", "Gray Oxide", "Sandblasted", "Blued
Steel", "Galvanized"
stiff_grade =
"A36" #
default steel grade
top_align = "Flush
Top" # default alignment "Flush
Top", "Flush Bott", Align CL", "Offset"
bot_align = "Flush
Bott" # default
alignment "Flush Top", "Flush Bott", Align CL",
"Offset", "Vert Dist"
top_offset = 0.0 # default offset top stiffener
bot_offset = 0.0 # default offset bottom
stiffener
stiff_clip = 1.0 # default stiffener
corner clip
ad_stf_weld =
"Yes" #
default for adding stiffener weld
"Yes" "No"
stf_weld_type =
"Fillet" #
default for weld type "Fillet" "Bevel groove" "Square
butt"
stf_weld_size =
0.3125 # default
stiffener weld size
stiff_calc =
"Fixed" #
Flag to calculate weld size based on stiffener thickness or to use default
"stf_weld_size" "Fixed, "Calc"
tail_text =
"TYP" #
default weld tail text
prt_code_chk =
"No" #
default to print
top_stiff_extra =
"1/8"
# end of defaults for
stiffeners
# start of defaults for
extended shear tabs
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
which_side_NS =
"Right" #
locate NS plate which side of column CL (right is preferred) "Right",
"Left"
which_side_FS =
"Left" #
locate FS plate which side of column CL (left is preferred) "Right",
"Left"
full_part_depth =
"Partial Depth" #
("Full Depth", "Partial Depth")
dist_1st = 3.0 # distance to first
hole from T/S
no_cols = 2 # number of bolt
columns (2 columns = double gage)
row_spa = 3.0 # spacing of bolt
rows
col_spa = 3.0 # spacing of bolt
columns
pl_thk = 0.5 # thickness of plate material
vert_ed = 1.5 # vertical edge
distace from hole to edge of cope
add_bott_stab =
"Yes" #
("Yes", "No")
stab_width = "5
1/2" #
prep_list = ["Cope
Top", "Cope Bott", "Clip Top", "Clip Bott"]
# ["Cope Top", "Cope Bott", "Clip Top",
"Clip Bott", "None"]
clip_dim = 0.75 # shear plate clip
dimension
pl_end_gap = 1.0 # dimension from end of
beam material to edge of cope
pl_color =
"None" #
shear plate finish "None", "Red Oxide", "Yellow
Zinc", "Gray Oxide", "Sandblasted", "Blued
Steel", "Galvanized"
pl_grade =
"A36" #
steel grade
bolt_size = 0.75 # bolt diameter
hole_type_web =
"Short Slot" # hole
type in web leg "Standard Round", "Short Slot",
"Oversized Round", "Long Slot"
bolt_type_web =
"A325N" # bolt
type in web leg "A325N" "A307" "A325SC"
tab_weld_type =
"Fillet" # weld
type "Fillet" "Bevel groove" "Square Butt"
tab_weld_size =
0.3125 # weld size to
column web
tabstf_weld_size =
0.25 # weld size to
stiffener
# set defaults for
extended shear tab end
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Define functions
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Function definitions
def
form_script_variables():
# All variables are defined as strings in
defaults section. Defaults are saved to disk as dlg.done() defines them.
# Default variables must be reformatted for
imported data or for the second loop if not importing data.
# Only floating point numbers need be
reformatted. Integers should be formatted in the dialog box.
global stiff_width, stiff_thk, top_offset,
bot_offset, stiff_clip, stf_weld_size, top_stiff_extra
stiff_width = dim_print(dim(stiff_width))
stiff_thk = dim_print(dim(stiff_thk))
top_offset = dim_print(dim(top_offset))
bot_offset = dim_print(dim(bot_offset))
stiff_clip = dim_print(dim(stiff_clip))
stf_weld_size =
dim_print(dim(stf_weld_size))
top_stiff_extra =
dim_print(dim(top_stiff_extra))
def
form_script_variables2():
global dist_1st, row_spa, col_spa, pl_thk,
vert_ed, stab_width, clip_dim, pl_end_gap, bolt_size, tab_weld_size,
tabstf_weld_size
dist_1st = dim_print(dim(dist_1st))
row_spa = dim_print(dim(row_spa))
col_spa = dim_print(dim(col_spa))
pl_thk = dim_print(dim(pl_thk))
vert_ed = dim_print(dim(vert_ed))
stab_width = dim_print(dim(stab_width))
clip_dim = dim_print(dim(clip_dim))
pl_end_gap = dim_print(dim(pl_end_gap))
bolt_size = dim_print(dim(bolt_size))
tab_weld_size =
dim_print(dim(tab_weld_size))
tabstf_weld_size =
dim_print(dim(tabstf_weld_size))
########################################################################################################################################################
## Function definitions
for saving default values to disk
## See Python file
"Script_Defaults.py" for usage documentation
########################################################################################################################################################
def import_data(file):
try:
ff = open(file)
except:
print "There was an error opening
the default data file. Please check your directory path and that file
exists."
return 0
else:
dd = {}
key_values_list = ff.readlines()[3:]
ff.close()
for ii in key_values_list:
key_name, key_value =
ii.split("=", 1)
dd[key_name.strip()] =
key_value.strip()
return dd
##########################################################################
def
export_data(file_name, dd_list, script_name): # pass script name for default
file
try:
f = open(file_name, "w")
f.write("Defaults file for script
" + script_name + "\nVariable Name = Value Name\n\n")
for jj in dd_list:
for key_name in jj.keys():
key_value = jj[key_name]
f.write("%s = %s\n" %
(key_name, key_value))
f.close()
except:
dd_list = 0
print "There was an error
exporting the default data to disk. Please check your directory path. "
return dd_list
##################################################################################################################################################
# convert radians to
degrees
def rtod ( r ):
return (r * 180.0 / pi)
# convert degrees to
radians
def dtor ( d ):
return (d * pi / 180.0)
# returns Fy of member
based upon member grade (mem.grade)
# if member grade is not
listed, the function will return 65.0
def ret_Fy (mem):
if mem.grade == "A992":
Fy = 50.0
elif mem.grade == "A36":
Fy = 36.0
elif mem.grade == "A572-50":
Fy = 50.0
elif mem.grade == "A500B":
Fy = 46.0
else:
Fy = 65.0
print "Material grade not listed -
returning 65 ksi"
return Fy
#
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# define function to
return the WP at the column CL
def ret_WP(mem11, mem12):
global which_end
dist1 = Point(mem11.left_location.x,
mem11.left_location.y, 0.000000).dist(Point(mem12.left_location.x,
mem12.left_location.y, 0.000000))
dist2 = Point(mem11.left_location.x,
mem11.left_location.y, 0.000000).dist(Point(mem12.right_location.x,
mem12.right_location.y, 0.000000))
if dist1 < dist2:
pt1 = Point(mem11.left_location.x,
mem11.left_location.y, mem12.left_location.z)
which_end = "left end"
else:
pt1 = Point(mem11.left_location.x,
mem11.left_location.y, mem12.right_location.z)
which_end = "right end"
return (pt1, which_end)
#
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# add rectangular plate
material
# returns a rectangular
plate object
def stiff_pl(mem, pnt1,
pnt2, pl_thk, rotpl):
rot_arg = (rotpl[0], rotpl[1], (rotpl[2] -
0.0))
# rectangular plate begin
rp11 = RectPlate()
rp11.member = mem
rp11.pt1 = pnt1
rp11.pt2 = pnt2
rp11.grade = stiff_grade
rp11.origin = "NS"
rp11.top_oper_left = "Clip"
rp11.top_length_left = stiff_clip
rp11.top_clip_left = stiff_clip
rp11.top_oper_right = "Clip"
rp11.top_length_right = stiff_clip
rp11.top_clip_right = stiff_clip
rp11.bottom_oper_left = "None"
rp11.bottom_oper_right = "None"
rp11.width = stiff_width
rp11.thick = pl_thk
rp11.work_pt_dist = rp11.pt1.dist( rp11.pt2
)
rp11.setback_left = 0
rp11.setback_right = 0
rp11.web_cut_angle_left = 0
rp11.web_cut_angle_right = 0
rp11.length = stiff_length
rp11.mtrl_type = "Plate"
rp11.mtrl_usage = "Continuity
Plate"
rp11.finish = stiff_color
rp11.ref_pt_offset = (0.000000, 0.000000,
0.000000)
rp11.add()
rp11.rotate(rp11.member, rot_arg)
# rectangular plate end
return rp11
# add weld
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
def
stiff_weld(weld_to_list, rl5, weld_size, weld_type, tt):
if weld_type == "Fillet":
allow_fillet = "Yes"
allow_bevel = "No"
allow_square = "Yes"
elif weld_type == "Bevel groove":
allow_fillet = "No"
allow_bevel = "Yes"
allow_square = "No"
else:
allow_fillet = "Yes"
allow_bevel = "No"
allow_square = "Yes"
try:
#
weld add begin
weld9 = Weld()
weld9.mtrl = [rl5, ]
weld9.weld_to = weld_to_list
weld9.min_size = weld_size
weld9.max_size = 1
weld9.min_length = 1
weld9.max_gap = 0.25
weld9.stagger_length = 3
weld9.stagger_spacing = 12
weld9.holdback_length = 0
weld9.root_face = 0
weld9.root_opening = 0
weld9.b_groove_angle = 45
weld9.v_groove_angle = 60
weld9.all_around = "No"
weld9.stagger = "No"
weld9.inside = "No"
weld9.auto_size = 0
weld9.full_penetration = "No"
weld9.fillet_back = "No"
weld9.holdback_end = 0
weld9.prequalified = "No"
weld9.backing_bar = 0
weld9.spacer = 0
weld9.contour = "None"
weld9.allow_fillet = allow_fillet
weld9.allow_square = allow_square
weld9.allow_bevel = allow_bevel
weld9.allow_v = "No"
weld9.allow_j = "No"
weld9.allow_u = "No"
weld9.allow_flare_bevel =
"No"
weld9.allow_flare_v = "No"
weld9.allow_plug = "No"
weld9.allow_backing = "No"
weld9.tail_text = ""
weld9.show_window = "No"
weld9.create()
# weld add end
except:
pass
# add the shear tab
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
def plate_add(mem, pnt1,
pnt2, rot1):
rot_arg = (rot1[0], rot1[1], (rot1[2]))
if cope_top:
leftb_op = "Cope"
cope_l_len = cope_top[0]
cope_l_dep = cope_top[1]
else:
leftb_op = "None"
cope_l_len = 0.0
cope_l_dep = 0.0
if cope_bott:
rightb_op = "Cope"
cope_r_len = cope_bott[0]
cope_r_dep = cope_bott[1]
else:
rightb_op = "None"
cope_r_len = 0.0
cope_r_dep = 0.0
if clip_top:
leftt_op = "Clip"
left_len = clip_top[0]
left_dep = clip_top[1]
else:
leftt_op = "None"
left_len = 0.0
left_dep = 0.0
if clip_bott:
rightt_op = "Clip"
right_len = clip_bott[0]
right_dep = clip_bott[1]
else:
rightt_op = "None"
right_len = 0.0
right_dep = 0.0
# rectangular plate begin
rp1 = RectPlate()
rp1.member = mem
rp1.pt1 = pnt1
rp1.pt2 = pnt2
rp1.grade = pl_grade
rp1.origin = "FS"
rp1.top_oper_left = leftt_op
rp1.top_length_left = left_len
rp1.top_clip_left = left_dep
rp1.top_oper_right = rightt_op
rp1.top_length_right = right_len
rp1.top_clip_right = right_dep
rp1.bottom_oper_left = leftb_op
rp1.bottom_length_left = cope_l_len
rp1.bottom_cope_left = cope_l_dep
rp1.bottom_oper_right = rightb_op
rp1.bottom_length_right = cope_r_len
rp1.bottom_cope_right = cope_r_dep
rp1.width = pl_width
rp1.thick = pl_thk
rp1.work_pt_dist = rp1.pt1.dist( rp1.pt2 )
rp1.setback_left = 0
rp1.setback_right = 0
rp1.web_cut_angle_left = 0
rp1.web_cut_angle_right = 0
rp1.length = pl_length
rp1.mtrl_type = "Plate"
rp1.mtrl_usage = "Extended Shear
Tab"
rp1.finish = pl_color
rp1.ref_pt_offset = (0.000000, 0.000000,
0.000000)
rp1.add()
rp1.rotate(rp1.member, rot_arg)
# rectangular plate end
return rp1
#
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# add holes to shear tab
# slots are rotated
perpendicular to length of material
def pl_holes (rp1):
try:
# hole group add begin
hole26 = Hole()
hole26.mtrl = [rp1, ]
hole26.pt1 = hole26.mtrl.location
hole26.hole_type = hole_type_web
hole26.face = "NS Face"
hole26.valid_cnc = "Yes"
hole26.x_ref_offset = hole_dim_x
hole26.y_ref_offset = hole_dim_y
hole26.x_spa = row_spa
hole26.y_spa = col_spa
hole26.group_rot = 0.0
hole26.locate = "Below Right"
hole26.columns = no_rows
hole26.rows = no_cols
hole26.bolt_type = bolt_type_web
hole26.bolt_dia = bolt_size
hole26.slot_rot = 90.0
hole26.length =
hole26.calc_slot_length()
hole26.hole_dia =
hole26.calc_hole_size()
hole26.show_window = "Yes"
hole26.create()
# hole group add end
except:
pass
####################################################################
def stabilizer_pl(bm,
pnt1, pnt2, rotpl):
# rectangular plate begin
rp12 = RectPlate()
rp12.member = bm
rp12.pt1 = pnt1
rp12.pt2 = pnt2
rp12.grade = pl_grade
rp12.origin = "NS"
rp12.top_oper_left = "None"
rp12.top_length_left = 0.0
rp12.top_clip_left = 0.0
rp12.top_oper_right = "None"
rp12.top_length_right = 0.0
rp12.top_clip_right = 0.0
rp12.bottom_oper_left = "None"
rp12.bottom_oper_right = "None"
rp12.width = stab_width
rp12.thick = pl_thk
rp12.work_pt_dist = rp12.pt1.dist(rp12.pt2)
rp12.setback_left = 0
rp12.setback_right = 0
rp12.web_cut_angle_left = 0
rp12.web_cut_angle_right = 0
rp12.length = stiff_length
rp12.mtrl_type = "Plate"
rp12.mtrl_usage = "Stabilizer"
rp12.finish = pl_color
rp12.ref_pt_offset = (0.000000, 0.000000,
0.000000)
rp12.add()
rp12.rotate(rp12.member, rotpl)
# rectangular plate end
return rp12
###########################################################################
# Default number of bolt
rows (bolt columns with respect to plate material)
def row_list(matl):
if matl[0:2] == "W8":
return 2
elif matl[0:3] == "W10":
return 2
elif matl[0:3] == "W12":
return 3
elif matl[0:3] == "W14":
return 3
elif matl[0:3] == "W16":
return 4
elif matl[0:3] == "W18":
return 5
elif matl[0:3] == "W21":
return 5
elif matl[0:3] == "W24":
return 6
elif matl[0:3] == "W27":
return 7
else:
return 8
# Minimum length (depth)
of partial depth extended shear tab
def tab_length(matl):
if matl[0:2] == "W8":
return 6.0
elif matl[0:3] == "W10":
return 6.75
elif matl[0:3] == "W12":
return 9.75
elif matl[0:3] == "W14":
return 11.75
elif matl[0:3] == "W16":
return 13.75
elif matl[0:3] == "W18":
return 15.75
elif matl[0:3] == "W21":
return 18.625
elif matl[0:3] == "W24":
return 18.625
elif matl[0:3] == "W27":
return 18.625
else:
return 21.0
#
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
##################################################################################################################################################
# a exception handler
function to format the exception info into a string for dialog display - credit
def
formatExceptionInfo(maxTBlevel=5):
cla, exc, trbk = sys.exc_info()
excName = cla.__name__
try:
excArgs = exc.__dict__["args"]
except KeyError:
excArgs = "<none>"
excTb = traceback.format_tb(trbk, maxTBlevel)
#- build the return string ready to be displayed
_str = "Error: " + excName + "\nDesc: "
for i in range(len(excArgs)):
_str = _str + excArgs[i] + "\n"
#for ii in range(len(excTb)):
_str = _str + excTb.pop() # + "\n"
return _str
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# End function
definitions
# Start main program loop
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
count = 0
if
enable_default_import_export == "Enable":
try:
globals().update(import_data(default_file_path + def_file))
if isinstance(prep_list,
types.StringType):
try:
prep_list = eval(prep_list)
except:
prep_list = ["None"]
Warning("Error reading
'prep_list'")
except:
Warning("There was a problem
importing data - reverting to original defaults")
while 1:
ClearSelection()
count = count + 1
col_list = []
bm_list = []
#######################################################################################################
try:
z = 1
# Select column members
while z:
if len(col_list) == 0:
mem1 =
MemberLocate("Select a WF column member.")
else:
mem1 =
MemberLocate("Select an additional WF column member.")
if mem1 == None:
break
else:
if mem1.type ==
"Column":
if mem1.mtrl_type ==
"W flange":
col_list.append(mem1)
else:
Warning(mem1.mtrl_type
+ " column material is not supported.")
else:
Warning("You picked a
" + mem1.type + ". You must pick a Column.")
if len(col_list) < 1:
break
######################################################################
z = 1
# Select beam members
ClearSelection()
while z:
try:
if len(bm_list) == 0:
mem2 =
MemberLocate("Select first
else:
mem2 =
MemberLocate("Select additional
if mem2 == None:
break
else:
if mem2.type in ["Beam",
"Joist", "Horizontal Brc"]:
bm_list.append(mem2)
else:
Warning("You
picked a " + mem2.type + ". You must pick a Beam or Joist.")
except:
yes_or_no("User canceled
the operation.\n" + formatExceptionInfo(), "OK")
bm_list = []
break
if len(bm_list) < 1:
Warning("You did not pick any
beams. Exiting script.")
break
#######################################################################
ClearSelection()
# begin loop for columns
for ci in range(len(col_list)):
pt_list = []
for bi in range(len(bm_list)):
list1 = ret_WP(col_list[ci], bm_list[bi])
pt_list.append(list1[0])
# begin loop for beams
for bi in range(len(bm_list)):
#
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Check to see if top of beam is
within 1/2" of top of column and sets default for
"make_top_thicker"
pt_WP = pt_list[bi]
if
pt_WP.dist(col_list[ci].right_location) < 0.5:
make_top_thicker =
"Yes"
else:
make_top_thicker =
"No"
#
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# if not tail_text:
# tail_text = "TYP"
if top_align !=
"Offset":
top_offset = dim_print(0.0)
if bot_align !=
"Offset":
bot_offset = dim_print(0.0)
# calculate stiffener defaults
and code check properties
stiff_width_bf =
dim_print(round(((bm_list[bi].bf - col_list[ci].tw) / 2 + 0.0625) * 4.0) / 4.0)
stiff_width_A =
dim_print(round(((col_list[ci].bf - col_list[ci].tw) / 2 + 0.0625) * 4.0) /
4.0)
stiff_thk_bf =
dim_print(round((bm_list[bi].tf + 0.03) * 8.0) / 8.0)
stiff_thk_A =
dim_print(round((bm_list[bi].tf + 0.03) * 8.0) / 8.0)
stiff_length =
dim_print(round((col_list[ci].depth-col_list[ci].tf*2-0.0625)*16)/16)
if stiff_calc ==
"Calc":
if which_stiff ==
"User":
stf_weld_size =
dim_print(round((dim(stiff_thk)*0.75+0.02)*16)/16)
elif which_stiff ==
"Column A":
stf_weld_size = dim_print(round((dim(stiff_thk_A)*0.75+0.02)*16)/16)
else:
stf_weld_size =
dim_print(round((dim(stiff_thk_bf)*0.75+0.02)*16)/16)
net_stf_area_bf =
round((dim(stiff_width_bf) - dim(stiff_clip)) * dim(stiff_thk_bf) * 2.0 *
1000.0) / 1000.0
net_stf_area_A =
round((dim(stiff_width_A) - dim(stiff_clip)) * dim(stiff_thk_A) * 2.0 * 1000.0)
/ 1000.0
Sx =
bm_list[bi].Ix/(bm_list[bi].depth/2)
Fyb = ret_Fy(bm_list[bi])
Fyc = ret_Fy(col_list[ci])
Mr =
round(0.67*Fyb*Sx/12.0*100)/100.0
Flg_force =
round(Mr*12.0/(bm_list[bi].depth-bm_list[bi].tf)*100)/100.0
Pbf =
round(Flg_force*5.0/3.0*100)/100.0
Pfb =
round(col_list[ci].tf*col_list[ci].tf*Fyc/0.16*100.0)/100.0
Pwb =
round((4100.0*col_list[ci].tw**3*Fyc**0.5/(col_list[ci].depth-2*col_list[ci].k))*100.0)/100.0
PwoPwi =
round(Fyc*col_list[ci].tw*(bm_list[bi].tf+5.0*col_list[ci].k)*100.0)/100.0
# Determine
stiff_str = "No stiffeners
required"
flg = 0
flg1 = 0
if Pbf>Pfb:
stiff_str =
"K1-1"
flg = 1
if Pbf>Pwb:
if flg:
stiff_str = stiff_str +
", K1-8"
else:
stiff_str =
"K1-8"
flg1 = 1
if Pbf>PwoPwi:
if flg or flg1!=0:
stiff_str = stiff_str +
", K1-9"
else:
stiff_str =
"K1-9"
stiff_str = stiff_str +
" (" + str(round((Pbf-PwoPwi)/36.0*1000)/1000) + " A36, " +
str(round((Pbf-PwoPwi)/50.0*1000)/1000) + " V50)"
form_script_variables()
dd_list = []
####################################################################################################################################
## Dialog
dlg1 = Dialog( "Column
stiffener/continuity plates and extended shear tabs" )
dlg1.tabset_begin()
dlg1.tab("Stiffener
Information")
dlg1.column_group_begin()
dlg1.column(0)
dlg1.group_title("Extended
shear tabs")
dlg1.menu( "add_shr_tab",
("Yes", "No"), add_shr_tab, "Add extended shear
tabs " )
dlg1.group_title_end
dlg1.group_title("General
Information")
dlg1.menu(
"add_stf_tb", ("Both", "Top", "Bott",
"None"), add_stf_tb, "Stiffeners at which beam flanges" )
dlg1.menu(
"which_side", ("BS", "NS", "FS"),
which_side, "Which side(s) of column web?" )
dlg1.menu(
"stiff_color", ("None", "Red Oxide", "Yellow
Zinc", "Gray Oxide", "Sandblasted", "Blued
Steel", "Galvanized"), stiff_color, "Stiffener finish"
)
dlg1.menu(
"stiff_grade", Job().steel_grades("Plate").keys(), stiff_grade,
"Select stiffener steel grade" )
dlg1.group_title_end
dlg1.group_title("Stiffener alignment")
dlg1.menu(
"top_align", ("Flush Top", "Flush Bott",
"Align CL", "Offset"), top_align, "Top stiffener
alignment")
dlg1.menu(
"bot_align", ("Flush Top", "Flush Bott",
"Align CL", "Offset", "Vert Dist"), bot_align,
"Bottom stiffener alignment")
dlg1.entry(
"top_offset", top_offset, "Top stiffener offset (+=UP)" )
dlg1.entry(
"bot_offset", bot_offset, "Bottom stiffener offset (-=DN)"
)
dlg1.menu(
"make_top_thicker", ("Yes", "No"),
make_top_thicker, "Make top stiffener thicker?" )
dlg1.entry(
"top_stiff_extra", top_stiff_extra, "Top stiffener extra
thickness" )
dlg1.group_title_end
dlg1.column(0)
dlg1.group_title("Member
Information")
dlg1.line("Column #"
+ str(ci + 1) + ", Beam #" + str(bi + 1))
dlg1.line(col_list[ci].size +
" at location " + dim_print(col_list[ci].left_location.x) + " ,
" + dim_print(col_list[ci].left_location.y) + " , " +\
dim_print(col_list[ci].left_location.z))
dlg1.line(bm_list[bi].size +
" at location " + dim_print(pt_WP.x) + " , " +
dim_print(pt_WP.y) + " , " + dim_print(pt_WP.z))
dlg1.group_title_end
dlg1.group_title("Stiffener Size Options")
dlg1.line("
dlg1.line("Stiffener size
Beam bf: " + stiff_width_bf + "x" + stiff_thk_bf)
dlg1.line("Stiffener size
Column A: " + stiff_width_A + "x" + stiff_thk_A)
dlg1.menu(
"which_stiff", ("Beam bf", "Column A",
"User"), which_stiff, "Select which stiffener size to
apply")
dlg1.group_title_end
dlg1.group_title("'User'
size stiffener dimensions")
dlg1.entry(
"stiff_width", stiff_width, "Stiffener width" )
dlg1.entry(
"stiff_thk", stiff_thk, "Stiffener thickness" )
dlg1.group_title_end
dlg1.group_title("Typical
stiffener dimensions")
dlg1.entry(
"stiff_length", stiff_length, "Stiffener length (typ.)" )
dlg1.entry(
"stiff_clip", stiff_clip, "Stiffener clip dimension (typ.)"
)
dlg1.group_title_end
dlg1.tab("Welding")
dlg1.group_title("Welding
for stiffener")
dlg1.menu(
"ad_stf_weld", ("Yes", "No"), ad_stf_weld,
"Add weld to stiffener" )
dlg1.menu(
"stf_weld_type", ("Fillet", "Square butt",
"Bevel groove"), stf_weld_type, "Weld type" )
dlg1.entry(
"stf_weld_size", stf_weld_size, "Stiffener weld size")
# dlg1.entry(
"tail_text", tail_text, "Tail text for stiffener weld")
dlg1.group_title_end
dlg1.tab("Code
Check")
dlg1.group_title("Code
check")
dlg1.group_title_end
dlg1.menu(
"prt_code_chk", ("Yes", "No"), prt_code_chk,
"Print
dlg1.image(image_name1)
dlg1.tabset_end()
try:
dd1 = dlg1.done()
except ResponseNotOK:
break
globals().update(dd1)
######################################################################################################################################
## END DIALOG
######################################################################################################################################
dd_list.append(dd1)
# determine stiffener
dimensions xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
if which_stiff == "Beam
bf":
stiff_width =
dim(stiff_width_bf)
stiff_thk = dim(stiff_thk_bf)
elif which_stiff ==
"Column A":
stiff_width =
dim(stiff_width_A)
stiff_thk =
dim(stiff_thk_A)
# Net area of specified
stiffeners xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
net_stf_area =
round((dim(stiff_width) - dim(stiff_clip)) * dim(stiff_thk) * 2.0 * 1000.0) /
1000.0
##
if prt_code_chk ==
"Yes":
stiff_reqd = "No"
print "Joint
No.", count
print "Column
size:", col_list[ci].size, col_list[ci].piecemark
print "Beam
size:", bm_list[bi].size, bm_list[bi].piecemark
print "Mr:", Mr,
" k-ft"
print "Flange
force:", Flg_force
print "Factored flange
force (Pbf):", Pbf
print "Flange bending
(Pfb):", Pfb
print "Web buckling
(Pwb):", Pwb
print "Web yielding
(PwoPwi):", PwoPwi
if Pbf>Pfb:
print "Stiffener
required per
stiff_reqd =
"Yes"
if Pbf>Pwb:
print "Stiffener
required per
stiff_reqd =
"Yes"
if Pbf>PwoPwi:
print "Stiffener
required per
print "Stiffener
area required per
print "Area of
default stiffeners (bf): (2)", stiff_width_bf, "x",
stiff_thk_bf, "=", net_stf_area_bf, "in2 (clip =",
stiff_clip, ")"
print "Area of
default stiffeners (A): (2)", stiff_width_A, "x", stiff_thk_A,
"=", net_stf_area_A, "in2 (clip =", stiff_clip,
")"
print "Area of
specified stiffeners: (2)", stiff_width, "x", stiff_thk,
"=", net_stf_area, "in2 (clip =", stiff_clip, ")"
stiff_reqd =
"Yes"
if stiff_reqd ==
"Yes":
print "Minimum
stiffener size =", round((bm_list[bi].bf/3.0 -
col_list[ci].tw/2.0)*1000)/1000, "x",
round(bm_list[bi].tf/2*1000)/1000
else:
print "Stiffeners
are not required."
print "\n"
## End
# Adjust thickness of top
stiffener if necessary
if make_top_thicker ==
"Yes":
stiff_thk_top = stiff_thk +
top_stiff_extra
else:
stiff_thk_top = stiff_thk
# Calculate member depth due to
slope
mem2_depth =
round(bm_list[bi].depth / cos(dtor(bm_list[bi].slope)) * 16.0) / 16.0
# Set work points for adding
stiffeners
if top_align == "Flush
Top":
pt_WP_top = pt_WP
elif top_align == "Flush
Bott":
pt_WP_top = pt_WP +
col_list[ci].translate(stiff_thk_top-bm_list[bi].tf, 0.0, 0.0)
elif top_align == "Align
CL":
pt_WP_top = pt_WP +
col_list[ci].translate(stiff_thk_top/2-bm_list[bi].tf/2, 0.0, 0.0)
elif top_align ==
"Offset":
pt_WP_top = pt_WP +
col_list[ci].translate(top_offset, 0.0, 0.0)
if bot_align == "Flush
Top":
pt_WP_bot = pt_WP +
col_list[ci].translate(-mem2_depth+bm_list[bi].tf-stiff_thk, 0.0, 0.0)
elif bot_align == "Flush
Bott":
pt_WP_bot = pt_WP +
col_list[ci].translate(-mem2_depth, 0.0, 0.0)
elif bot_align == "Align
CL":
pt_WP_bot = pt_WP + col_list[ci].translate(-mem2_depth+bm_list[bi].tf/2-stiff_thk/2,
0.0, 0.0)
elif bot_align ==
"Offset":
pt_WP_bot = pt_WP +
col_list[ci].translate(-mem2_depth+bot_offset, 0.0, 0.0)
elif bot_align == "Vert
Dist":
dlg3 = Dialog( "Bott
stiff vertical dist" )
dlg3.entry("vert_dist", dim_print(mem2_depth-stiff_thk),
"Enter vertical dist to top of bott stiff" )
try:
dd1 = dlg3.done()
except ResponseNotOK:
break
pt_WP_bot = pt_WP +
col_list[ci].translate(-dlg3.vert_dist-stiff_thk, 0.0, 0.0)
## Add stiffeners
##########################################################################
stf_mtrl_list_ns = []
stf_mtrl_list_fs = []
if add_stf_tb ==
"Top" or add_stf_tb == "Both":
if which_side ==
"NS" or which_side == "BS":
pt11 = pt_WP_top +
col_list[ci].translate(0.0, stiff_length / 2, col_list[ci].tw / 2)
pt12 = pt11 +
col_list[ci].translate(0.0, -stiff_length, 0.0)
rp11 =
stiff_pl(col_list[ci], pt11, pt12, stiff_thk_top,(-90.0, 0.0, -90.0))
stf_mtrl_list_ns.append(rp11)
if ad_stf_weld ==
"Yes" and make_top_thicker == "No":
stiff_weld([col_list[ci], ], rp11, stf_weld_size, stf_weld_type,
"")
if which_side ==
"FS" or which_side == "BS":
pt11 = pt_WP_top +
col_list[ci].translate(0.0, -stiff_length / 2, -col_list[ci].tw / 2)
pt12 = pt11 +
col_list[ci].translate(0.0, stiff_length, 0.0)
rp12 =
stiff_pl(col_list[ci], pt11, pt12, stiff_thk_top, (90.0, 0.0, 90.0))
stf_mtrl_list_fs.append(rp12)
if ad_stf_weld ==
"Yes" and make_top_thicker == "No":
stiff_weld([col_list[ci], ], rp12, stf_weld_size, stf_weld_type,
"")
if add_stf_tb ==
"Bott" or add_stf_tb == "Both":
if which_side ==
"NS" or which_side == "BS":
pt11 = pt_WP_bot +
col_list[ci].translate(0.0, -stiff_length / 2, col_list[ci].tw / 2)
pt12 = pt11 +
col_list[ci].translate(0.0, stiff_length, 0.0)
rp13 =
stiff_pl(col_list[ci], pt11, pt12, stiff_thk, (-90.0, 0.0, 90.0))
stf_mtrl_list_ns.append(rp13)
if ad_stf_weld ==
"Yes":
stiff_weld([col_list[ci], ], rp13,
stf_weld_size, stf_weld_type, "")
if which_side ==
"FS" or which_side == "BS":
pt11 = pt_WP_bot +
col_list[ci].translate(0.0, stiff_length / 2, -col_list[ci].tw / 2)
pt12 = pt11 +
col_list[ci].translate(0.0, -stiff_length, 0.0)
rp14 =
stiff_pl(col_list[ci], pt11, pt12, stiff_thk, (90.0, 0.0, -90.0))
stf_mtrl_list_fs.append(rp14)
if ad_stf_weld == "Yes":
stiff_weld([col_list[ci], ], rp14, stf_weld_size, stf_weld_type,
"")
## End add stiffeners
##########################################################################
## Add extended shear tab and
stabilizer plate #################################################
if add_shr_tab ==
"Yes":
counter = 0
mem3 =
MemberLocate("Add shear tab - Select beam member")
if mem3 != None:
if mem3.mtrl_type ==
"W flange":
if mem3.type !=
"Beam":
print "You
picked a " + mem3.type + ". You should have picked a beam."
pick_success =
0
else:
pick_success =
1
else:
print mem3.mtrl_type + " beam
material is not supported. "
pick_success = 0
else:
pick_success = 0
while pick_success == 1:
# Calculate WP at top
of beam and center of column 'pt_WP'
pt_WP = ret_WP(col_list[ci], mem3)[0]
if which_end ==
"left end":
matl_setback =
mem3.left.setback
else:
matl_setback =
mem3.right.setback
# set shear tab
variables
no_rows =
row_list(mem3.size)
end_ed =
dim_print(dim(bolt_size) * 2.0)
pl_width =
dim_print(round((matl_setback - col_list[ci].tw/2 + dim(end_ed)*2 +
(int(no_cols) - 1)*dim(col_spa) + 0.12) * 4.0) / 4.0)
form_script_variables2()
####################################################################################################################################
## Dialog
dlg2 = Dialog(
"Column connection assembly shear tab" )
dlg2.tabset_begin()
dlg2.tab("Shear
Tab Information")
dlg2.column_group_begin()
dlg2.column(0)
dlg2.group_title("Shear Tab Information" )
dlg2.menu("add_shear_tab",
("Yes", "No"), "Yes", "Add extended shear
tab ")
dlg2.menu("which_side_NS", ("Right",
"Left"), which_side_NS, "NS plate on which side of col CL")
dlg2.menu("which_side_FS", ("Right", "Left"),
which_side_FS, "FS plate on which side of col CL")
dlg2.menu("pl_grade",
Job().steel_grades("Plate").keys(), pl_grade, "Steel grade for
shear tab")
dlg2.menu("pl_color", ("None", "Red
Oxide", "Yellow Zinc", "Gray Oxide",
"Sandblasted", "Blued Steel", "Galvanized"),
pl_color, "Plate finish")
dlg2.group_title_end
dlg2.group_title("Shear Tab Dimensions")
dlg2.entry("dist_1st",
dist_1st, "Distance to first bolt row")
dlg2.entry("no_rows", int(no_rows), "Number of bolt
rows")
dlg2.entry("no_cols", int(no_cols), "Number of bolt
cols")
dlg2.entry("row_spa",
row_spa, "Bolt row spacing")
dlg2.entry("col_spa", col_spa, "Bolt column
spacing")
dlg2.entry("end_ed", end_ed, "End of matl to 1st bolt
column")
dlg2.entry("pl_thk", pl_thk, "Thickness of shear
plate")
dlg2.entry("pl_width", pl_width, "Width of shear
plate")
dlg2.entry("pl_end_gap", pl_end_gap, "End of matl to cope
edge")
dlg2.entry("vert_ed", vert_ed, "Cope vert E.D from
holes")
dlg2.entry("clip_dim", clip_dim, "Clip dimension")
dlg2.group_title_end
dlg2.group_title("Tab Depth Options")
dlg2.menu("full_part_depth", ("Full Depth",
"Partial Depth"), full_part_depth, "'Full' or 'Partial'
depth")
dlg2.line("If
'Partial Depth' is selected, 'Cope Bott' and \n'Clip Bott' will be disabled
automatically")
dlg2.group_title_end
dlg2.column(0)
dlg2.group_title("Member Information")
dlg2.line("Member
size: " + mem3.size + "
Piecemark: " + mem3.piecemark)
dlg2.line("Reaction Left end: " + "
%0.1f"%mem3.left.shear + " kips")
dlg2.line("Reaction Right end: " + "
%0.1f"%mem3.right.shear + " kips")
dlg2.group_title_end
dlg2.checkbutton("prep_list", ["Cope Top",
"Cope Bott", "Clip Top", "Clip Bott",
"None"], prep_list, "Shear plate end preparation" )
dlg2.group_title("Partial Depth Tab Stabilizer")
dlg2.menu("add_bott_stab", ("Yes", "No"),
add_bott_stab, "Add shear tab bottom edge stabalizer plate")
dlg2.line("Thickness will match shear tab thickness")
dlg2.entry("stab_width", stab_width, "Stabilizer plate
width")
dlg2.group_title("Bolt information")
dlg2.entry(
"bolt_size", bolt_size, "Enter bolt size")
dlg2.menu(
"hole_type_web", ("Standard Round", "Short Slot",
"Oversized Round", "Long Slot"), hole_type_web, "Hole
type in shear tab")
dlg2.menu(
"bolt_type_web", ("A325N", "A325SC",
"A307", "A490N"), bolt_type_web, "Bolt type in shear
tab")
dlg2.group_title_end
dlg2.group_title("Welding")
dlg2.entry(
"tab_weld_size", tab_weld_size, "Shear tab weld to column web
size")
dlg2.entry(
"tabstf_weld_size", tabstf_weld_size, "Shear tab weld to column
web size")
dlg2.menu(
"tab_weld_type", ("Fillet", "Square butt",
"Bevel groove"), tab_weld_type, "Shear tab weld type" )
dlg2.group_title_end
dlg2.tab("Image")
dlg2.image(image_name2)
try:
dd2 = dlg2.done()
except ResponseNotOK:
break
try:
prep_list =
dd2['prep_list']
except KeyError:
prep_list =
["None"]
Warning("Error
setting 'prep_list")
globals().update(dd2)
######################################################################################################################################
## END DIALOG
######################################################################################################################################
## Add extended shear tab
############################################################################################################
if add_shear_tab ==
"Yes":
stiff_oo =
pt_WP_top.dist(pt_WP_bot)
# determine whether
plate is NS or FS of column web
net_angle =
col_list[ci].rotation - mem3.plan_rotation
if which_end ==
"left end" and net_angle > 0.0 or which_end == "right
end" and net_angle < 0.0:
case_no =
"
rot_argument =
(-90.0, 0.0, 180.0)
webside_flg = 1
else:
case_no = "Case FS"
rot_argument =
(-90.0, 180.0, 0.0)
webside_flg =
-1
if case_no ==
"
if
which_side_NS == "Right":
y_off =
-mem3.tw/2
else:
y_off =
mem3.tw/2 + pl_thk
if case_no ==
"Case FS":
if
which_side_FS == "Left":
y_off =
mem3.tw/2
else:
y_off =
-mem3.tw/2 - pl_thk
dist_stf = pt_WP_top.z
- pt_WP.z + dist_1st
hole_dim_x =
dist_stf - stiff_thk_top
hole_dim_y =
matl_setback + end_ed - col_list[ci].tw/2
# Check to see if
plate is wide enough to accomodate the hole pattern
if (hole_dim_y +
(no_cols-1)*col_spa + 0.75) > pl_width:
Add_ch =
yes_or_no("Plate width will not accomodate hole pattern. Adjust?")
if Add_ch == 1:
#
Recalculate plate width
pl_width =
(round((matl_setback - col_list[ci].tw/2 + dim(end_ed)*2 + (no_cols -
1)*col_spa + 0.12) * 4.0) / 4.0)
# Calculate depth
(material length) of extended shear tab
if full_part_depth
== "Full Depth":
"""
if isinstance(stiff_oo, types.StringType):
print
"stiff_oo is a string"
elif
isinstance(stiff_thk_top, types.StringType):
print
"stiff_thk_top is a string"
elif
isinstance(stiff_thk, types.StringType):
print
"stiff_thk is a string"
"""
pl_length =
stiff_oo - stiff_thk_top - stiff_thk
else:
pl_length =
max(hole_dim_x + (no_rows-1)*row_spa + vert_ed, tab_length(mem3.size))
if "None"
in prep_list:
cope_top = 0
cope_bott = 0
clip_top = 0
clip_bott = 0
prep_list =
["None", ]
dd2['prep_list'] =
["None", ]
else:
if "Cope
Top" in prep_list:
cope_top =
[(dist_stf - vert_ed - stiff_thk_top), round((pl_width + col_list[ci].tw/2 -
matl_setback + pl_end_gap) * 4.0) / 4.0]
else:
cope_top =
0
if "Cope
Bott" in prep_list and full_part_depth == "Full Depth":
cope_bott = [(stiff_thk_top +
pl_length - dist_stf - (no_rows-1)*row_spa - vert_ed), \
round((pl_width + col_list[ci].tw/2 - matl_setback + pl_end_gap) * 4.0)
/ 4.0]
else:
cope_bott =
0
if "Clip
Top" in prep_list:
clip_top =
[clip_dim, clip_dim]
else:
clip_top = 0
if "Clip
Bott" in prep_list and full_part_depth == "Full Depth":
clip_bott =
[clip_dim, clip_dim]
else:
clip_bott = 0
# add extended
shear tabs, holes, and weld
pt11 = pt_WP_top +
col_list[ci].translate(-stiff_thk_top, y_off, webside_flg * col_list[ci].tw/2)
pt12 = pt11 +
col_list[ci].translate(-pl_length, 0.0, 0.0)
rp21 =
plate_add(col_list[ci], pt11, pt12, rot_argument)
pl_holes (rp21)
if add_bott_stab ==
"Yes" and full_part_depth == "Partial Depth":
if case_no ==
"
pt11 =
pt_WP_top + col_list[ci].translate(-(stiff_thk_top+pl_length+pl_thk),
stiff_length/2, col_list[ci].bf/2)
pt12 = pt11
+ col_list[ci].translate(stiff_length, 0.0, 0.0)
rp101 =
stabilizer_pl(col_list[ci], pt11, pt12, (90.0, 0.0, -90.0))
if ad_stf_weld ==
"Yes":
stiff_weld([col_list[ci], rp21], rp101, tabstf_weld_size, tab_weld_type,
"")
else:
pt11 =
pt_WP_top + col_list[ci].translate(-(stiff_thk_top+pl_length+pl_thk),
-stiff_length/2, -col_list[ci].bf/2)
pt12 = pt11
+ col_list[ci].translate(stiff_length, 0.0, 0.0)
rp101 =
stabilizer_pl(col_list[ci], pt11, pt12, (-90.0, 0.0, 90.0))
if
ad_stf_weld == "Yes":
stiff_weld([col_list[ci], rp21], rp101, tabstf_weld_size, tab_weld_type,
"")
if ad_stf_weld ==
"Yes":
if case_no ==
"
weld_mtrl_list = stf_mtrl_list_ns
else:
weld_mtrl_list
= stf_mtrl_list_fs
stiff_weld([col_list[ci], ], rp21, tab_weld_size, tab_weld_type,
"")
stiff_weld(weld_mtrl_list, rp21, tabstf_weld_size, tab_weld_type,
"")
counter = counter + 1
if counter == 1:
ad_opp_tab =
yes_or_no("Add same shear tab on opposite side of column web?")
if ad_opp_tab
== 1:
if case_no == "
case_no
= "Case FS"
rot_argument = (-90.0, 180.0, 0.0)
webside_flg = -1
else:
case_no
= "
rot_argument = (-90.0, 0.0, 180.0)
webside_flg = 1
y_off = y_off * -1
pt11 =
pt_WP_top + col_list[ci].translate(-stiff_thk_top, y_off, webside_flg *
col_list[ci].tw/2)
pt12 = pt11
+ col_list[ci].translate(-pl_length, 0.0, 0.0)
rp31 =
plate_add(col_list[ci], pt11, pt12, rot_argument)
pl_holes
(rp31)
if
add_bott_stab == "Yes":
if case_no
== "
pt11 = pt_WP_top +
col_list[ci].translate(-(stiff_thk_top+pl_length+pl_thk), stiff_length/2,
col_list[ci].bf/2)
pt12 = pt11 + col_list[ci].translate(stiff_length, 0.0, 0.0)
rp102 = stabilizer_pl(col_list[ci], pt11, pt12, (90.0, 0.0, -90.0))
if
ad_stf_weld == "Yes":
stiff_weld([col_list[ci], rp31], rp102, tabstf_weld_size, tab_weld_type,
"")
else:
pt11 = pt_WP_top +
col_list[ci].translate(-(stiff_thk_top+pl_length+pl_thk), -stiff_length/2,
-col_list[ci].bf/2)
pt12 = pt11 + col_list[ci].translate(stiff_length, 0.0, 0.0)
rp102 = stabilizer_pl(col_list[ci], pt11, pt12, (-90.0, 0.0, 90.0))
if ad_stf_weld ==
"Yes":
stiff_weld([col_list[ci], rp31], rp102, tabstf_weld_size, tab_weld_type,
"")
if case_no ==
"Case NS":
weld_mtrl_list = stf_mtrl_list_ns
else:
weld_mtrl_list = stf_mtrl_list_fs
stiff_weld([col_list[ci], ], rp31, tab_weld_size, tab_weld_type,
"")
stiff_weld(weld_mtrl_list, rp31, tabstf_weld_size, tab_weld_type,
"")
pick_success = 0
else:
mem3 =
MemberLocate("Add shear tab - Select opp. beam member")
if mem3 !=
None:
if mem3.mtrl_type == "W
flange":
if
mem3.type != "Beam":
print "You picked a " + mem3.type + ". You should have
picked a beam."
pick_success = 0
else:
pick_success = 1
else:
print
mem3.mtrl_type + " beam material is not supported. "
pick_success = 0
else:
pick_success = 0
else:
pick_success = 0
else:
pick_success = 0
# Export defaults to disk if enabled
try:
dd_list.append(dd2)
except:
dd_list.append({'prep_list':
prep_list, })
if enable_default_import_export ==
"Enable":
export_data(default_file_path +
def_file, dd_list, script_name)
Add_pls = yes_or_no("Add
additional column stiffeners/continuity plates?")
if Add_pls == 0:
break
except:
Warning(formatExceptionInfo(1))
break
# end script
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx