コード例 #1
0
 def initialiseNutBolts(self):
     b = self.bolt
     n = self.nut
     for i in range(self.row * self.col):
         bolt_len_required = float(b.T + self.sgap)
         b.H = bolt_len_required + (5 - bolt_len_required) % 5
         self.bolts.append(Bolt(b.R,b.T, b.H, b.r))
         self.nuts.append(Nut(n.R, n.T,n.H, n.r1))
     
     for i in range(self.brow * self.bcol):
         bolt_len_required = float(b.T + self.sbgap)
         b.H = bolt_len_required + (5 - bolt_len_required) % 5
         self.bbolts.append(Bolt(b.R,b.T, b.H, b.r))
         self.bnuts.append(Nut(n.R, n.T,n.H, n.r1))
         
     for i in range(self.topcliprow * self.topclipcol):
         bolt_len_required= float(b.T + self.tgap)
         b.H = bolt_len_required + (5 - bolt_len_required) % 5
         self.topclipbolts.append(Bolt(b.R,b.T, b.H, b.r))
         self.topclipnuts.append(Nut(n.R, n.T,n.H, n.r1))
     
     for i in range(self.topclipbrow * self.topclipbcol):
         bolt_len_required = float(b.T + self.tbgap)
         b.H = bolt_len_required + (5 - bolt_len_required) % 5
         self.topclipbbolts.append(Bolt(b.R,b.T, b.H, b.r))
         self.topclipbnuts.append(Nut(n.R, n.T,n.H, n.r1))
コード例 #2
0
 def initialise_nut_bolts(self):
     b = self.bolt
     n = self.nut
     for i in range(self.row * self.col):
         bolt_len_required = float(b.T + self.gap)
         b.H = bolt_len_required + (5 - bolt_len_required) % 5
         self.bolts.append(Bolt(b.R, b.T, b.H, b.r))
         self.nuts.append(Nut(n.R, n.T, n.H, n.r1))
     for i in range(self.row * self.col):
         bolt_len_required = float(b.T + self.gap)
         b.H = bolt_len_required + (5 - bolt_len_required) % 5
         self.bolts1.append(Bolt(b.R, b.T, b.H, b.r))
         self.nuts1.append(Nut(n.R, n.T, n.H, n.r1))
コード例 #3
0
 def initialiseNutBolts_BF(self):
     '''
     :return: This initializes required number of bolts and nuts for below flange. 
     '''
     b_BF = self.bolt
     n_BF = self.nut
     for j in range(self.numOfboltsF):
         bolt_length_required = float(b_BF.T + self.nutSpaceF)
         b_BF.H = 1.5 * bolt_length_required
         self.bolts_BF.append(Bolt(b_BF.R, b_BF.T, b_BF.H, b_BF.r))
         self.nuts_BF.append(Nut(n_BF.R, n_BF.T, n_BF.H, n_BF.r1))
コード例 #4
0
 def initialiseNutBolts(self):
     '''
     Initialise the Nut and Bolt 
     '''
     b = self.bolt
     n = self.nut
     for i in range(self.numOfBolts):
         bolt_length_required = float(b.T + self.gap)  #
         b.H = bolt_length_required + (bolt_length_required - 5) % 5
         self.bolts.append(Bolt(b.R, b.T, b.H, b.r))
         self.nuts.append(Nut(n.R, n.T, n.H, n.r1))
コード例 #5
0
 def initialiseNutBolts_Web(self):
     '''
     :return: This initializes required number of bolts and nuts for web bolting. 
     '''
     b_W = self.bolt
     n_W = self.nut
     for k in range(self.numOfboltsW):
         bolt_length_required = float(b_W.T + self.nutSpaceW)
         b_W.H = 1.5 * bolt_length_required
         self.bolts_W.append(Bolt(b_W.R, b_W.T, b_W.H, b_W.r))
         self.nuts_W.append(Nut(n_W.R, n_W.T, n_W.H, n_W.r1))
コード例 #6
0
 def initialiseNutBolts(self):
     '''
     Initializing the Nut and Bolt
     '''
     b = self.bolt
     n = self.nut
     for i in range(self.row * self.col):
         bolt_len_required = float(b.T + self.gap)
         b.H = bolt_len_required + (5 - bolt_len_required) % 5
         self.bolts.append(Bolt(b.R, b.T, b.H, b.r))
         self.nuts.append(Nut(n.R, n.T, n.H, n.r1))
