fixed indeces of stringers

hello everynyan
i hope this fixed the issues, i am worried there might be issues with the RF calculation for the column buckling due to what I got on the feedback, but ill see tomorrow (I am hoping its just a fluke rn)

aseredesign/aseredesign.py

@@ -79,56 +79,50 @@ 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):
+    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 = 0
+    return(alpha)
 
 def GetSigCrip(stringerNo, Loadcase): ## unfinished, need to understand x claulcation still a bit
-    x = (dim1/dim2)*math.sqrt(sYield/(3.60*Ebasis))
+    #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
     
-    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)
+    x1 = (b1/dim2)*math.sqrt(sYield/(3.60*Ebasis))
+    
+    alpha1 = GetAlpha(x1)
+    
+    #print("x12: " + str(x))
+    sigCrip1 = alpha1 * sYield
+    
+    x2 = (b2/dim2)*math.sqrt(sYield/(3.60*Ebasis))
+    
+    alpha2 = GetAlpha(x2)
+    
+    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:
-        alpha = 1
+        sigCripAVG = sYield
 
-    
-    sigCrip12 = alpha * sYield
-    
-    x = (dim4/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
-    
-    
-    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
+    # average only over what can buckle!!! F/A, A = sumOf(bi*ti)
+    return min(sigCripAVG, sYield)
 
 
 def kBiax(panelNo,Loadcase):
@@ -153,19 +147,28 @@ def RF_panel(panelNo, Loadcase):
     return(result)
 
 
-def GetLambda(stringerNo):
+def GetLambda(i): # checked and correct
     I_comb = GetIcomb(i)
     r_gyr = math.sqrt(I_comb/(areaStringer + 0.5 * pThickness[i] * pWidth + 0.5 * pThickness[i+1] * pWidth))
     c = 1
-    return(1*pLength/r_gyr)
+    sLambda = c*pLength/r_gyr
+    return(sLambda)
 
 
 def GetSigCRIT(stringerNo, Loadcase):
-    sLambda_crit = math.sqrt((2*math.pi*math.pi*Ebasis)/GetSigCrip(i,0))
-    if(GetLambda(stringerNo)<sLambda_crit):
-        return(GetSigCrip(stringerNo, Loadcase) - ((1/Ebasis)*((GetSigCrip(stringerNo, Loadcase)/(2*math.pi))**2)*(GetLambda(stringerNo)**2)))
+    sLambda_crit = math.sqrt((2*math.pi*math.pi*Ebasis)/GetSigCrip(stringerNo,Loadcase))
+    # Lambda_crit correct
+    hSigCrip = GetSigCrip(stringerNo, Loadcase)
+    # 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 / (GetLambda(stringerNo) ** 2))
+        return((math.pi**2)*Ebasis / (hLambda ** 2))
 
 
 def GetRFstringer(stringerNo, Loadcase):

aseredesign/readme.md

@@ -1,10 +1,21 @@
 # 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/aseredesign)
+[aseredesign](https://git.zoerdu.net/Sasha/uni/src/branch/main/aseredesign)