#   Add a cap plate that can be nonsymmetrical to the top of a column shaft.
#   Input the column with the desired minus dimension (top of cap plate)
#   and the material setback (bottom of cap plate) with desired web or flange cuts.
#   The plate x slope = web cut and y slope = flange cut. The script ignores the
#   flange cut bevel if the web cut bevel > 0.0. The distance the user enters to
#   locate each hole pattern is measured from the column center at the bottom of
#   the cap plate (enter positive x and y to locate in the desired quadrant).
#   The user must account for the resulting offset to the top of the cap plate
#   (if necessary) for a sloping cap plate.
#
#   The default plate thickness is (material setback - minus dimension) * cos(pl_slope).
#
#   You can input up to 4 hole patterns - ul, ur, ll, lr (ex. - ul = upper left
#   quadrant of cap plate when looking down at the column top end view).
#   Example: To add a 6 hole pattern (:::), select any quadrant, enter positive x and y
#   distances to the corner hole in the selected quadrant, enter 3 columns and 2 rows,
#   and enter positive column and row spacings (deselect all buttons for plain plate).
#   Entering negative column and row spacings takes the hole pattern away from the column.
#   All hole patterns use the same bolt diameter, hole size, etc. The reference point
#   for the hole patterns is the column center at the bottom of cap plate.
#
#   This script can be executed in plan, elevation, or isometric.
#
#   This source is provided "as is."  All warranties are disclaimed.
#   Developed in SDS2 6.314, Python 2.2.1 3/14/03
#   Tested in SDS/2 6.245
#   Developed by Bruce Vaughan, BV Detailing & Design, Inc. (BVD)  (615) 646-9239
#   For comments, suggestions or questions call BVD at the number above.
#
#   NOT FOR SALE
#   
#   This script executes a conditional statement on the version of SDS/2. Hole pattern
#   rotations in rectangular plates are different in SDS/2 6.3xx vs. 6.2xx.
#
#   R2 - Changed hole pattern rotation from -90 to 180 to work in SDS/2 version 6.323 and later
#   R3 - Changed rectangular plate reference point (line 148) to: rp1.ref_pt_offset = (pl_left, -pl_up, 0.0) # global variables pl_left, pl_up
#
#
#   Go to line 69 to set defaults for job to job variations.
#
# startup code begin
from param import *
Units("feet")
from shape import Shape
from point import *
from member import Member, MemberLocate
from mtrl_list import MtrlLocate
from cons_line import ConsLine
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 mtrl_fit import MtrlFit
# startup code end
from math import *
try:
    from version import *
except:
    pass
# Version module was added in SDS/2 6.311
# set defaults xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx :: : :: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
pl_left = 3.5                   # default distance to left plate edge
pl_right = 3.5                  # default distance to right plate edge
pl_up = 3.5                     # default distance to upper plate edge
pl_down = 3.5                   # default distance to lower plate edge

ul_x = 14.0                     # default upper left pattern x dimension
ul_y = 9.5                      # default upper left pattern y dimension
ul_cols = 2                     # default upper left pattern number of columns (x direction)
ul_rows = 2                     # default upper left pattern number of rows (y direction)
ul_spx = 5.5                    # default column spacing
ul_spy = 19.0                   # default row spacing

ll_x = 14.0                     # default lower left pattern x dimension
ll_y = 9.5                      # default lower left pattern y dimension
ll_cols = 2                     # default lower left pattern number of columns (x direction)
ll_rows = 2                     # default lower left pattern number of rows (y direction)
ll_spx = 5.5                    # default column spacing
ll_spy = 19.0                   # default row spacing

ur_x = 14.0                     # default upper right pattern x dimension
ur_y = 9.5                      # default upper right pattern y dimension
ur_cols = 2                     # default upper right pattern number of columns (x direction)
ur_rows = 2                     # default upper right pattern number of rows (y direction)
ur_spx = 5.5                    # default column spacing
ur_spy = 19.0                   # default row spacing

