def cs_analysis(): form_values.content = copy.deepcopy(form_values.default_cs) cont = form_values.content data.input_data.update({"a":cont.get("a")}) first_cs = initial_cs.create_initial_cs(cont.get("b_sup"), cont.get("b_inf"), cont.get("h"), cont.get("t_side"), cont.get("t_deck"), cont.get("t_btm")) deck_stiffeners = deck.deck(cont.get("b_sup"), False) form_values.stiffeners = [] form_values.stiffeners += deck_stiffeners end_cs = merge.merge(first_cs, form_values.stiffeners) image = cs_to_html.print_cs(end_cs) return render_template('geometry_input.html', image = image, content = cont)
def cs_analysis_input_1(): cont = None try: b_sup = int(request.form['b_sup']) b_inf = int(request.form['b_inf']) h = int(request.form['h']) t_side = int(request.form['t_side']) t_btm = int(request.form['t_btm']) num_side = int(request.form['num_side']) num_btm = int(request.form['num_btm']) a = int(request.form['a']) L_e = int(request.form['L_e']) form_values.content = copy.deepcopy(form_values.default_cs) cont = form_values.content cont.update({"b_sup":b_sup, "b_inf":b_inf, "h":h, "t_side":t_side, "t_btm":t_btm, "num_side":num_side, "num_btm":num_btm, "a":a, "L_e":L_e}) for i in range(num_side): code = ["location" + str(i+1), "b_sup" + str(i+1), "b_inf" + str(i+1), "h" + str(i+1), "t" + str(i+1)] location_st = float(request.form[code[0]]) b_sup_st = float(request.form[code[1]]) b_inf_st = float(request.form[code[2]]) h_st = float(request.form[code[3]]) t_st = float(request.form[code[4]]) cont.update({code[0]:location_st, code[1]:b_sup_st, code[2]:b_inf_st, code[3]:h_st, code[4]:t_st}) sym = math.ceil(num_btm/2) for i in range(30, 30+sym, 1): code = ["location" + str(i+1), "b_sup" + str(i+1), "b_inf" + str(i+1), "h" + str(i+1), "t" + str(i+1)] #try except clause because of disabled field try: location_st = float(request.form[code[0]]) except KeyError: location_st = 0 b_sup_st = float(request.form[code[1]]) b_inf_st = float(request.form[code[2]]) h_st = float(request.form[code[3]]) t_st = float(request.form[code[4]]) cont.update({code[0]:location_st, code[1]:b_sup_st, code[2]:b_inf_st, code[3]:h_st, code[4]:t_st}) except KeyError: cont = form_values.content a = cont.get("a") first_cs = initial_cs.create_initial_cs(cont.get("b_sup"), cont.get("b_inf"), cont.get("h"), cont.get("t_side"), cont.get("t_deck"), cont.get("t_btm")) data.input_data.update({"a":a}) deck_stiffeners = deck.deck(cont.get("b_sup"), False) num_top = len(deck_stiffeners) cont.update({"num_top":num_top}) form_values.stiffeners = [] form_values.stiffeners += deck_stiffeners stiffener_transform.input_to_prop(cont.get("num_top"), cont.get("num_side"), cont.get("num_btm")) rest_stiffeners = stiffener_transform.prop_to_draw(first_cs) form_values.stiffeners += rest_stiffeners end_cs = merge.merge(first_cs, form_values.stiffeners) image = cs_to_html.print_cs(end_cs) return render_template('geometry_input.html', content = cont, image = image)
def optimize_input_1(): val = None try: b_sup = int(request.form['b_sup']) b_inf = int(request.form['b_inf']) h = int(request.form['h']) a = int(request.form['a']) L_e = int(request.form['L_e']) form_values.values = copy.deepcopy(form_values.default_cs) val = form_values.values val.update({"b_sup":b_sup, "b_inf":b_inf, "h":h, "a":a, "L_e":L_e}) except KeyError: val = form_values.values first_cs = initial_cs.create_initial_cs(val.get("b_sup"), val.get("b_inf"), val.get("h"), 1,1,1) image = cs_to_html.print_cs(first_cs) return render_template('optimize_input.html', image = image, content = val)
def cs_analysis_gui(): #initialize file file = open("user_interface\output\cs_analysis.txt", "w+") file.close() #deck and initial_cs block cs = initial_cs.create_initial_cs(data.input_data.get("b_sup"), data.input_data.get("b_inf"), data.input_data.get("h"), data.input_data.get("t_side"), data.input_data.get("t_deck"), data.input_data.get("t_bottom")) st_list_deck = deck.deck(data.input_data.get("b_sup"), False) #assembly block st_list_rest = [] for st in data.stiffener_data.stiffeners: y,z = cs.get_coordinates(st.location, st.pl_position) if st.pl_position == 2: angle = math.pi + cs.get_angle(2) if st.pl_position == 3: angle = math.pi if st.pl_position == 4: angle = math.pi - cs.get_angle(2) stiffener_i = add_stiffeners.create_stiffener_global(st.pl_position, st.st_number, y, z, angle, \ st.b_sup, st.b_inf, st.h, st.t) st_list_rest.append(stiffener_i) stiffener_list = st_list_deck + st_list_rest stiffener_list = sorted(stiffener_list, key = lambda st: st.lines[0].code.st_number) cs = merge.merge(cs, stiffener_list) #proof block cs = buckling_proof.buckling_proof(cs) #user interface preparation results = {"eta_1": round(cs.eta_1,2), "eta_3_side_1":round(cs.eta_3_side_1,2), "interaction_1": round(cs.interaction_1,2), "eta_3_side_2":round(cs.eta_3_side_2,2), \ "interaction_2": round(cs.interaction_2,2), "eta_3_side_3":round(cs.eta_3_side_3,2), "interaction_3": cs.interaction_3, "eta_3_side_4":round(cs.eta_3_side_4,2), "interaction_4": round(cs.interaction_4,2)} image = cs_to_html.print_cs_red(cs) results.update({"image": image}) #create the output pdf printing.txt_to_pdf(cs, "cs") return results
def optimize(): form_values.values = copy.deepcopy(form_values.default_cs) val = form_values.values first_cs = initial_cs.create_initial_cs(val.get("b_sup"), val.get("b_inf"), val.get("h"), val.get("t_side"), val.get("t_deck"), val.get("t_btm")) image = cs_to_html.print_cs(first_cs) return render_template('optimize_input.html', image = image, content = val)
def optimize(): cs_collector.reset() b_sup = data.input_data["b_sup"] b_inf = data.input_data["b_inf"] h = data.input_data["h"] t_deck = data.input_data["t_deck"] t_range = defaults.t_range_opt I_range = defaults.I_range counter = 1 bottom_max = defaults.num_bottom_stiffeners_max side_max = defaults.num_side_stiffeners_max st_prop_deck = deck.deck(b_sup, True) num_top_stiffeners = len(st_prop_deck.stiffeners) m_ed = data.input_data.get("M_Ed") sign = math.copysign(1, m_ed) #no side stiffener block num_side_stiffeners = 0 if num_side_stiffeners <= side_max: for t_side in t_range: for t_bottom in t_range: base_cs = initial_cs.create_initial_cs(b_sup, b_inf, h, t_side, t_deck, t_bottom) for num_btm_stiffeners in range(bottom_max + 1): #no side stiffeners cs if num_side_stiffeners == 0: #without bottom stiffeners if num_btm_stiffeners == 0: print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("t_bottom:" + str(t_bottom)) print("t_side:" + str(t_side)) test_cs = copy.deepcopy(base_cs) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop.stiffeners = st_prop_deck.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener.st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof(test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): print("PASS!") cs_collector.into_collector(end_cs) else: print("FAIL!") #with bottom stiffeners else: for I_btm in I_range: print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("I_Bottom " + str(I_btm)) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) for num in range(num_btm_stiffeners): loc_btm = -1 + 2 / (num_btm_stiffeners + 1) * (num + 1) st_number = num_top_stiffeners + num_side_stiffeners + num + 1 st = proposed_stiffener.proposed_stiffener( pl_position=3, st_number=st_number, location=loc_btm, i_along=I_btm) st_prop_rest.stiffeners.append(st) st_prop.stiffeners = st_prop_deck.stiffeners + st_prop_rest.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener.st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof( test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): cs_collector.into_collector(end_cs) print("PASS!") else: print("FAIl!") #one side stiffener block num_side_stiffeners = 1 if num_side_stiffeners <= side_max: for t_side in t_range: for t_bottom in t_range: base_cs = initial_cs.create_initial_cs(b_sup, b_inf, h, t_side, t_deck, t_bottom) for num_btm_stiffeners in range(bottom_max + 1): if num_side_stiffeners == 1: #without bottom stiffeners if num_btm_stiffeners == 0: locations_side = get_locations_side( num_side_stiffeners, sign) for loc_side in range(len(locations_side)): for I_side in I_range: print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("I_Side " + str(I_side)) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) for num in range(num_side_stiffeners): #create side stiffeners loc = locations_side[loc_side][num] assert loc != -1, "Error!" st_number_right = num_top_stiffeners + num + 1 st_number_left = num_top_stiffeners + num_btm_stiffeners + 2 * num_side_stiffeners - num st_right = proposed_stiffener.proposed_stiffener( pl_position=2, st_number=st_number_right, location=loc, i_along=I_side) st_left = proposed_stiffener.proposed_stiffener( pl_position=4, st_number=st_number_left, location=loc, i_along=I_side) st_prop_rest.stiffeners.append( st_right) st_prop_rest.stiffeners.append(st_left) st_prop.stiffeners = st_prop_deck.stiffeners + st_prop_rest.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener.st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof( test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): cs_collector.into_collector(end_cs) print("PASS!") else: print("FAIL!") #with bottom stiffeners else: for I_side in I_range: locations_side = get_locations_side( num_side_stiffeners, sign) for loc_side in range(len(locations_side)): for I_btm in I_range: print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("I_Side " + str(I_side)) print("I_Btm " + str(I_btm)) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) for num in range(num_side_stiffeners): #create side stiffeners loc = locations_side[loc_side][num] assert loc != -1, "Error!" st_number_right = num_top_stiffeners + num + 1 st_number_left = num_top_stiffeners + num_btm_stiffeners + 2 * num_side_stiffeners - num st_right = proposed_stiffener.proposed_stiffener( pl_position=2, st_number=st_number_right, location=loc, i_along=I_side) st_left = proposed_stiffener.proposed_stiffener( pl_position=4, st_number=st_number_left, location=loc, i_along=I_side) st_prop_rest.stiffeners.append( st_right) st_prop_rest.stiffeners.append( st_left) #create bottom siffeners for num in range(num_btm_stiffeners): loc_btm = -1 + 2 / ( num_btm_stiffeners + 1) * (num + 1) st_number = num_top_stiffeners + num_side_stiffeners + num + 1 st = proposed_stiffener.proposed_stiffener( pl_position=3, st_number=st_number, location=loc_btm, i_along=I_btm) st_prop_rest.stiffeners.append(st) st_prop.stiffeners = st_prop_deck.stiffeners + st_prop_rest.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener.st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof( test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): cs_collector.into_collector( end_cs) print("PASS!") else: print("FAIL!") #two side stiffeners block num_side_stiffeners = 2 if num_side_stiffeners <= side_max: for t_side in t_range: for t_bottom in t_range: base_cs = initial_cs.create_initial_cs(b_sup, b_inf, h, t_side, t_deck, t_bottom) for num_btm_stiffeners in range(bottom_max + 1): if num_side_stiffeners == 2: #without bottom stiffeners if num_btm_stiffeners == 0: for I_side_btm in I_range: for I_side_top in I_range: I_collection = [I_side_top, I_side_btm] locations_side = get_locations_side( num_side_stiffeners, sign) for loc_side in range(len(locations_side)): print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("I_Side_Top " + str(I_side_top)) print("I_Side_Bottom " + str(I_side_btm)) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) for num in range(num_side_stiffeners): #create side stiffeners loc = locations_side[loc_side][num] assert loc != -1, "Error!" st_number_right = num_top_stiffeners + num + 1 st_number_left = num_top_stiffeners + num_btm_stiffeners + 2 * num_side_stiffeners - num st_right = proposed_stiffener.proposed_stiffener( pl_position=2, st_number=st_number_right, location=loc, i_along=I_collection[num]) st_left = proposed_stiffener.proposed_stiffener( pl_position=4, st_number=st_number_left, location=loc, i_along=I_collection[num]) st_prop_rest.stiffeners.append( st_right) st_prop_rest.stiffeners.append( st_left) st_prop.stiffeners = st_prop_deck.stiffeners + st_prop_rest.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener.st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof( test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): cs_collector.into_collector( end_cs) print("PASS!") else: print("FAIL!") #with bottom stiffeners else: for I_side_btm in I_range: for I_side_top in I_range: I_collection = [I_side_top, I_side_btm] locations_side = get_locations_side( num_side_stiffeners, sign) for loc_side in range(len(locations_side)): for I_btm in I_range: print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("I_Side_Top " + str(I_side_top)) print("I_Side_Bottom " + str(I_side_btm)) print("I_Btm " + str(I_btm)) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) for num in range( num_side_stiffeners): #create side stiffeners loc = locations_side[loc_side][ num] assert loc != -1, "Error!" st_number_right = num_top_stiffeners + num + 1 st_number_left = num_top_stiffeners + num_btm_stiffeners + 2 * num_side_stiffeners - num st_right = proposed_stiffener.proposed_stiffener( pl_position=2, st_number=st_number_right, location=loc, i_along=I_collection[num]) st_left = proposed_stiffener.proposed_stiffener( pl_position=4, st_number=st_number_left, location=loc, i_along=I_collection[num]) st_prop_rest.stiffeners.append( st_right) st_prop_rest.stiffeners.append( st_left) #create bottom siffeners for num in range( num_btm_stiffeners): loc_btm = -1 + 2 / ( num_btm_stiffeners + 1) * (num + 1) st_number = num_top_stiffeners + num_side_stiffeners + num + 1 st = proposed_stiffener.proposed_stiffener( pl_position=3, st_number=st_number, location=loc_btm, i_along=I_btm) st_prop_rest.stiffeners.append( st) st_prop.stiffeners = st_prop_deck.stiffeners + st_prop_rest.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener.st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof( test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): cs_collector.into_collector( end_cs) print("PASS!") else: print("FAIL!") #three side stiffeners block num_side_stiffeners = 3 if num_side_stiffeners <= side_max: for t_side in t_range: for t_bottom in t_range: base_cs = initial_cs.create_initial_cs(b_sup, b_inf, h, t_side, t_deck, t_bottom) for num_btm_stiffeners in range(bottom_max + 1): if num_side_stiffeners == 3: #without bottom stiffeners if num_btm_stiffeners == 0: for I_side_btm in I_range: for I_side_middle in I_range: for I_side_top in I_range: I_collection = [ I_side_top, I_side_middle, I_side_btm ] locations_side = get_locations_side( num_side_stiffeners, sign) for loc_side in range( len(locations_side)): print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("I_Side_Top " + str(I_side_top)) print("I_Side_Bottom " + str(I_side_btm)) print("I_Side_Middle" + str(I_side_middle)) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) for num in range( num_side_stiffeners): #create side stiffeners loc = locations_side[loc_side][ num] assert loc != -1, "Error!" st_number_right = num_top_stiffeners + num + 1 st_number_left = num_top_stiffeners + num_btm_stiffeners + 2 * num_side_stiffeners - num st_right = proposed_stiffener.proposed_stiffener( pl_position=2, st_number=st_number_right, location=loc, i_along=I_collection[num]) st_left = proposed_stiffener.proposed_stiffener( pl_position=4, st_number=st_number_left, location=loc, i_along=I_collection[num]) st_prop_rest.stiffeners.append( st_right) st_prop_rest.stiffeners.append( st_left) st_prop.stiffeners = st_prop_deck.stiffeners + st_prop_rest.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener.st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof( test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): cs_collector.into_collector( end_cs) print("PASS!") else: print("FAIL!") #with bottom stiffeners else: for I_side_btm in I_range: for I_side_top in I_range: for I_side_middle in I_range: I_collection = [ I_side_top, I_side_middle, I_side_btm ] locations_side = get_locations_side( num_side_stiffeners, sign) for loc_side in range( len(locations_side)): for I_btm in I_range: print( "\n-------------------------------------------------------------------------------------------------------" ) print( "------------------------------------ CS" + str(counter) + "---------------------------------------------------------------" ) counter += 1 print("#Side Stiffeners " + str(num_side_stiffeners)) print("#Btm Stiffeners " + str(num_btm_stiffeners)) print("I_Side_Top " + str(I_side_top)) print("I_Side_Middle " + str(I_side_middle)) print("I_Side_Bottom " + str(I_side_btm)) print("I_Btm " + str(I_btm)) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) for num in range( num_side_stiffeners): #create side stiffeners loc = locations_side[ loc_side][num] assert loc != -1, "Error!" st_number_right = num_top_stiffeners + num + 1 st_number_left = num_top_stiffeners + num_btm_stiffeners + 2 * num_side_stiffeners - num st_right = proposed_stiffener.proposed_stiffener( pl_position=2, st_number= st_number_right, location=loc, i_along=I_collection[ num]) st_left = proposed_stiffener.proposed_stiffener( pl_position=4, st_number= st_number_left, location=loc, i_along=I_collection[ num]) st_prop_rest.stiffeners.append( st_right) st_prop_rest.stiffeners.append( st_left) #create bottom siffeners for num in range( num_btm_stiffeners): loc_btm = -1 + 2 / ( num_btm_stiffeners + 1) * (num + 1) st_number = num_top_stiffeners + num_side_stiffeners + num + 1 st = proposed_stiffener.proposed_stiffener( pl_position=3, st_number=st_number, location=loc_btm, i_along=I_btm) st_prop_rest.stiffeners.append( st) st_prop.stiffeners = st_prop_deck.stiffeners + st_prop_rest.stiffeners st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda proposed_stiffener: proposed_stiffener. st_number) test_cs = add_stiffeners.add_stiffener_set( base_cs, st_prop, "b") if test_cs != False: #proof end_cs = buckling_proof.buckling_proof( test_cs) st_prop_rest = stiffeners_proposition.stiffeners_proposition( ) if end_cs.proven(): cs_collector.into_collector( end_cs) print("PASS!") else: print("FAIL!") printing.print_best_proof() printing.print_best() return
def opt_eqpressure(): cs_collector.reset() b_sup = data.input_data["b_sup"] b_inf = data.input_data["b_inf"] h = data.input_data["h"] t_deck = data.input_data["t_deck"] t_values = defaults.t_range_opt i_along_values = defaults.I_range n_st_side_max = defaults.num_side_stiffeners_max n_st_bottom_max = defaults.num_bottom_stiffeners_max cs_fresh = initial_cs.create_initial_cs(b_sup, b_inf, h, 1, t_deck, 1) st_prop_deck = deck.deck(b_sup, True) n_st_deck = len(st_prop_deck.stiffeners) assert data.input_data.get( "M_Ed") < 1, "Optimizer A does not work for positive bending moments" for t_side in t_values: print("888888888888888888888888888888888 SIDE T = ", t_side, "888888888888888888888888888888888") for t_bottom in t_values: print("888888888888888888888888888888888 BOTTOM T = ", t_bottom, "888888888888888888888888888888888") empty_cs = set_t_side(copy.deepcopy(cs_fresh), t_side) empty_cs = set_t_bottom(empty_cs, t_bottom) cs_temp = add_stiffeners.add_stiffener_set(copy.deepcopy(empty_cs), st_prop_deck, "a") cs_temp = buckling_proof.buckling_proof(copy.deepcopy(empty_cs)) sigma_top_red = get_sigma_top_red(cs_temp) sigma_bottom_red = get_sigma_bottom_red(cs_temp) #the optimizer loop does not loop i_along, as this should be set optimally by the set functions n_st_side = 0 while n_st_side <= n_st_side_max: print("\n888888888888888888888888888888888 ITERATION SIDE ", n_st_side, "888888888888888888888888888888888") if n_st_side == 0: i_along_values_side = [1] else: i_along_values_side = i_along_values for i_along_side in i_along_values_side: print( "\n&&&&&&&&&&&&&&&&&&&&&&&&& ITERATION I_ALONG_SIDE = ", str(i_along_side / 10**5), " &&&&&&&&&&&&&&&&&&&&&&&&&&&") n_st_bottom = 0 while n_st_bottom <= n_st_bottom_max: print( "\n888888888888888888888888888888888 ITERATION BOTTOM ", n_st_bottom, "888888888888888888888888888888888") if n_st_bottom == 0: i_along_values_bottom = [1] else: i_along_values_bottom = i_along_values for i_along_bottom in i_along_values_bottom: print( "\n&&&&&&&&&&&&&&&&&&&&&&&&& ITERATION I_ALONG_BOTTOM = ", str(i_along_bottom / 10**5), " &&&&&&&&&&&&&&&&&&&&&&&&&&&") #do it twice; the stresses now are the ones calculated for the same amount of stiffeners (but different place (could do more)) for times in range(2): st_prop_side = set_stiffeners_side( copy.deepcopy(empty_cs), n_st_deck, n_st_side, n_st_bottom, sigma_top_red, sigma_bottom_red, i_along_side) st_prop_bottom = set_stiffeners_bottom( copy.deepcopy(empty_cs), n_st_deck, n_st_side, n_st_bottom, sigma_bottom_red, i_along_bottom) st_prop = stiffeners_proposition.stiffeners_proposition( ) st_prop.stiffeners = copy.deepcopy( st_prop_deck.stiffeners) + copy.deepcopy( st_prop_side.stiffeners ) + copy.deepcopy( st_prop_bottom.stiffeners) st_prop.stiffeners = sorted( st_prop.stiffeners, key=lambda st: st.st_number) stiffened_cs = add_stiffeners.add_stiffener_set( copy.deepcopy(empty_cs), st_prop, "a") assert stiffened_cs != True, "cs is bool True" assert stiffened_cs != False, "cs is bool False" stiffened_cs = buckling_proof.buckling_proof( copy.deepcopy(stiffened_cs)) #stresses at the top and bottom corner sigma_top_red = get_sigma_top_red(stiffened_cs) sigma_bottom_red = get_sigma_bottom_red( stiffened_cs) if stiffened_cs.proven(): cs_collector.into_collector(stiffened_cs) #terminate i_along_bottom n_st_bottom += 1 #terminate n_st_bottom #terminate else #terminate i_along _side #terminate n_st_side n_st_side += 1 #terminate t bottom #terminate t_side printing.print_best() printing.print_best_proof()
#sys.path.append('C:/Users/Vinzenz Müller/Dropbox/ETH/6. Semester/BA') #crosssection input and creation (only trapezoid plates) if defaults.do_print_to_txt == True: file = open("user_interface/output/cs_analysis.txt", "w+") file.close() defaults.do_deck_as_prop = True cs_analysis_tool_terminal_input.set_defaults() printing.printing(data.constants_tostring(), terminal=True) cs_analysis_tool_terminal_input.set_cs_geometry() #data.check_input_data_complete() cs = initial_cs.create_initial_cs(data.input_data.get("b_sup"), data.input_data.get("b_inf"), data.input_data.get("h"), data.input_data.get("t_side"), data.input_data.get("t_deck"), data.input_data.get("t_bottom")) printing.printing(data.input_data_tostring(), terminal=True) #add the deck stiffeners st_list_deck = deck.deck(data.input_data.get("b_sup")) number_st_top = len(st_list_deck.stiffeners) st_list_deck = substantiate.substantiate(cs, st_list_deck) #add all other stiffeners cs_analysis_tool_terminal_input.set_stiffeners(number_st_top) st_list_rest = [] for st in data.stiffener_data.stiffeners: y, z = cs.get_coordinates(st.location, st.pl_position)