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)