lr_x = 1.625                      # default lower right pattern x dimension
lr_y = 4.5                      # default lower right pattern y dimension
lr_cols = 2                     # default lower right pattern number of columns (x direction)
lr_rows = 1                     # default lower right pattern number of rows (y direction)
lr_spx = 3.25                    # default column spacing
lr_spy = 0.0                   # default row spacing

pl_color = "Yellow Zinc"        # default material color "Red Oxide", "Yellow Zinc", "Gray Oxide", "Sandblasted", "Blued Steel", "Galvanized", "Red Oxide 2", "undefined 2"
steelgrade = "A36"              # default steel grade
bolt_size = 0.5                 # default bolt diameter
hole_dia = 0.0                  # default hole diameter (enter 0.0 for SDS/2 to calculate hole diameter from hole type and bolt diameter)
hole_type = "Standard Round"    # default hole type "Standard Round" "Short Slot" "Oversized" "Long Slot" "Cope Hole" "Erection Pin Hole" "Anchor Bolt Hole" "Plug Weld Hole"
bolt_type = "A307"             # default bolt type "Auto" "A325N" "A325SC" "A307"
ad_pl_weld = "Yes"              # default for adding seat weld       "Yes" "No"
pl_weld_type = "Fillet"         # default for weld type "Fillet" "Bevel groove"
weld_size = "3/16"              # default weld size
weld_around = "Yes"             # default weld all around "No" "Yes"
patt_list = ["None"]              # default pattern quadrant "UL" "LL" "UR" "LR"
# default end xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# convert radians to degrees
def rtod ( r ):
    return (r * 180.0 / pi)
# convert degrees to radians
def dtor ( d ):
    return (d * pi / 180.0)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# add a plate
# ref_pt is the center of the column
# returns a rectangular plate object
def plate_add(col, ref_pt, pnt1, pnt2, pl_width, pl_thk, pl_length, pl_grade, pl_color, rot1, pl_slope):
    rot_arg = ((rot1[0]), (rot1[1]), rot1[2] - pl_slope)
    # rectangular plate begin
    rp1 = RectPlate()
    rp1.member = col
    rp1.pt1 = pnt1
    rp1.pt2 = pnt2
    rp1.grade = pl_grade
    rp1.origin = "FS"
    rp1.top_oper_left = "None"
    rp1.top_oper_right = "None"
    rp1.bottom_oper_left = "None"
    rp1.bottom_oper_right = "None"
    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.finish = pl_color
    rp1.ref_pt_offset = (pl_left, -pl_up, 0.0) # global variables pl_left, pl_up
    rp1.add()
    rp1.rotate(rp1.member, rot_arg)
    # rectangular plate end
    return rp1
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# begin definition of hole pattern add function xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
def bp_hole (rect_pl, hl_ref_pt, hl_face, x_off, y_off, bd, hs, ht, bt, quadrant, no_x, no_y, spa_x, spa_y):
    try:
        c_ver = VersionCompare(CurrentVersion(), "6.312")
    except:
        c_ver = 0
    if c_ver > 0:
        rot_patt = 180.0
    else:
        rot_patt = 0.0
    if quadrant == "UL":
        hl_patt = "Below Right"
    elif quadrant == "LL":
        hl_patt = "Above Right"
    elif quadrant == "UR":
        hl_patt = "Below Left"
    elif quadrant == "LR":
        hl_patt = "Above Left"
    else:
        print "Something is wrong with pattern"
    if hs:
        str = "hs"
    else:        
        str = "hole26.calc_hole_size()"
    try:
        # hole group add begin
        hole26 = Hole()
        hole26.mtrl = [rect_pl, ]
        hole26.pt1 = hl_ref_pt
        hole26.hole_type = ht
        hole26.face = hl_face
        hole26.valid_cnc = "Yes"
        hole26.x_ref_offset = x_off
        hole26.y_ref_offset = y_off
        hole26.x_spa = spa_x
        hole26.y_spa = spa_y
        hole26.group_rot = rot_patt
        hole26.locate = hl_patt
        hole26.columns = no_x
        hole26.rows = no_y
        hole26.bolt_type = bt
        hole26.bolt_dia = bd
        hole26.slot_rot = 0.0
        hole26.length = hole26.calc_slot_length()
        hole26.hole_dia = eval(str)
        hole26.show_window = "Yes"
        hole26.create()
        # hole group add end
    except:
        pass
        print "The " + quadrant + " hole pattern you entered could not be added."