コード例 #7
0
ファイル: common_logic.py プロジェクト: yash-lokhande/Osdag
    def create3DColFlangeBeamWeb(self):
        '''
        Creating 3d cad model with column flange beam web connection

        '''
        ##### BEAM PARAMETERS #####
        beam_D = int(self.dictbeamdata["D"])
        beam_B = int(self.dictbeamdata["B"])
        beam_tw = float(self.dictbeamdata["tw"])
        beam_T = float(self.dictbeamdata["T"])
        beam_alpha = float(self.dictbeamdata["FlangeSlope"])
        beam_R1 = float(self.dictbeamdata["R1"])
        beam_R2 = float(self.dictbeamdata["R2"])
        beam_length = 500.0  # This parameter as per view of 3D cad model

        # beam = ISectionold(B = 140, T = 16,D = 400,t = 8.9, R1 = 14, R2 = 7, alpha = 98,length = 500)
        beam = ISection(B=beam_B,
                        T=beam_T,
                        D=beam_D,
                        t=beam_tw,
                        R1=beam_R1,
                        R2=beam_R2,
                        alpha=beam_alpha,
                        length=beam_length,
                        notchObj=None)

        ##### COLUMN PARAMETERS ######

        column_D = int(self.dictcoldata["D"])
        column_B = int(self.dictcoldata["B"])
        column_tw = float(self.dictcoldata["tw"])
        column_T = float(self.dictcoldata["T"])
        column_alpha = float(self.dictcoldata["FlangeSlope"])
        column_R1 = float(self.dictcoldata["R1"])
        column_R2 = float(self.dictcoldata["R2"])

        column = ISection(B=column_B,
                          T=column_T,
                          D=column_D,
                          t=column_tw,
                          R1=column_R1,
                          R2=column_R2,
                          alpha=column_alpha,
                          length=1000,
                          notchObj=None)

        #### WELD,PLATE,BOLT AND NUT PARAMETERS #####
        if self.connection == "cleatAngle":
            cleat_length = self.resultObj['cleat']['height']
            cleat_thick = float(self.dictangledata["t"])
            seat_legsizes = str(self.dictangledata["AXB"])
            angle_A = int(seat_legsizes.split('x')[0])
            angle_B = int(seat_legsizes.split('x')[1])
            angle_r1 = float(str(self.dictangledata["R1"]))
            angle_r2 = float(str(self.dictangledata["R2"]))

        elif self.connection == 'SeatedAngle':
            seat_length = self.resultObj['SeatAngle']['Length (mm)']
            seat_thick = float(self.dictangledata["t"])
            seat_legsizes = str(self.dictangledata["AXB"])
            seatangle_A = int(seat_legsizes.split('x')[0])
            seatangle_B = int(seat_legsizes.split('x')[1])
            seatangle_r1 = float(str(self.dictangledata["R1"]))
            seatangle_r2 = float(str(self.dictangledata["R2"]))

            topangle_length = self.resultObj['SeatAngle']['Length (mm)']
            topangle_thick = float(self.dicttopangledata["t"])
            top_legsizes = str(self.dicttopangledata["AXB"])
            topangle_A = int(top_legsizes.split('x')[0])
            topangle_B = int(top_legsizes.split('x')[1])
            topangle_r1 = float(str(self.dicttopangledata["R1"]))
            topangle_r2 = float(str(self.dicttopangledata["R2"]))

        else:
            fillet_length = self.resultObj['Plate']['height']
            fillet_thickness = str(self.uiObj['Weld']['Size (mm)'])
            # ---------------- fillet_thickness = self.resultObj['Weld']['thickness']
            plate_width = self.resultObj['Plate']['width']
            plate_thick = str(self.uiObj['Plate']['Thickness (mm)'])

        bolt_dia = str(self.uiObj["Bolt"]["Diameter (mm)"])
        bolt_r = (float(bolt_dia) / 2)
        bolt_R = self.bolt_R
        # bolt_R = bolt_r + 7
        nut_R = bolt_R
        bolt_T = self.bolt_T
        bolt_Ht = self.bolt_Ht
        nut_T = self.nut_T
        nut_Ht = 12.2  #
        gap = float(str(self.uiObj['detailing']['gap']))

        if self.connection == "cleatAngle":
            angle = Angle(L=cleat_length,
                          A=angle_A,
                          B=angle_B,
                          T=cleat_thick,
                          R1=angle_r1,
                          R2=angle_r2)
            #bolt_len_required = float(bolt_T + 2 * (cleat_thick) + beam_tw + nut_T)
        elif self.connection == 'SeatedAngle':
            seatangle = Angle(L=seat_length,
                              A=seatangle_A,
                              B=seatangle_B,
                              T=seat_thick,
                              R1=seatangle_r1,
                              R2=seatangle_r2)
            #bolt_len_required = float(bolt_T + (seat_thick) + beam_tw + nut_T)
            topclipangle = Angle(L=topangle_length,
                                 A=topangle_A,
                                 B=topangle_B,
                                 T=topangle_thick,
                                 R1=topangle_r1,
                                 R2=topangle_r2)
        else:
            # plate = Plate(L= 300,W =100, T = 10)
            plate = Plate(L=fillet_length, W=plate_width, T=int(plate_thick))

            # Fweld1 = FilletWeld(L= 300,b = 6, h = 6)
            Fweld1 = FilletWeld(L=fillet_length,
                                b=int(fillet_thickness),
                                h=int(fillet_thickness))

        # bolt = Bolt(R = bolt_R,T = bolt_T, H = 38.0, r = 4.0 )
        bolt = Bolt(R=bolt_R, T=bolt_T, H=bolt_Ht, r=bolt_r)

        # nut =Nut(R = bolt_R, T = 10.0,  H = 11, innerR1 = 4.0, outerR2 = 8.3)
        nut = Nut(R=bolt_R, T=nut_T, H=nut_Ht, innerR1=bolt_r)

        if self.connection == "Finplate":
            nut_space = beam_tw + int(plate_thick) + nut_T
            nutBoltArray = finNutBoltArray(self.resultObj, nut, bolt,
                                           nut_space)  # finColFlangeBeamWeb
            colflangeconn = finColFlangeBeamWeb(column, beam, Fweld1, plate,
                                                nutBoltArray, gap)

        elif self.connection == "Endplate":
            nut_space = column_T + int(plate_thick) + nut_T
            nutBoltArray = endNutBoltArray(self.resultObj, nut, bolt,
                                           nut_space)
            colflangeconn = endColFlangeBeamWeb(column, beam, Fweld1, plate,
                                                nutBoltArray)

        elif self.connection == "cleatAngle":
            nut_space = beam_tw + 2 * cleat_thick + nut_T
            cnut_space = column_T + cleat_thick + nut_T
            nut_bolt_array = cleatNutBoltArray(self.resultObj, nut, bolt,
                                               nut_space, cnut_space)
            colflangeconn = cleatColFlangeBeamWeb(column, beam, angle,
                                                  nut_bolt_array, gap)
        else:
            snut_space = column_T + seat_thick + nut_T
            sbnut_space = beam_T + seat_thick + nut_T
            tnut_space = beam_T + topangle_thick + nut_T
            tbnut_space = column_T + topangle_thick + nut_T

            nutBoltArray = seatNutBoltArray(self.resultObj, nut, bolt,
                                            snut_space, sbnut_space,
                                            tnut_space, tbnut_space)
            colflangeconn = seatColFlangeBeamWeb(column, beam, seatangle,
                                                 topclipangle, nutBoltArray,
                                                 gap)

        colflangeconn.create_3dmodel()
        return colflangeconn
