Hello dear Dlubal team,
Is there an option in the Steel Connections add-on in RFEM6 to display the maximum load-bearing capacity of a connection regardless of the acting design situation?
Or is this only possible through a manual iterative load increase in the design situation until a utilization of 100% of the connection is reached?
Good day,
I am not part of the Dlubal team myself, but I am quite sure that this is not possible and for good reason.
The maximum load capacity for many connections would not be a scalar, i.e., a one-dimensional value, but rather a limit for many different combinations of internal forces, especially since FEA connections allow up to 6 internal forces per connected member. This naturally results in an incredible number of internal force combinations (depending on the number of connected members, tending towards infinity). Because interactions occur between the stresses resulting from different internal force components => strains, it is therefore not possible to calculate THE maximum load capacity of a connection, but rather the maximum normal force that may additionally act given: Mt, My, Mx, Vy, Vz. If you want to develop a kind of parametric analysis yourself, i.e., a table from which you can later derive the maximum load capacities for verifications, you can do this using an API programming code. For example, I programmed a load iteration with the following code, in which only verified combinations are calculated:
def main():
results = []
wb = load_workbook(excel_file)
ws = wb[sheet_name]
excel_i = 0
lc_counter = LC_START
with rfem.Application(api_key_value=API_KEY) as rfem_app:
info = rfem_app.get_application_info()
print(f"Version: {info.name}")
rfem_app.get_active_model()
Mz = START
while True:
has_valid_mz_combination = False
My = START
while True:
has_valid_my_combination = False
Vy = START
while True:
has_valid_vy_combination = False
Vz = START
while True:
has_valid_vz_combination = False
N = START
while True:
try:
result = calculate_combination(
rfem_app=rfem_app,
lc_no=lc_counter,
My=My,
Mz=Mz,
Vy=Vy,
Vz=Vz,
N=N
)
epsilon_max = result["epsilon_max"]
eta_criticalScrew = result["eta_criticalScrew"]
epsilon_max_remaining = result["epsilon_max_remaining"]
epsilonmax_all = result["epsilon_max_all"]
corresponding_N = result["corresponding_N"]
corresponding_Vy = result["corresponding_Vy"]
corresponding_Vz = result["corresponding_Vz"]
corresponding_Vres = result["corresponding_Vres"]
print(
f"LC={lc_counter} | "
f"My={My}, Mz={Mz}, Vy={Vy}, Vz={Vz}, N={N} "
f"-> epsilon_max={epsilon_max:.6f}, Surface={result['surface_max']}"
)
row = EXCEL_START_ROW + excel_i
write_excel(
wb=wb,
ws=ws,
row=row,
lc_no=lc_counter,
My=My,
Mz=Mz,
Vy=Vy,
Vz=Vz,
N=N,
result=result
)
except Exception as e:
print(
f"Error at LC={lc_counter} | "
f"My={My}, Mz={Mz}, Vy={Vy}, Vz={Vz}, N={N}: {e}"
)
break
lc_counter += 1
excel_i += 1
if epsilon_max > EPS_LIMIT:
break
results.append({
"LC": lc_counter - 1,
"My": My,
"Mz": Mz,
"Vy": Vy,
"Vz": Vz,
"N": N,
"epsilon_max": epsilon_max,
"surface_max": result["surface_max"],
"eta_criticalScrew": eta_criticalScrew,
"corresponding_N": corresponding_N,
"corresponding_Vy": corresponding_Vy,
"corresponding_Vz": corresponding_Vz,
"corresponding_Vres": corresponding_Vres,
"epsilonmax_all": epsilonmax_all,
"epsilon_max_remaining": epsilon_max_remaining
})
has_valid_vz_combination = True
has_valid_vy_combination = True
has_valid_my_combination = True
has_valid_mz_combination = True
N += STEP
if not has_valid_vz_combination:
break
Vz += STEP
if not has_valid_vy_combination:
break
Vy += STEP
if not has_valid_my_combination:
break
My += STEP
if not has_valid_mz_combination:
break
Mz += STEP
wb.save(excel_file)
print("Excel file has been saved.")
print(f"Number of valid combinations: {len(results)}")
if __name__ == "__main__":
main()
PS: Of course this is not my entire complete code but only an excerpt that hopefully gives you enough inspiration and input to piece the rest together; I think it illustrates the basic principle quite well and makes it easy to build the framework around it for your individual connection... It is best to simply ask ChatGPT about individual sections of the code that you do not understand. Otherwise, if necessary, I can also give you 1-2 tips that I have learned/built into my application.
Best regards, Nick
It is important to note here that, as you have probably seen, the code only stops the load iterations for the limit strain; this was intentional in my application case. I programmed an output in Excel where I can monetize when connections would actually fail due to welds or bolts, but the sheets could still carry more load... If you are concerned about the first exceeded proof, you will of course need to add further loop break criteria.
Furthermore, it is extremely important to know that the API currently can only evaluate results continuously according to the result smoothing => continuously throughout areas and area sets! For a correct design of plastic material, it is strongly recommended not only by DLUBAL but also by many other FE literature sources to use the result smoothing constantly in mesh elements. The results usually differ by hardly 5%. However, one should still preferably look at the results in the GUI at the corresponding limit areas where the proofs no longer pass according to the correct setting => the development has already created a bug report regarding this and will hopefully resolve the whole issue soon.
It would also be totally smart, of course, to program the load iterations in such a way that the step sizes in which the loads increase are refined when a proof is exceeded, so that on the one hand as many load cases as possible where the connection is hardly loaded anyway are not unnecessarily calculated, and on the other hand the interval around the point where the innermost load loop breaks off is kept as small as possible in order to get to the limit states that are as close as possible to the maximum load-bearing capacity. Unfortunately, I still have difficulties here myself since my overall code has become very large and I am currently occupied on other fronts... if you yourself program something and solve it cleverly, I would be very happy to hear from you and possibly learn.