def check_lay_up_rules(ss,
constraints,
no_ipo_check=False,
no_bal_check=False,
equality_45_135=False,
equality_0_90=False,
n_plies=None):
"""
checks the manufacturability of a stacking sequence
"""
if n_plies is not None and ss.size != n_plies:
raise Exception("Wrong number of plies")
if constraints.dam_tol:
if not is_dam_tol(ss, constraints):
print_ss(ss)
raise Exception("Damage tolerance constraint not satisfied")
if not no_bal_check and constraints.bal:
if not is_balanced(ss, constraints):
raise Exception("Balance constraint not satisfied")
if not no_ipo_check and constraints.ipo:
lampamA = calc_lampamA(ss, constraints)
if (abs(lampamA[2:4]) > 1e-10).any():
print_ss(ss)
print('lampamA', lampamA)
# print('ipo')
raise Exception("In plane orthotropy constraint not satisfied")
if constraints.diso:
if hasattr(constraints, 'dam_tol_rule'):
if not is_diso_ss(ss, constraints.delta_angle, constraints.dam_tol,
constraints.dam_tol_rule):
raise Exception("Disorientation constraint not satisfied")
else:
if not is_diso_ss(ss, constraints.delta_angle, constraints.dam_tol,
constraints.n_plies_dam_tol):
raise Exception("Disorientation constraint not satisfied")
if constraints.contig:
if not is_contig(ss, constraints.n_contig):
raise Exception("Contiguity constraint not satisfied")
if constraints.rule_10_percent:
if not is_ten_percent_rule(constraints,
stack=ss,
equality_45_135=equality_45_135,
equality_0_90=equality_0_90):
raise Exception("10% rule not satisfied")
return 0
ss = np.hstack((90*np.ones(27,), 45*np.ones(45,), 0*np.ones(28,)))
if ipop == 65:
ss = np.hstack((45*np.ones(21,), -45*np.ones(79,)))
# Complete the stacking sequence
#print(ipop)
ss.reshape((20,))
# print(ipop, ss.ndim, ss)
if ss.ndim == 2:
ss = np.hstack((ss, np.flip(ss, axis=1)))
else:
ss = np.hstack((ss, np.flip(ss, axis=0)))
# print(ss)
# For the 10# rule
if not is_ten_percent_rule(constraints, stack=ss):
raise Exception('Laminate violating the 10% rule at line ', ipop)
# For the contiguity and disorientation constraints
ss, _ = internal_diso_contig(ss, constraints)
if ss.size == 0:
raise Exception('Laminate violating disorientation or contiguity at line ', ipop)
# For the correct total number of plies
if ss.size != n_plies_in_panels:
print('ss.size', ss.size)
raise Exception('Laminate with incorrect ply count at line ', ipop)
# Storage of the stacking sequence
ss = np.ravel(ss)
N0 = sum(ss == 0)
p_A, lampam_target, constraints)
# print('\nSolution stacking sequence')
# print_ss(ss_list[0], 200)
# print('ply_queue', ply_queue_list[0])
# lampamA = lampamA_list[0]
# lampamA_check = calc_lampamA_ply_queue(ss, ss.size, ply_queue, constraints)
# if not (abs(lampamA_check - lampamA) < 1e-10).all():
# print()
# print('lampamA ', lampamA)
# print('lampamA_check', lampamA_check)
# print('lampam_target', lampam_target)
# print('\nSolution stacking sequence 0')
# print_ss(ss_list[0], 200)
# print(ply_queue_list[0], 200)
if not is_ten_percent_rule(
constraints, stack=ss_list[0], ply_queue=ply_queue_list[0]):
raise Exception('10% rule not satisfied membrane')
for ind in range(len(ss_list)):
print()
print('ss_list[ind]', ss_list[ind])
print('ply_queue_list[ind]', ply_queue_list[ind])
if not is_ten_percent_rule(
constraints, stack=ss_list[ind],
ply_queue=ply_queue_list[ind]):
raise Exception('10% rule not satisfied membrane')
popu.loc[ind, 'diso'] = is_diso_ss(stack,
delta_angle=constraints.delta_angle,
dam_tol=constraints.dam_tol,
dam_tol_rule=constraints.dam_tol_rule)
if (abs(lampam[2:4]) > 1e-10).any():
popu.loc[ind, 'ipo'] = False
else:
popu.loc[ind, 'ipo'] = True
if is_balanced(stack, constraints):
popu.loc[ind, 'balance'] = True
else:
popu.loc[ind, 'balance'] = False
if is_contig(stack, constraints.n_contig):
popu.loc[ind, 'contig'] = True
else:
popu.loc[ind, 'contig'] = False
if is_ten_percent_rule(constraints, stack=stack):
popu.loc[ind, 'rule_10_percent'] = True
else:
popu.loc[ind, 'rule_10_percent'] = False
save_constraints_LAYLA(filename, constraints)
save_materials(filename, mat_prop)
append_df_to_excel(filename, popu, 'stacks', index=True, header=True)
autofit_column_widths(filename)
def generate_ss_LAYLA(n_plies, constraints, not_constraints):
"""
randomly generates lamination parameters and retrieves stacking sequences
satisfying the design guidelines using LAYLA
Args:
n_plies (scalar): number of plies in the laminate
constraints (instance of the class Constraints): set of constraints
that must be satisfied
not_constraints (instance of the class Constraints): set of constraints
that must not be satisfied
Returns:
a manufacturable stacking sequence and its lamination parameters
created by the optimiser LAYLA aiming at matching lamination parameter
targets randomly generated
"""
if constraints.diso and not_constraints.diso:
raise Exception("""
Decide whether or not the stacking sequences must satisfy disorientation""")
if constraints.contig and not_constraints.contig:
raise Exception("""
Decide whether or not the stacking sequences must satisfy contiguity""")
if constraints.ipo and not_constraints.ipo:
raise Exception("""
Decide whether or not the stacking sequences must satisfy balance""")
if constraints.rule_10_percent and not_constraints.rule_10_percent:
raise Exception("""
Decide whether or not the stacking sequences must satisfy 10% rule""")
#==========================================================================
# LAYLA parameters
#==========================================================================
n_outer_step = 1
first_outer_loop_assumption = 'layerwise_QI'
method = 'beam_search' # with beam search
global_node_limit = 20
local_node_limit = 10
global_node_limit_p = 20
pseudo = True
repair_membrane_switch = True
repair_flexural_switch = True
penalty_10_pc_switch = False
penalty_10_lampam_switch = False
penalty_ipo_switch = True
penalty_bal_switch = False
balanced_scheme = False
coeff_10 = 1
coeff_bal_ipo = 1
coeff_oopo = 1
p_A = 100
n_D1 = 6
n_D2 = 10
group_size_min = 5
group_size_max = np.array([1000, 12, 12, 12, 12])
if constraints.set_of_angles is np.array([-45, 0, 45, 90], int):
lampam_to_be_optimised = np.array([1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0])
else:
lampam_to_be_optimised = np.array([1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1])
first_level_sensitivities = np.ones((12, ), float)
while True:
lampam_target = 2 * np.random.random_sample((12, )) - 1
# lampam_target = np.array([
# -0.25662112, -0.01727515, -0.73962959, 0.08359081,
# 0.43671968, -0.7901057, 0.98404481, 0.65070345,
# 0.97056517, 0.7023994, 0.32539113, -0.35851357])
# print('lampam_target', lampam_target)
parameters = Parameters(
constraints=constraints,
lampam_target=lampam_target,
coeff_10=coeff_10,
coeff_bal_ipo=coeff_bal_ipo,
coeff_oopo=coeff_oopo,
p_A\
=p_A,
n_D1=n_D1,
n_D2=n_D2,
n_outer_step=n_outer_step,
group_size_min=group_size_min,
group_size_max=group_size_max,
first_level_sensitivities=first_level_sensitivities,
lampam_to_be_optimised=lampam_to_be_optimised,
method=method,
first_outer_loop_assumption=first_outer_loop_assumption,
global_node_limit=global_node_limit,
local_node_limit=local_node_limit,
global_node_limit_p=global_node_limit_p,
pseudo=pseudo,
repair_membrane_switch=repair_membrane_switch,
repair_flexural_switch=repair_flexural_switch,
penalty_10_lampam_switch=penalty_10_lampam_switch,
penalty_10_pc_switch=penalty_10_pc_switch,
penalty_ipo_switch=penalty_ipo_switch,
penalty_bal_switch=penalty_bal_switch,
balanced_scheme=balanced_scheme)
try:
result = optimisation(parameters,
constraints,
np.copy(lampam_target),
n_plies,
not_constraints=not_constraints)
except SystemExit:
break
ss = result[0] # solution stacking sequence
lampam = result[1] # solution lamination parameters
if not ss.size == n_plies:
raise Exception('Wrong laminate ply count')
try:
check_lay_up_rules(ss, constraints)
except:
continue
if hasattr(constraints, 'dam_tol_rule'):
if not_constraints.diso and is_diso_ss(
ss,
not_constraints.delta_angle,
dam_tol=constraints.dam_tol,
dam_tol_rule=constraints.dam_tol_rule):
continue
else:
if not_constraints.diso and is_diso_ss(
ss,
not_constraints.delta_angle,
dam_tol=constraints.dam_tol,
n_plies_dam_tol=constraints.n_plies_dam_tol):
continue
if not_constraints.contig and is_contig(ss, not_constraints.n_contig):
continue
if not_constraints.rule_10_percent \
and is_ten_percent_rule(not_constraints, stack=ss):
continue
if not_constraints.ipo \
and abs(lampam[2]) < 1e-10 and abs(lampam[3]) < 1e-10:
continue
#
# if is_ten_percent_rule(not_constraints, stack=ss) \
# and abs(lampam[2]) < 1e-10 and abs(lampam[3]) < 1e-10:
# continue
break
return ss, lampam
def generate_ss_randomly(n_plies, constraints, not_constraints):
"""
randomly generates stacking sequences satisfying the design guidelines
INPUTS
n_plies: number of plies in the laminate
constraints: set of constraints that must be satisfied
not_constraints: set of constraints that must not be satisfied
"""
if constraints.diso and not_constraints.diso:
raise Exception("""
Decide whether or not the stacking sequences must satisfy disorientation""")
if constraints.contig and not_constraints.contig:
raise Exception("""
Decide whether or not the stacking sequences must satisfy contiguity""")
if constraints.ipo and not_constraints.ipo:
raise Exception("""
Decide whether or not the stacking sequences must satisfy balance""")
if constraints.rule_10_percent and not_constraints.rule_10_percent:
raise Exception("""
Decide whether or not the stacking sequences must satisfy 10% rule""")
if constraints.dam_tol and constraints.dam_tol_rule not in {1, 2}:
raise Exception("""
Only coded for damage tolerance rules 0, 1 and 2.""")
if not_constraints.rule_10_percent:
n_plies_0_lim = ma.ceil(not_constraints.percent_0 * n_plies)
n_plies_90_lim = ma.ceil(not_constraints.percent_90 * n_plies)
n_plies_45_lim = ma.ceil(not_constraints.percent_45 * n_plies)
n_plies_135_lim = ma.ceil(not_constraints.percent_135 * n_plies)
n_plies_45_135_lim = ma.ceil(not_constraints.percent_45_135 * n_plies)
if constraints.sym:
n_plies_0_lim = ma.ceil(n_plies_0_lim / 2)
n_plies_90_lim = ma.ceil(n_plies_90_lim / 2)
n_plies_45_lim = ma.ceil(n_plies_45_lim / 2)
n_plies_135_lim = ma.ceil(n_plies_135_lim / 2)
n_plies_45_135_lim = ma.ceil(n_plies_45_135_lim / 2)
# print('n_plies_0_lim', n_plies_0_lim)
# print('n_plies_45_lim', n_plies_45_lim)
while True:
ss = np.array((), int)
n0 = 0
n90 = 0
if not_constraints.rule_10_percent:
random_for_10 = random.randint(0, 4)
if constraints.dam_tol:
if constraints.dam_tol_rule == 1:
reduced_n_plies = n_plies - 2
if random.randint(0, 1):
ss = np.array(([45]), int)
if constraints.sym:
n45 = 2
n135 = 0
else:
n45 = 4
n135 = 0
else:
ss = np.array(([-45]), int)
if constraints.sym:
n45 = 0
n135 = 2
else:
n45 = 0
n135 = 4
elif constraints.dam_tol_rule == 2:
reduced_n_plies = n_plies - 4
if random.randint(0, 1):
ss = np.array(([45, -45]), int)
else:
ss = np.array(([-45, 45]), int)
if constraints.sym:
n45 = 2
n135 = 2
else:
n45 = 4
n135 = 4
else:
reduced_n_plies = n_plies
n45 = 0
n135 = 0
if constraints.sym:
reduced_n_plies //= 2
if constraints.dam_tol and constraints.dam_tol_rule == 2:
ss = ss[1:]
for ind in range(reduced_n_plies):
angle_added = False
for angle in np.random.permutation(constraints.set_of_angles):
ss_test = np.hstack((ss, angle))
# print_ss(ss_test)
if internal_diso_contig(ss_test, constraints)[0].size == 0:
continue
if not_constraints.rule_10_percent:
if random_for_10 == 0 and n0 + 1 >= n_plies_0_lim:
continue
if random_for_10 == 1 and n90 + 1 >= n_plies_90_lim:
continue
if random_for_10 == 2 and n45 + 1 >= n_plies_45_lim:
continue
if random_for_10 == 3 and n135 + 1 >= n_plies_135_lim:
continue
if random_for_10 == 4 \
and n45 + n135 + 1 >= n_plies_45_135_lim:
continue
angle_added = True
if angle == 0:
n0 += 1
elif angle == 90:
n90 += 1
elif angle == 45:
n45 += 1
elif angle == -45:
n135 += 1
ss = ss_test
# print_ss(ss)
break
if not angle_added:
break
if not angle_added:
continue
if constraints.dam_tol and constraints.dam_tol_rule == 2:
ss = ss = np.hstack((-np.array(ss[0]), ss))
if constraints.sym:
if n_plies % 2:
if random.randint(0, 1):
ss = np.hstack((ss, 0, np.flip(ss)))
n0 += 1
else:
ss = np.hstack((ss, 90, np.flip(ss)))
n90 += 1
else:
ss = np.hstack((ss, np.flip(ss)))
else:
if constraints.dam_tol:
if random.randint(0, 1):
ss = np.hstack((ss, 45, -45))
else:
ss = np.hstack((ss, -45, 45))
if not ss.size == n_plies:
raise Exception('Wrong laminate ply count')
try:
check_lay_up_rules(ss, constraints)
except:
continue
if hasattr(constraints, 'dam_tol_rule'):
if not_constraints.diso and is_diso_ss(
ss,
not_constraints.delta_angle,
dam_tol=constraints.dam_tol,
dam_tol_rule=constraints.dam_tol_rule):
continue
else:
if not_constraints.diso and is_diso_ss(
ss,
not_constraints.delta_angle,
dam_tol=constraints.dam_tol,
n_plies_dam_tol=constraints.n_plies_dam_tol):
continue
if not_constraints.contig and is_contig(ss, not_constraints.n_contig):
continue
if not_constraints.rule_10_percent \
and is_ten_percent_rule(not_constraints, stack=ss):
continue
lampam = calc_lampam(ss)
if not_constraints.bal \
and abs(lampam[2]) < 1e-10 and abs(lampam[3]) < 1e-10:
continue
break
return ss, lampam
def test_is_ten_percent_rule(constraints, stack, ply_queue, n_plies_per_angle,
equality_45_135, equality_0_90, expect):
output = is_ten_percent_rule(constraints, stack, ply_queue,
n_plies_per_angle, equality_45_135,
equality_0_90)
assert output == expect