コード例 #8
0
ファイル: common_logic.py プロジェクト: yash-lokhande/Osdag
    def create3DBeamWebBeamWeb(self):
        '''self,uiObj,resultObj,dictbeamdata,dictcoldata):
        creating 3d cad model with beam web beam web

        '''
        ##### PRIMARY BEAM PARAMETERS #####
        pBeam_D = int(self.dictcoldata["D"])
        pBeam_B = int(self.dictcoldata["B"])
        pBeam_tw = float(self.dictcoldata["tw"])
        pBeam_T = float(self.dictcoldata["T"])
        pBeam_alpha = float(self.dictcoldata["FlangeSlope"])
        pBeam_R1 = float(self.dictcoldata["R1"])
        pBeam_R2 = float(self.dictcoldata["R2"])
        pBeam_length = 800.0  # This parameter as per view of 3D cad model

        # beam = ISectionold(B = 140, T = 16,D = 400,t = 8.9, R1 = 14, R2 = 7, alpha = 98,length = 500)
        column = ISection(B=pBeam_B,
                          T=pBeam_T,
                          D=pBeam_D,
                          t=pBeam_tw,
                          R1=pBeam_R1,
                          R2=pBeam_R2,
                          alpha=pBeam_alpha,
                          length=pBeam_length,
                          notchObj=None)

        ##### SECONDARY BEAM PARAMETERS ######

        sBeam_D = int(self.dictbeamdata["D"])
        sBeam_B = int(self.dictbeamdata["B"])
        sBeam_tw = float(self.dictbeamdata["tw"])
        sBeam_T = float(self.dictbeamdata["T"])
        sBeam_alpha = float(self.dictbeamdata["FlangeSlope"])
        sBeam_R1 = float(self.dictbeamdata["R1"])
        sBeam_R2 = float(self.dictbeamdata["R2"])
        #cleardist = float(self.uiObj['detailing']['gap'])

        if self.connection == "cleatAngle":
            cleat_length = self.resultObj['cleat']['height']
            cleat_thick = float(self.dictangledata["t"])
            cleat_legsizes = str(self.dictangledata["AXB"])
            angle_A = int(cleat_legsizes.split('x')[0])
            angle_B = int(cleat_legsizes.split('x')[1])
            angle_r1 = float(str(self.dictangledata["R1"]))
            angle_r2 = float(str(self.dictangledata["R2"]))
        else:
            plate_thick = float(self.uiObj['Plate']['Thickness (mm)'])
            fillet_length = float(self.resultObj['Plate']['height'])
            fillet_thickness = float(self.uiObj["Weld"]['Size (mm)'])
            plate_width = float(self.resultObj['Plate']['width'])

        bolt_dia = int(self.uiObj["Bolt"]["Diameter (mm)"])
        bolt_r = bolt_dia / 2
        bolt_R = self.bolt_R
        nut_R = bolt_R
        bolt_T = self.bolt_T
        bolt_Ht = self.bolt_Ht
        nut_T = self.nut_T
        nut_Ht = 12.2  # 150
        gap = self.uiObj['detailing']['gap']
        notch_height = self.get_notch_ht(pBeam_T, sBeam_T, pBeam_R1, sBeam_R1)
        notch_R1 = max([pBeam_R1, sBeam_R1, 10])

        if self.connection == "cleatAngle":
            angle = Angle(L=cleat_length,
                          A=angle_A,
                          B=angle_B,
                          T=cleat_thick,
                          R1=angle_r1,
                          R2=angle_r2)
        else:
            plate = Plate(L=fillet_length, W=plate_width, T=plate_thick)
            Fweld1 = FilletWeld(L=fillet_length,
                                b=fillet_thickness,
                                h=fillet_thickness)

        # --Notch dimensions
        if self.connection == "Finplate":
            notchObj = Notch(
                R1=notch_R1,
                height=notch_height,
                #width= (pBeam_B/2.0 - (pBeam_tw/2.0 ))+ gap,
                width=(pBeam_B / 2.0 - (pBeam_tw / 2.0 + gap)) + gap,
                length=sBeam_B)

        elif self.connection == "Endplate":
            notchObj = Notch(R1=notch_R1,
                             height=notch_height,
                             width=(pBeam_B / 2.0 -
                                    (pBeam_tw / 2.0 + plate_thick)) +
                             plate_thick,
                             length=sBeam_B)

        elif self.connection == "cleatAngle":
            #((pBeam_B - (pBeam_tw + 40)) / 2.0 + 10)
            notchObj = Notch(R1=notch_R1,
                             height=notch_height,
                             width=(pBeam_B / 2.0 - (pBeam_tw / 2.0 + gap)) +
                             gap,
                             length=sBeam_B)

        # column = ISectionold(B = 83, T = 14.1, D = 250, t = 11, R1 = 12, R2 = 3.2, alpha = 98, length = 1000)
        beam = ISection(B=sBeam_B,
                        T=sBeam_T,
                        D=sBeam_D,
                        t=sBeam_tw,
                        R1=sBeam_R1,
                        R2=sBeam_R2,
                        alpha=sBeam_alpha,
                        length=500,
                        notchObj=notchObj)

        # bolt = Bolt(R = bolt_R,T = bolt_T, H = 38.0, r = 4.0 )
        bolt = Bolt(R=bolt_R, T=bolt_T, H=bolt_Ht, r=bolt_r)

        # nut =Nut(R = bolt_R, T = 10.0,  H = 11, innerR1 = 4.0, outerR2 = 8.3)
        nut = Nut(R=bolt_R, T=nut_T, H=nut_Ht, innerR1=bolt_r)

        if self.connection == "Finplate":  # finBeamWebBeamWeb/endBeamWebBeamWeb
            nut_space = sBeam_tw + plate_thick + nut_T
            nutBoltArray = finNutBoltArray(self.resultObj, nut, bolt,
                                           nut_space)
            beamwebconn = finBeamWebBeamWeb(column, beam, notchObj, plate,
                                            Fweld1, nutBoltArray, gap)
            # column, beam, notch, plate, Fweld, nut_bolt_array
        elif self.connection == "Endplate":
            nut_space = sBeam_tw + plate_thick + nut_T
            nutBoltArray = endNutBoltArray(self.resultObj, nut, bolt,
                                           nut_space)
            beamwebconn = endBeamWebBeamWeb(column, beam, notchObj, Fweld1,
                                            plate, nutBoltArray)

        elif self.connection == "cleatAngle":
            nut_space = sBeam_tw + 2 * cleat_thick + nut_T
            cnut_space = pBeam_tw + cleat_thick + nut_T
            nut_bolt_array = cleatNutBoltArray(self.resultObj, nut, bolt,
                                               nut_space, cnut_space)
            beamwebconn = cleatBeamWebBeamWeb(column, beam, notchObj, angle,
                                              nut_bolt_array, gap)

        beamwebconn.create_3dmodel()

        return beamwebconn