# end function definition xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
def cap_pl_weld(col, rl5, weld_size, weld_type, around):
    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"
    # weld add begin
    weld9 = Weld()
    weld9.mtrl =  [rl5, ]
    weld9.weld_to = [col, ]
    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 = around
    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
#######################################################################
while 1:
    Add_pls = yes_or_no("Add a nonsymmetrical cap plate to a column?")
    if Add_pls == 0:
        break
    mem1 = MemberLocate("Select a column member")
    if mem1.type != "Column":
        print "You picked a " + mem1.type + ". Run the script again."
        break
    if not hole_dia:
        hole_dia = 0.0
    if not patt_list:
        patt_list = ["None"]
    pl_left = dim_print(pl_left)
    pl_right = dim_print(pl_right)
    pl_up = dim_print(pl_up)
    pl_down = dim_print(pl_down)
    bolt_size = dim_print(bolt_size)
    hole_dia = dim_print(hole_dia)
    pl_slope_flg = round(mem1.right.flange_cut_angle * 10000) / 10000
    pl_slope_web = round(mem1.right.web_cut_angle * 10000) / 10000
    pl_thk = dim_print(abs(mem1.right.setback - mem1.right.minus_dim) * cos(dtor(pl_slope_web)))
    if abs(pl_slope_flg) > 0.0 and pl_slope_web == 0.0:
        pl_thk = dim_print(abs(mem1.right.setback - mem1.right.minus_dim) * cos(dtor(pl_slope_flg)))
    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    # xxxxxxxxx new dialog boxes start xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
    #  dialog 1 ( "title" )xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    dlg1 = Dialog( "Add a nonsymmetrical cap plate to a column" )
    dlg1.line("Column (" + mem1.piecemark + ", " + mem1.section_size + ") plan rotation: " + "%0.4f"%mem1.rotation)
    dlg1.checkbutton("patt_list", ["UL", "LL", "UR", "LR", "None"], patt_list, "Select pattern quadrant(s)" )
    dlg1.line("Cap plate information" )
    dlg1.entry("pl_thk", pl_thk, "Cap plate thickness")
    dlg1.entry("pl_left", pl_left, "Plate dimension left")
    dlg1.entry("pl_right", pl_right, "Plate dimension right")
    dlg1.entry("pl_up", pl_up, "Plate dimension up")
    dlg1.entry("pl_down", pl_down, "Plate dimension down")
    dlg1.menu("steelgrade", ("A36", "A572-50"), steelgrade, "Select plate steel grade")
    dlg1.menu("pl_color", ("Red Oxide", "Yellow Zinc", "Gray Oxide", "Sandblasted", "Blued Steel", "Galvanized", "Red Oxide 2", "undefined 2"), pl_color, "Select plate color" )
    dlg1.line("Bolt and hole information" )
    dlg1.entry("bolt_size", bolt_size, "Bolt size")
    dlg1.entry("hole_dia", hole_dia, "Hole diameter (0 for calculate)")
    dlg1.menu("hole_type", ("Standard Round", "Short Slot", "Oversized", "Long Slot", "Cope Hole", "Erection Pin Hole", "Anchor Bolt Hole", "Plug Weld Hole"), hole_type, "Hole type")
    dlg1.menu("bolt_type", ("Auto", "A325N", "A325SC", "A307"), bolt_type, "Bolt type")
    dlg1.line("Welding information" )
    dlg1.menu( "ad_pl_weld", ("Yes", "No"), ad_pl_weld, "Add cap plate to column weld?" )
    dlg1.menu( "pl_weld_type", ("Fillet", "Square butt", "Bevel groove"), pl_weld_type, "Select weld type" )
    dlg1.entry( "weld_size", weld_size, "Enter weld size")
    dlg1.menu("weld_around", ("Yes", "No"), weld_around, "Weld all around?")

    try:
        dd1 = dlg1.done()
    except ResponseNotOK:
        break
    globals().update(dd1)
    try:
        patt_list = dd1['patt_list']
        if "None" in patt_list:
            patt_list = 0
    except KeyError:
        patt_list = 0
