aseredesign/aseredesign.py

@@ -79,7 +79,10 @@ def GetCombAvgStressofStringer(stringerNo, Loadcase):
     rightPStress = GetAvgStressofPanel(rightPID, Loadcase, 'XX')
     return((leftPStress * 0.5 * pThickness[stringerNo - 1] * pWidth + rightPStress * 0.5 * pThickness[stringerNo]*pWidth + avgStringerStress * areaStringer) / (areaStringer + 0.5*pThickness[stringerNo-1] * pWidth + 0.5 * pThickness[stringerNo]*pWidth))
 
-def GetAlpha(x):
+
+def GetSigCrip(stringerNo, Loadcase): ## unfinished, need to understand x claulcation still a bit
+    x = (dim1/dim2)*math.sqrt(sYield/(3.60*Ebasis))
+    
     if(0.4 <= x <= 1.095):
         alpha = 1.4 - 0.628 * x
     elif(1.095 < x <= 1.633):
@@ -87,42 +90,45 @@ def GetAlpha(x):
     elif(x > 1.633):
         alpha = 0.69/(x**0.75)
     else:
-        alpha = 0
+        alpha = 1
-    return(alpha)
     
-def GetSigCrip(stringerNo, Loadcase): ## unfinished, need to understand x claulcation still a bit
-    #use b1 and b2 for calc
-    #E_c = Ebasis
-    #no alpha = 1 it is none -> what do then? -> ignore that element in averaging
-    #averaging only with elements that cripple
-    #if  nothing cripples, use yield strength
-    b1 = dim1 - dim2
-    b2 = dim3 - dim2
     
-    x1 = (b1/dim2)*math.sqrt(sYield/(3.60*Ebasis))
+    sigCrip12 = alpha * sYield
     
-    alpha1 = GetAlpha(x1)
+    x = (dim4/dim2)*math.sqrt(sYield/(3.60*Ebasis))
     
-    #print("x12: " + str(x))
+    if(0.4 <= x <= 1.095):
-    sigCrip1 = alpha1 * sYield
+        alpha = 1.4 - 0.628 * x
-    
+    elif(1.095 < x <= 1.633):
-    x2 = (b2/dim2)*math.sqrt(sYield/(3.60*Ebasis))
+        alpha = 0.78/x
-    
+    elif(x > 1.633):
-    alpha2 = GetAlpha(x2)
+        alpha = 0.69/(x**0.75)
-    
-    sigCrip2 = alpha2 * sYield
-
-    if(alpha1 != 0 and alpha2 != 0):
-        sigCripAVG = (sigCrip1 * b1 * dim2 + sigCrip2 * b2 * dim2 * 2)/(b1 * dim2 + b2 * dim2 * 2)
-    elif(alpha1 != 0):
-        sigCripAVG = (sigCrip1 * b1 * dim2)/(b1 * dim2)
-    elif(alpha2 != 0):
-        sigCripAVG = (sigCrip2 * b2 * dim2)/(b2 * dim2)
     else:
-        sigCripAVG = sYield
+        alpha = 1
     
-    # average only over what can buckle!!! F/A, A = sumOf(bi*ti)
+    
-    return min(sigCripAVG, sYield)
+    sigCrip24 = alpha * sYield
+    
+    x = (dim3/dim2)*math.sqrt(sYield/(3.60*Ebasis))
+    
+    if(0.4 <= x <= 1.095):
+        alpha = 1.4 - 0.628 * x
+    elif(1.095 < x <= 1.633):
+        alpha = 0.78/x
+    elif(x > 1.633):
+        alpha = 0.69/(x**0.75)
+    else:
+        alpha = 1
+    
+    sigCrip23 = alpha * sYield
+    # i know this is inefficient and shittily as hell!! its quick and dirty tho
+    # TODO: FIX!!
+    sigCripAVG = (sigCrip12 * dim1 * dim2 + sigCrip23 * dim2 * dim3 + sigCrip24 * dim2 * dim4)/(dim1 * dim2 + dim2 * dim3 + dim2 * dim4)
+    
+    if(sigCripAVG < sYield):
+        return sigCripAVG
+    else:
+        return sYield
 
 
 def kBiax(panelNo,Loadcase):
@@ -147,28 +153,19 @@ def RF_panel(panelNo, Loadcase):
     return(result)
 
 
-def GetLambda(i): # checked and correct
+def GetLambda(stringerNo):
     I_comb = GetIcomb(i)
     r_gyr = math.sqrt(I_comb/(areaStringer + 0.5 * pThickness[i] * pWidth + 0.5 * pThickness[i+1] * pWidth))
     c = 1
-    sLambda = c*pLength/r_gyr
+    return(1*pLength/r_gyr)
-    return(sLambda)
 
 
 def GetSigCRIT(stringerNo, Loadcase):
-    sLambda_crit = math.sqrt((2*math.pi*math.pi*Ebasis)/GetSigCrip(stringerNo,Loadcase))
+    sLambda_crit = math.sqrt((2*math.pi*math.pi*Ebasis)/GetSigCrip(i,0))
-    # Lambda_crit correct
+    if(GetLambda(stringerNo)<sLambda_crit):
-    hSigCrip = GetSigCrip(stringerNo, Loadcase)
+        return(GetSigCrip(stringerNo, Loadcase) - ((1/Ebasis)*((GetSigCrip(stringerNo, Loadcase)/(2*math.pi))**2)*(GetLambda(stringerNo)**2)))
-    # SigCrip  correct!!
-    hLambda = GetLambda(stringerNo-1)
-    #print("Lmabda: " + str(hLambda))
-    # ISSUE HERE - Lambda off from results
-    # no double checking now
-        
-    if(hLambda<sLambda_crit):
-        return(hSigCrip - ((1/Ebasis)*((hSigCrip/(2*math.pi))**2)*(hLambda**2)))
     else:
-        return((math.pi**2)*Ebasis / (hLambda ** 2))
+        return((math.pi**2)*Ebasis / (GetLambda(stringerNo) ** 2))
 
 
 def GetRFstringer(stringerNo, Loadcase):

aseredesign/readme.md

@@ -1,21 +1,10 @@
 # ASE Redesign Calculator
-
-**Important:**
-
-Version was updated --- new release. There might be issues with the RF of the column buckling. I am unsure at this exact moment.
-
-Nothing regarding the procedure has changed. 
-
-***
-
 This redesign calculator requires manual input in Hyperworks, but returns the values needed for the final results csv file.
 It can calculate several results at the same time which I found helpful for comparing and analysing.
 It has the following limitations:
 1. All stringers have to have the same dimensions (panel thickness may vary tho)
 2. Dimensions must be inputted into Python as well as Hyperworks
 
-[Releases here](https://git.zoerdu.net/Sasha/uni/releases)
-
 ## Quick rundown
 1. Modify the dimensions of the stringers and panels in the *.hm* and *aseredesign.py* file
 2. Run the simulation

readme.md

@@ -1,2 +1,2 @@
 # Uni stuff
-[aseredesign](https://git.zoerdu.net/Sasha/uni/src/branch/main/aseredesign)
+[aseredesign](https://git.zoerdu.net/Sasha/uni/aseredesign)