Back to SDS/2 Parametric Scripts

 

## PipeEndCap.py

## Copyright (c) 2006 Bruce Vaughan, BV Detailing & Design, Inc.

## All rights reserved.

## NOT FOR SALE. The software is provided "as is" without any warranty.

################################################################################

"""

Given a slotted pipe material object, add two plates each end to form end closures.

The pipe is a vertical brace, and the closure plates are on opposite sides of the gusset.

An optional galvanizing drain hole can be cut.

Arguments: member, which end, plate thickness, gusset thickness, drain hole radius, projection,\

           vertices outside radius, vertices inside radius, material grade, material finish

"""

from rect_plate import RectPlate

from mtrl_cut import MtrlCut

from point import Point, PointLocate

from job import Job

from shape import Shape

from member import Member

from math import sqrt

from macrolib.P3D import Plane3D

from macrolib.ExceptWarn import formatExceptionInfo

from macrolib.PolarPt import PolarPt3D

from macrolib.ptUtils import uv

from PrintPtList import formatPtList

 

def_grade = Job().steel_grades("Plate").keys()[0]

gusset_clearance = 0.125

 

class PipeEndCap(object):

    def __init__(self, mem, which_end='LE', thk=0.25, g_thk=0.75, dh_rad=1.5,\

                 proj=-0.125, vor=16, vir=12, grade=def_grade, finish='None'):

        # Add gusset clearance to gusset clearance

        g_thk += gusset_clearance

        m = mem.main_mtrl()

        self.mem = mem

        self.m = m

        self.we = which_end

        self.depth = mem.depth

        self.thk = thk

        self.g_thk = g_thk

        self.dh_rad = dh_rad

        self.proj = proj

        self.vor = vor

        self.vir = vir

        self.pt1 = m.pt1

        self.pt2 = m.pt1 + m.translate(m.work_pt_dist, 0.0, 0.0)

        self.ptWP1 = m.pt1 + m.translate(m.setback_left, 0.0, 0.0)

        self.ptWP2 = self.pt2 - m.translate(m.setback_right, 0.0, 0.0)

        self.grade = grade

        self.finish = finish

 

        self.radius = (mem.depth/2)+proj

        # Calculate the plate length

        self.mtrl_length = (sqrt(self.radius**2 - (g_thk/2)**2)) * 2.0

 

        self.set_WP()

        self.add_plate()

 

    def set_WP(self):

        # Calculate plate work points for each end, ns and fs

        self.pNLeft = self.ptWP1 + self.mem.translate(0.0, self.mtrl_length/2, self.g_thk/2)

        self.pFLeft = self.ptWP1 + self.mem.translate(0.0, -self.mtrl_length/2, -self.g_thk/2)

        self.pNRight = self.ptWP2 + self.mem.translate(0.0, -self.mtrl_length/2, self.g_thk/2)

        self.pFRight = self.ptWP2 + self.mem.translate(0.0, self.mtrl_length/2, -self.g_thk/2)

       

    def add_plate(self):

        # Plate rotations

        rNLeft = (-90.0, 0.0, -90.0)

        rFLeft = (90.0, 0.0, 90.0)

        rNRight = (-90.0, 0.0, 90.0)

        rFRight = (90.0, 0.0, -90.0)

 

        ##################################

        ## Add plates and make cut layouts

        if self.vir > 2 and self.dh_rad > self.g_thk/2:

            d = sqrt(self.dh_rad**2-(self.g_thk/2)**2)

            p11 = self.ptWP1 + self.mem.translate(0.0, -d, self.g_thk/2)

            p12 = self.ptWP1 + self.mem.translate(0.0, d, self.g_thk/2)

            p21 = self.ptWP1 + self.mem.translate(0.0, d, -self.g_thk/2)

            p22 = self.ptWP1 + self.mem.translate(0.0, -d, -self.g_thk/2)

 

        if self.we == 'LE':       

            # Left end NS

            rp = self.add_plate_mtrl(self.pNLeft, rNLeft)

            p1 = self.ptWP1 + self.mem.translate(0.0, -self.mtrl_length/2, self.g_thk/2)

            self.radius_cut(rp, Plane3D(self.ptWP1, p1, self.pNLeft), self.vor, "A")

            if self.vir > 2 and self.dh_rad > self.g_thk/2:

                self.radius_cut(rp, Plane3D(self.ptWP1, p11, p12), self.vir, "B")

 

            # Left end FS       

            rp = self.add_plate_mtrl(self.pFLeft, rFLeft)

            p2 = self.ptWP1 + self.mem.translate(0.0, self.mtrl_length/2, -self.g_thk/2)

            self.radius_cut(rp, Plane3D(self.ptWP1, p2, self.pFLeft), self.vor, "A")

            if self.vir > 2 and self.dh_rad > self.g_thk/2:

                self.radius_cut(rp, Plane3D(self.ptWP1, p21, p22), self.vir, "B")

        else:

            # Right end NS

            rp = self.add_plate_mtrl(self.pNRight, rNRight)

            p3 = self.ptWP2 + self.mem.translate(0.0, self.mtrl_length/2, self.g_thk/2)

            self.radius_cut(rp, Plane3D(self.ptWP2, p3, self.pNRight), self.vor, "A")

            if self.vir > 2 and self.dh_rad > self.g_thk/2:

                self.radius_cut(rp, Plane3D(self.ptWP1, p11, p12), self.vir, "B")

 

            # Right end FS

            rp = self.add_plate_mtrl(self.pFRight, rFRight)

            p4 = self.ptWP2 + self.mem.translate(0.0, -self.mtrl_length/2, -self.g_thk/2)

            self.radius_cut(rp, Plane3D(self.ptWP2, p4, self.pFRight), self.vor, "A")

            if self.vir > 2 and self.dh_rad > self.g_thk/2:

                self.radius_cut(rp, Plane3D(self.ptWP1, p21, p22), self.vir, "B")

 

    def add_plate_mtrl(self, p, r):

        # (mem, p, g, x, y, thk, fin, rot, ref_pt_off):

        # rectangular plate begin

        rp1 = RectPlate()

        rp1.member = self.mem

        rp1.pt1 = p

        rp1.pt2 = p + self.mem.translate(self.mtrl_length, 0.0, 0.0)

        rp1.grade = self.grade

        rp1.origin = "NS"

        rp1.top_oper_left = "None"

        rp1.top_length_left = 0.0

        rp1.top_clip_left = 0.0

        rp1.top_oper_right = "None"

        rp1.top_length_right = 0.0

        rp1.top_clip_right = 0.0

        rp1.bottom_oper_left = "None"

        rp1.bottom_oper_right = "None"

        rp1.width = self.radius-self.g_thk/2

        rp1.thick = self.thk

        rp1.work_pt_dist = self.mtrl_length

        rp1.setback_left = 0

        rp1.setback_right = 0

        rp1.web_cut_angle_left = 0

        rp1.web_cut_angle_right = 0

        rp1.length = self.mtrl_length

        rp1.mtrl_type = "Plate"

        rp1.finish = self.finish

        rp1.ref_pt_offset = (self.mtrl_length/2, self.g_thk/2)

        rp1.add()

        rp1.rotate(rp1.member, r)

        # rectangular plate end

        return rp1

 

    def radius_cut(self, rp, a, v, side="A"):

        """

        # rp is a material object

        # a is a Plane3D instance

        # v is the quantity of vertices

        # side ('A', 'B') is the flag to remove material above or below

        """

        ## Create points list

        # print a.p3, a.p2, PolarPt3D(a.p3, a.p2, 12.0)

        p2_beyond = PolarPt3D(a.p3, a.p2, 12.0)

        p3_beyond = PolarPt3D(a.p2, a.p3, 12.0)

        pt_list = [p2_beyond, a.p2, ]

 

        actual_spa = a.pp/(v)

        dst = actual_spa

        spaces = v-1

 

        # Compile a list of points determined by the angle required between construction lines

        for i in range(spaces):

            pt_list.append(a.PointRotate3D(a.p2, dst/a.Ra))

            dst = dst + actual_spa

               

        pt_list.append(a.PointRotate3D(a.p2, a.Q))

        pt_list.append(p3_beyond)

 

        p0_uv = uv(p3_beyond, p2_beyond)

       

        if side == 'B':

            p03 = p3_beyond + a.cross_product(p0_uv, a.N_uv)

            p02 = p2_beyond + a.cross_product(p0_uv, a.N_uv)

        else:

            p03 = p3_beyond - a.cross_product(p0_uv, a.N_uv)

            p02 = p2_beyond - a.cross_product(p0_uv, a.N_uv)

       

        pt_list.append(PolarPt3D(p3_beyond, p03, a.Ra+12.0))

        pt_list.append(PolarPt3D(p2_beyond, p02, a.Ra+12.0))

        pt_list.append(p2_beyond)

       

        # print formatPtList('Cut Layout Point List:', pt_list)

        ## Make radius cut to material object

        try:

        # mtrl cut begin

            mcut1 = MtrlCut()

            mcut1.mtrl = [rp, ]

            mcut1.rotate = (0,0,0)

            for pt in pt_list:

                mcut1.pts.append((pt, 0.0))

            mcut1.cut("Layout")

            return True

        except:

            Warning(formatExceptionInfo())

            return False

        # mtrl cut end