## ADD CAP PLATE ########################################################################################################
    pt11 = mem1.right_location
    pt21 = pt11 + mem1.translate(-mem1.right.setback - pl_left * sin(dtor(pl_slope_web)), pl_left * cos(dtor(pl_slope_web)), -pl_up)
    pt22 = pt21 + mem1.translate((pl_left + pl_right) * sin(dtor(pl_slope_web)), (pl_left + pl_right) * cos(dtor(pl_slope_web)), 0.0)
    pt23 = pt11 + mem1.translate(mem1.right.setback, 0.0, 0.0)
    rot_pl = (-90.0, 0.0, -90.0 + pl_slope_web)
    if abs(pl_slope_flg) > 0.0 and pl_slope_web == 0.0:
        pt21 = pt11 + mem1.translate(-mem1.right.setback - pl_up * sin(dtor(pl_slope_flg)), pl_left, -pl_up * cos(dtor(pl_slope_flg)))
        pt22 = pt21 + mem1.translate(0.0, pl_left + pl_right, 0.0)
        rot_pl = (-90.0 - pl_slope_flg, 0.0, -90.0)
    rp1 = plate_add(mem1, pt23, pt21, pt22, (pl_up + pl_down), pl_thk, (pl_left + pl_right), steelgrade, pl_color, rot_pl, 0.0)
