percent_45_135 = 10 diso = True delta_angle = 45 contig = True n_contig = 4 set_of_angles = np.array(data.loc[1, 'fibre orientations'].split()).astype(int) constraints = Constraints( sym=sym, bal=bal, ipo=ipo, oopo=oopo, dam_tol=dam_tol, rule_10_percent=rule_10_percent, percent_0=percent_0, percent_45=percent_45, percent_90=percent_90, percent_135=percent_135, percent_45_135=percent_45_135, diso=diso, contig=contig, n_contig=n_contig, delta_angle=delta_angle, set_of_angles=set_of_angles) #============================================================================== # Parameters #============================================================================== # lamination parameter weightings during membrane property refinement in_plane_coeffs = np.array([1, 1, 0, 0]) # percentage of laminate thickness for plies that can be modified during # the refinement of membrane properties
< -2*lampam_tab_tab[ind, 0]+4*constraints.percent_0 -1: lampam_tab_tab = np.delete(lampam_tab_tab, np.s_[ind], axis=0) angle = np.delete(angle, np.s_[ind], axis=0) angle2 = np.delete(angle2, np.s_[ind], axis=0) elif lampam_tab_tab[ ind, 2] > 1 - 2 * constraints.percent_45_135 + 1e-15: lampam_tab_tab = np.delete(lampam_tab_tab, np.s_[ind], axis=0) angle = np.delete(angle, np.s_[ind], axis=0) angle2 = np.delete(angle2, np.s_[ind], axis=0) return lampam_tab_tab, angle, angle2 if __name__ == "__main__": constraints = Constraints(sym=True) constraints.rule_10_percent = True constraints.set_percentages(percent_0=10, percent_45=0, percent_90=10, percent_135=0, percent_45_135=10) print('*** Test for the function display_ply_counts ***\n') display_ply_counts(stack=np.array([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 90, 90, 90, 90, 90, 90, -45, -45, -45, -45, -45, -45, -45, -45, -45, -45, 90, 90, 90, 90, 90, 90, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
return stack, False # remaining_plies = remaining_plies[good_permut] stack = np.hstack((stack_top, remaining_plies[good_permut], stack_bottom)) if stack.size != ss.size: raise Exception('This should not happen') return stack, True if __name__ == "__main__": print('\n*** Test for repair_diso_contig_from_outside_asym ***') ss_ini = np.array([-45, 0, 666, 666, 666, 90, 45, 90], int) ply_queue = [-45, 0, 45] constraints = Constraints( sym=False, dam_tol=False, diso=True, contig=True, delta_angle=45, n_contig=4, set_of_angles=[0, 45, -45, 90, 30, -30, 60, -60, 15, -15, 75, -75]) print_ss(ss_ini, 200) n_D1 = 6 print('ss_ini.size', ss_ini.size) print('ply_queue', ply_queue) ss, completed = repair_diso_contig_from_outside_asym( ss_ini, ply_queue, constraints, n_D1) print('Repair successful?', completed) print_ss(ss, 200)
if objD < 1e-10: if count_obj: return ss, n_obj_func_D_calls return ss if count_obj: return ss, n_obj_func_D_calls return ss if __name__ == "__main__": print('\n*** Test for the function repair_flexural_1 ***') constraints = Constraints( sym=True, ipo=True, dam_tol=False, diso=True, contig=True, delta_angle=45, n_contig=4) lampam_target = np.array([1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]) ss = np.array([90, 90, 45, 0, 0, -45, 90, 45, 0, -45], int) if constraints.sym: ss = np.hstack((ss, np.flip(ss))) print('\nInitial stacking sequence') print_ss(ss) test, _ = internal_diso_contig(ss, constraints) if test.size < 1: raise Exception('Contiguity or disorientation rule not satisfied.') out_of_plane_coeffs = np.array([1/3, 1/3, 1/3, 0])
current_10[0] = sum(ss == 0) + sum(ply_queue == 0) current_10[1] = sum(ss == 90) + sum(ply_queue == 90) current_10[2] = sum(ss == 45) + sum(ply_queue == 45) current_10[3] = sum(ss == -45) + sum(ply_queue == -45) current_10[4] = current_10[2] + current_10[3] return current_10 - mini_10 if __name__ == "__main__": print('\n\n*** Test for the function calc_excess_10 ***') constraints = Constraints(sym=True, ipo=True, dam_tol=False, rule_10_percent=True, percent_0=10, percent_45=10, percent_90=10, percent_135=10, set_of_angles=[0, 45, 30, -30, -45, 60, -60, 90]) ss = np.array([ 0, 45, 666, 666, 666, 666, 666, 666, 666, 666, 666, 666, 666, 666, 666, 666, 45, 0 ], int) ply_queue = [90, 90, -45, 90, 90, 45, 0] mini_10 = calc_mini_10(constraints, ss.size) print('\nInitial stacking sequence') print_ss(ss, 40) excess_10 = calc_excess_10(ss, ply_queue, mini_10, sym=constraints.sym) print('\nexcess_10', excess_10)
# print() # print_ss(ss_ini[:ss_ini.size//2]) # print_ss(ss[:ss_ini.size//2]) # print('objD', objD) if constraints.sym: ss[ss.size // 2 + ss.size % 2:] = np.flip(ss[:ss.size // 2]) if count_obj: return ss, n_obj_func_D_calls return ss if __name__ == "__main__": print('\n*** Test for the function repair_flexural_4 ***') constraints = Constraints(sym=True, dam_tol=True) parameters = Parameters(repair_flexural_switch=True, n_D2=2, constraints=constraints) ss = np.array([ 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 45, 0, 0, 0, 0 ], int) if constraints.sym:
print('outputs:\n') print(calc_contig_vector(ss, n_contig)) print('*** Test for the function calc_matrix_viol_contig ***\n') print('Inputs:\n') ss = [np.array([0, 90, 90]), np.array([0, 0, 0, 0, 0, 0])] n_contig = 3 print(f'ss: {ss}') print(f'n_contig: {n_contig}') print('outputs:\n') viola_contig = calc_matrix_viol_contig(ss, n_contig) print(f'viola_contig: {viola_contig}\n') print('*** Test for the function calc_penalty_contig_mp ***\n') print('Inputs:\n') constraints = Constraints(sym=True) constraints.dam_tol = True constraints.n_contig = 3 ss = [np.array([0, 90, 90]), np.array([0, 0, 0, 0, 0, 0])] print(f'ss: {ss}') print('outputs:\n') viola_contig = calc_penalty_contig_mp(ss, constraints) print(f'Result: {viola_contig}\n') print('*** Test for the function calc_penalty_contig_ss ***\n') constraints = Constraints(sym=True) constraints.dam_tol = True constraints.n_contig = 3 print('Inputs:\n') ss = np.array([0, 90, 90, 90, 90]) print(f'ss: {ss}')
in_plane_coeffs * (( lampamA \ - lampamA_options[ind_pos_angle1] \ + lampamA_options[ind_pos_angle2] \ - lampam_target[0:4]) ** 2)) return objA_options if __name__ == "__main__": print('\n*** Test for the function repair_membrane_1_ipo ***') constraints = Constraints( sym=True, bal=True, ipo=True, dam_tol=False, rule_10_percent=True, percent_0=10, percent_45=0, percent_90=10, percent_135=0, percent_45_135=10, set_of_angles=[0, 45, -45, 90]) # set_of_angles=[0, 45, 30, -30, 60, -60, -45, 90]) p_A = 70 in_plane_coeffs = np.array([0.5, 0.5, 0, 0]) ss_target = np.array([0], int) lampam_target = calc_lampam(ss_target) ss = np.array([45, 90, 45, 45, 0, -45, -45, 0, 666, 666], int) ss = np.hstack((ss, np.flip(ss))) ply_queue = [90, -45]
print(is_diso_ss(ss, delta_angle=45, dam_tol=True, dam_tol_rule=2)) print('*** Test for the function calc_n_viola_diso ***\n') print('Inputs:\n') mother_n_viola_diso = np.array([0, 0]) mother_ss = [np.array([0, 0]), np.array([90])] child_ss = np.array([[0], [45], [90], [-45]]) level = 3 n_panels = 2 n_plies = 4 pdl = np.array([[0, 1, 2, 3], [0, -1, 2, 3]]) ss_before = [np.array(()), np.array(())] ss_after = [np.array(()), np.array(())] bottom = False constraints = Constraints(sym=True, dam_tol=True, dam_tol_rule=2, delta_angle=45) print(f'mother_ss: {mother_ss}') print(f'child_ss: {child_ss}') print(f'mother_n_viola_diso: {mother_n_viola_diso}\n') print('outputs:\n') viola_diso = calc_n_viola_diso(mother_n_viola_diso, mother_ss, child_ss, level, n_panels, n_plies, pdl, constraints) print(f'viola_diso: {viola_diso}\n') print('*** Test for the function calc_penalty_diso_mp_0 ***\n') print('Inputs:\n') ss = [np.array([0, 90, 90]), np.array([0, 0, 0, 45, -45, 0])] delta_angle = 45 print(f'ss = {ss}, delta_angle = {delta_angle}\n') print('outputs:\n')
penalty_ipo_pc = np.zeros((n_plies_per_angle.shape[0], ), float) for ind_ss in range(n_plies_per_angle.shape[0]): my_sum = sum(n_plies_per_angle[ind_ss]) if my_sum: for ind_angle in range(constraints.angles_bal.shape[0]): penalty_ipo_pc[ind_ss] += abs( n_plies_per_angle[ind_ss][ constraints.angles_bal[ind_angle][1]] \ - n_plies_per_angle[ind_ss][ constraints.angles_bal[ind_angle][2]]) penalty_ipo_pc[ind_ss] /= my_sum return cummul_areas * penalty_ipo_pc if __name__ == "__main__": print('\n*** Test for the functions is_balanced***\n') constraints = Constraints(ipo=True, oopo=True) print( is_balanced(stack=np.array([0, 45, 90, -45, 60, 30, 12, -12, 13]), constraints=Constraints())) print('\n*** Test for the functions calc_penalty_bal***\n') n_plies_per_angle = np.array([0, 0, 1, 0]) constraints = Constraints(ipo=True, oopo=True) print(calc_penalty_bal(n_plies_per_angle, constraints)) n_plies_per_angle = np.array([[2, 1, 2, 2], [2, 1, 2, 2]]) constraints = Constraints(ipo=True, oopo=True) print(calc_penalty_bal(n_plies_per_angle, constraints))
if count_obj: return ss, n_obj_func_D_calls return ss if __name__ == "__main__": print('\n*** Test for the function repair_flexural ***') constraints = Constraints( sym=True, bal=True, ipo=True, dam_tol=False, rule_10_percent=True, diso=True, contig=True, delta_angle=45, n_contig=4, percent_0=10, percent_45=0, percent_90=10, percent_135=0, percent_45_135=10, set_of_angles=[0, 45, -45, 90, 30, -30, 60, -60, 15, -15, 75, -75]) parameters = Parameters(repair_flexural_switch=True, n_D2=2, constraints=constraints) ss = np.array([-60, -45, 90, 75, -75, -45, 0], int) if constraints.sym: ss = np.hstack((ss, np.flip(ss))) if not is_diso_ss(ss,
stack = np.hstack(( stack_dam_tol, remaining_plies[good_permut], stack, np.flip(remaining_plies[good_permut]), np.flip(stack_dam_tol))) if stack.size != ss.size: raise Exception('This should not happen') return stack, True if __name__ == "__main__": print('\n*** Test for repair_diso_contig_from_inside_sym ***') ss = np.array([0, 90, 45, 45, 666, 666, 666], int) ss = np.hstack((ss, 0, np.flip(ss))) constraints = Constraints( sym=True, dam_tol=True, diso=True, contig=True, delta_angle=45, n_contig=3, set_of_angles=[0, 45, -45, 90]) print_ss(ss, 40) n_D1 = 4 ply_queue = [-45, -45, 0] print('ss.size', ss.size) ss, completed = repair_diso_contig_from_inside_sym( ss, ply_queue, constraints, n_D1) print('Repair successful?', completed) print_ss(ss, 40)
# queue = [-30, 0, 60, -45, 60, -30, 60] # print(order_plies_to_test(adjacent_plies, queue, constraints)) # # print('\n*** Test for the function smallest_row ***') # permut = [[0, 2, 1], [2, 1, 0], [1, 2, 0], [0, 1, 2]] # print('best_permut', smallest_row(permut)) # print('expectecd best_permut', [0, 1, 2]) print('\n*** Test for the function initialise_repair_diso_contig ***') ss = np.arange(10) ss = np.hstack((ss, np.flip(ss))) print_ss(ss) constraints = Constraints(sym=False, dam_tol=True, dam_tol_rule=3, diso=True, contig=True, delta_angle=45, n_contig=3) from_inside = True n_D1 = 3 if constraints.sym and not from_inside: stack, ind_1, ind_2 = initialise_repair_diso_contig( ss, constraints, from_inside, n_D1) print('stack', end='') print_ss(stack, 40) elif not constraints.sym and not from_inside: stack_top, stack_bottom, ind_1, ind_2 \ = initialise_repair_diso_contig( ss, constraints, from_inside, n_D1)
A: {self.lampam_weightings_final[0]:.2f} {self.lampam_weightings_final[1]:.2f} {self.lampam_weightings_final[2]:.2f} {self.lampam_weightings_final[3]:.2f} B: {self.lampam_weightings_final[4]:.2f} {self.lampam_weightings_final[5]:.2f} {self.lampam_weightings_final[6]:.2f} {self.lampam_weightings_final[7]:.2f} D: {self.lampam_weightings_final[8]:.2f} {self.lampam_weightings_final[9]:.2f} {self.lampam_weightings_final[10]:.2f} {self.lampam_weightings_final[11]:.2f} """) class ParametersDefinitionError(Exception): pass if __name__ == "__main__": constraints = Constraints( sym=True, bal=True, ipo=True, dam_tol=False, rule_10_percent=True, diso=True, contig=True, delta_angle=45, n_contig=5, percent_0=10, percent_45=10, percent_90=10, percent_135=10, set_of_angles=[0, 45, -45, 90]) parameters = Parameters( constraints=constraints, first_level_sensitivities = np.array([ 8, 4, 2, 1, 0, 12, 0, 13, 0, 0, 0, 0]), lampam_to_be_optimised=np.array([ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0])) print(parameters)