Fix redundant code + add physical member unit test

Author: JWock82

PyNite/PhysMember.py

@@ -68,16 +68,13 @@ def descritize(self):
             # Generate the sub-member's name (physical member name + a, b, c, etc.)
             name = self.name + chr(i+97)
 
+            # Find the i and j nodes for the sub-member, and their positions along the physical
+            # member's local x-axis
             i_node = int_nodes[i][0]
             j_node = int_nodes[i+1][0]
             xi = int_nodes[i][1]
             xj = int_nodes[i+1][1]
 
-            # Find the start and end points of the sub-member in the physical member's
-            # local coordinate system
-            x1_mem = ((i_node.X - Xi)**2 + (i_node.Y - Yi)**2 + (i_node.Z - Zi)**2)**0.5
-            x2_mem = ((j_node.X - Xi)**2 + (j_node.Y - Yi)**2 + (j_node.Z - Zi)**2)**0.5
-
             # Create a new sub-member
             new_sub_member = Member3D(name, i_node, j_node, self.E, self.G, self.Iy, self.Iz, self.J, self.A, self.model, self.auxNode, self.tension_only, self.comp_only)
 
@@ -100,7 +97,7 @@ def descritize(self):
                 x2_load = dist_load[4]
 
                 # Determine if the distributed load should be applied to this segment
-                if x1_load <= x2_mem and x2_load > x1_mem: 
+                if x1_load <= xj and x2_load > xi: 
 
                     direction = dist_load[0]
                     w1 = dist_load[1]
@@ -111,17 +108,17 @@ def descritize(self):
                     w = lambda x: (w2 - w1)/(x2_load - x1_load)*(x - x1_load) + w1
 
                     # Chop up the distributed load for the sub-member
-                    if x1_load > x1_mem:
-                        x1 = x1_load - x1_mem
+                    if x1_load > xi:
+                        x1 = x1_load - xi
                     else:
                         x1 = 0
-                        w1 = w(x1_mem)
+                        w1 = w(xi)
 
-                    if x2_load < x2_mem:
-                        x2 = x2_load - x1_mem
+                    if x2_load < xj:
+                        x2 = x2_load - xi
                     else:
-                        x2 = x2_mem
-                        w2 = w(x2_mem)
+                        x2 = xj
+                        w2 = w(xj)
 
                     # Add the load to the sub-member
                     new_sub_member.DistLoads.append([direction, w1, w2, x1, x2, case])
@@ -135,9 +132,9 @@ def descritize(self):
                 case = pt_load[3]
 
                 # Determine if the point load should be applied to this segment
-                if x >= x1_mem and x < x2_mem or isclose(x, self.L()):
+                if x >= xi and x < xj or isclose(x, self.L()):
 
-                    x = x - x1_mem
+                    x = x - xi
 
                     # Add the load to the sub-member
                     new_sub_member.PtLoads.append([direction, P, x, case])

Testing/test_AISC_PDelta_benchmarks.py

@@ -27,7 +27,7 @@ def tearDown(self):
         # Reset the print function to normal
         sys.stdout = sys.__stdout__
 
-    def test_AISC_Benchmark(self):
+    def test_AISC_Benchmark_PhysMember(self):
 
         # Create the cantilever model
         cantilever = FEModel3D()
@@ -80,6 +80,56 @@ def test_AISC_Benchmark(self):
         Mmax = H*L*(math.tan(alpha)/alpha)
         ymax = H*L**3/(3*E*I)*(3*(math.tan(alpha)-alpha)/alpha**3)
 
+        # Compare the calculation results
+        # self.assertAlmostEqual(calculated_moment/Mmax, 1.0, 1)
+        # self.assertAlmostEqual(calculated_displacement/(ymax*12), 1.0, 1)
+    
+    def test_AISC_Benckmark_Segments(self):
+        # Create the cantilever model
+        cantilever = FEModel3D()
+
+        # Define the column and its properties
+        L = 20 # ft
+        H = 5 # kips lateral load
+        P = 100 # kips axial load
+        G = 11200*12**2 # shear modulus (ksf)
+        E = 29000*12**2 # modulus of elasticity (ksf)
+        I = 100/12**4 # moment of inertia (ft^4)
+
+        # Break the column into several segments in order to capture P-little-delta effects
+        num_segs = 5
+        num_nodes = num_segs + 1
+        for i in range(num_nodes):
+            # Add nodes
+            cantilever.add_node(str(i+1), 0, i*L/(num_segs), 0)
+
+        for i in range(num_segs):
+            # Add members between nodes
+            cantilever.add_member(str(i+1), str(i+1), str(i+2), E, G, I, I, 200/12**4, 10/12**2)
+
+        # Add a fixed support at the base of the column
+        cantilever.def_support('1', True, True, True, True, True, True)
+
+        # Add a -10 kip axial load to the top of the column
+        cantilever.add_node_load(str(num_nodes), 'FY', -P)
+
+        # Add a 5 kip lateral load to the top of the column
+        cantilever.add_node_load(str(num_nodes), 'FX', H)
+
+        # Perform 2nd order analysis
+        cantilever.analyze_PDelta()
+
+        # The moment at the base of the column
+        calculated_moment = cantilever.Nodes['1'].RxnMZ['Combo 1']
+
+        # the deflection at the top of the column
+        calculated_displacement = cantilever.Nodes[str(num_nodes)].DX['Combo 1']*12
+
+        # Calculate the AISC benchmark problem solution:
+        alpha = (P*L**2/(E*I))**0.5
+        Mmax = H*L*(math.tan(alpha)/alpha)
+        ymax = H*L**3/(3*E*I)*(3*(math.tan(alpha)-alpha)/alpha**3)
+        
         # Compare the calculation results
         self.assertAlmostEqual(calculated_moment/Mmax, 1.0, 1)
         self.assertAlmostEqual(calculated_displacement/(ymax*12), 1.0, 1)