##########################################################################################################################
    if patt_list:
        if "UL" in patt_list:
            ul_x = dim_print(ul_x)
            ul_y = dim_print(ul_y)
            ul_spx = dim_print(ul_spx)
            ul_spy = dim_print(ul_spy)
            dlg2 = Dialog("Upper left hole pattern")
            dlg2.line("Upper left pattern information" )
            dlg2.line("X and Y dims. locate corner hole.")
            dlg2.line("Enter positive col. and row spacings for pattern to go toward column.")
            dlg2.line("Cap plate UL location: " + dim_print(pl_left) + ", " + dim_print(pl_up) + "   Size:  " + dim_print((pl_left + pl_right)) + " x " + dim_print((pl_up + pl_down)))
            dlg2.entry("ul_x", ul_x, "X dimension")
            dlg2.entry("ul_y", ul_y, "Y dimension")
            dlg2.entry("ul_cols", ul_cols, "Number of columns (x dir)")
            dlg2.entry("ul_rows", ul_rows, "Number of rows (y dir)")
            dlg2.entry("ul_spx", ul_spx, "Column spacing")
            dlg2.entry("ul_spy", ul_spy, "Row spacing")
            try:
                dd2 = dlg2.done()
            except ResponseNotOK:
                break
            globals().update(dd2)
        if "LL" in patt_list:
            ll_x = dim_print(ll_x)
            ll_y = dim_print(ll_y)
            ll_spx = dim_print(ll_spx)
            ll_spy = dim_print(ll_spy)
            dlg3 = Dialog("Lower left hole pattern")
            dlg3.line("Lower left pattern information" )
            dlg3.line("X and Y dims. locate corner hole.")
            dlg3.line("Enter positive col. and row spacings for pattern to go toward column.")
            dlg3.line("Cap plate LL location: " + dim_print(pl_left) + ", " + dim_print(pl_down) + "   Size:  " + dim_print((pl_left + pl_right)) + " x " + dim_print((pl_up + pl_down)))
            dlg3.entry("ll_x", ll_x, "X dimension")
            dlg3.entry("ll_y", ll_y, "Y dimension")
            dlg3.entry("ll_cols", ll_cols, "Number of columns (x dir)")
            dlg3.entry("ll_rows", ll_rows, "Number of rows (y dir)")
            dlg3.entry("ll_spx", ll_spx, "Column spacing")
            dlg3.entry("ll_spy", ll_spy, "Row spacing")
            try:
                dd3 = dlg3.done()
            except ResponseNotOK:
                break
            globals().update(dd3)
        if "UR" in patt_list:
            ur_x = dim_print(ur_x)
            ur_y = dim_print(ur_y)
            ur_spx = dim_print(ur_spx)
            ur_spy = dim_print(ur_spy)
            dlg4 = Dialog("Upper right hole pattern")
            dlg4.line("Upper right pattern information" )
            dlg4.line("X and Y dims. locate corner hole.")
            dlg4.line("Enter positive col. and row spacings for pattern to go toward column.")
            dlg4.line("Cap plate UR location: " + dim_print(pl_right) + ", " + dim_print(pl_up) + "   Size:  " + dim_print((pl_left + pl_right)) + " x " + dim_print((pl_up + pl_down)))
            dlg4.entry("ur_x", ur_x, "X dimension")
            dlg4.entry("ur_y", ur_y, "Y dimension")
            dlg4.entry("ur_cols", ur_cols, "Number of columns (x dir)")  
            dlg4.entry("ur_rows", ur_rows, "Number of rows (y dir)")
            dlg4.entry("ur_spx", ur_spx, "Column spacing")
            dlg4.entry("ur_spy", ur_spy, "Row spacing")
            try:
                dd4 = dlg4.done()
            except ResponseNotOK:
                break
            globals().update(dd4)
        if "LR" in patt_list:
            lr_x = dim_print(lr_x)
            lr_y = dim_print(lr_y)
            lr_spx = dim_print(lr_spx)
            lr_spy = dim_print(lr_spy)
            dlg5 = Dialog("Lower right hole pattern")
            dlg5.line("Lower right pattern information" )
            dlg5.line("X and Y dims. locate corner hole.")
            dlg5.line("Enter positive col. and row spacings for pattern to go toward column.")
            dlg5.line("Cap plate LR location: " + dim_print(pl_right) + ", " + dim_print(pl_down) + "   Size:  " + dim_print((pl_left + pl_right)) + " x " + dim_print((pl_up + pl_down)))
            dlg5.entry("lr_x", lr_x, "X dimension")
            dlg5.entry("lr_y", lr_y, "Y dimension")
            dlg5.entry("lr_cols", lr_cols, "Number of columns (x dir)")       
            dlg5.entry("lr_rows", lr_rows, "Number of rows (y dir)")
            dlg5.entry("lr_spx", lr_spx, "Column spacing")        
            dlg5.entry("lr_spy", lr_spy, "Row spacing")
            try:
                dd5 = dlg5.done()
            except ResponseNotOK:
                break
            globals().update(dd5)
    # xxxxxxxxx end of hole pattern dialog boxes xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    if patt_list:
        if "UL" in patt_list:
            bp_hole (rp1, pt23, "NS Face", ul_x, ul_y, bolt_size, hole_dia, hole_type, bolt_type, "UL", ul_cols, ul_rows, -ul_spx, -ul_spy)
        if "LL" in patt_list:
            bp_hole (rp1, pt23, "NS Face", ll_x, ll_y, bolt_size, hole_dia, hole_type, bolt_type, "LL", ll_cols, ll_rows, -ll_spx, -ll_spy)
        if "UR" in patt_list:
            bp_hole (rp1, pt23, "NS Face", ur_x, ur_y, bolt_size, hole_dia, hole_type, bolt_type, "UR", ur_cols, ur_rows, -ur_spx, -ur_spy)
        if "LR" in patt_list:
            bp_hole (rp1, pt23, "NS Face", lr_x, lr_y, bolt_size, hole_dia, hole_type, bolt_type, "LR", lr_cols, lr_rows, -lr_spx, -lr_spy)
    if ad_pl_weld == "Yes":
        cap_pl_weld(mem1, rp1, weld_size, pl_weld_type, weld_around)
# end script xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx