else:
raise Exception(
'constraints.n_contig must be 2, 3, 4 or 5')
return angle, angle2
if __name__ == "__main__":
'Test'
import sys
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.divers.pretty_print import print_ss, print_list_ss
constraints = Constraints()
constraints.contig = True
constraints.n_contig = 2
print('*** Test for the function external_contig ***\n')
print('Input stacking sequences:\n')
ss = np.array([[-45, -45, 0, 45, 90], [0, 45, 45, 45, 45],[0, 0, 0, 45, 45]])
print_list_ss(ss)
print('Stacking sequence of adajacent sublaminate:\n')
ss_before = np.array([-45])
print_ss(ss_before)
n_plies_group = 5
middle_ply = 0
test, _ = external_contig(ss, n_plies_group, constraints, ss_before, ss)
if test.shape[0]:
print('Stacking sequences satisfying the rule:\n')
n_plies_per_angle = np.copy(n_plies_per_angle_ini)
for ind_ply in range(angle.shape[1]):
index = constraints.ind_angles_dict[angle[ind_ss, ind_ply]]
n_plies_per_angle[index] += 1
for ind_ply in range(angle2.shape[1]):
index = constraints.ind_angles_dict[angle2[ind_ss, ind_ply]]
n_plies_per_angle[index] += 1
if middle_ply != 0:
index = constraints.ind_angles_dict[angle[ind_ss, -1]]
n_plies_per_angle[index] -= 1 / 2
n_plies_per_angle_tab[ind_ss] = n_plies_per_angle
return n_plies_per_angle_tab
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
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))
print('outputs:\n')
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')
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,
n_plies=n_plies,
angle_before=None, # last group has only one neighbour
angle_after=ss_ref[ind_start + n_block_of_plies],
constraints=constraints)
list_blocks.append(new_block)
list_blocks.sort(key=operator.attrgetter('distance_middle'), reverse=True)
return list_blocks
if __name__ == "__main__":
print('\n*** Test for the function find_list_blocks ***')
constraints = Constraints(
sym=False,
contig=True,
diso=True,
n_contig=4,
delta_angle=45,
set_of_angles=[0, 45, -45, 90, 30, -30, 60, -60, 15, -15, 75, -75])
print('Initial stacking sequence')
ss = np.array([-75, -45, -60, -30, 0], int)
if constraints.sym:
ss = np.hstack((ss, 90, np.flip(ss)))
print_ss(ss, 40)
n_plies = ss.size
list_blocks = find_list_blocks(ss, n_plies, constraints)
for elem in list_blocks:
print(elem)
print('\n*** Test for the function calc_delta_lampamD_swap ***\n')
constraints = Constraints(sym=False)
# 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_2 ***')
constraints = Constraints(
sym=True,
dam_tol=False,
diso=True,
contig=True,
delta_angle=45,
n_contig=4,)
parameters = Parameters(
repair_flexural_switch=True, n_D2=3, constraints=constraints)
ss = np.array([45, 0, 45, 90, -45, -45, 0], int)
if constraints.sym:
ss = np.hstack((ss, np.flip(ss)))
print('\nInitial stacking sequence')
print_ss(ss, 80)
print(ss.size)
ss_target = 0*np.ones((1,), dtype=int)
lampam_target = calc_lampam(ss_target)
out_of_plane_coeffs = np.array([1/3, 1/3, 1/3, 0])
ss = repair_flexural_2(
stack = np.hstack((stack, remaining_plies[good_permut]))
if ss.size % 2:
stack = np.hstack((stack, ss[ss.size // 2], np.flip(stack)))
else:
stack = np.hstack((stack, np.flip(stack)))
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_sym ***')
constraints = Constraints(
sym=True,
bal=False,
ipo=False,
dam_tol=False,
diso=True,
contig=True,
delta_angle=45,
n_contig=5,
set_of_angles=[0, 45, -45, 90, 30, -30, 60, -60, 75, -75, 15, -15])
ss = np.array([0, 45, -45, 666, 666, 666, 666], int)
ss = np.hstack((ss, np.flip(ss)))
ply_queue = [-45, 90, 90, 90]
print_ss(ss, 40)
n_D1 = 3
print('ss.size', ss.size)
ss, completed = repair_diso_contig_from_outside_sym(
ss, ply_queue, constraints, n_D1)
print('Repair successful?', completed)
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)
Tests for functions calculating lamination parameters
"""
__version__ = '2.0'
__author__ = 'Noemie Fedon'
import sys
import pytest
import numpy as np
sys.path.append(r'C:\LAYLA')
from src.CLA.lp_functions_2 import calc_lampamA, calc_lampamD
from src.LAYLA_V02.constraints import Constraints
# test 1
constraints1 = Constraints(
sym=False,
set_of_angles=np.array([0, 45, 90, -45]))
stack1 = np.array([0, 0, 0, 0, 0, 0, 0, 0], int)
lampam1A = np.array([1, 1, 0, 0], float)
lampam1D = np.array([1, 1, 0, 0], float)
# test 2
constraints2 = Constraints(
sym=True,
set_of_angles=np.array([0, 45, 90, -45]))
stack2 = np.array([90, 0, 0, 0, 90], int)
lampam2A = np.array([0.2, 1, 0, 0], float)
lampam2D = np.array([-0.568, 1, 0, 0], float)
@pytest.mark.parametrize(
"""stack, constraints, expect""", [
print(
"""*** Test for the functions calc_penalty_ipo_param and ipo_param***\n"""
)
param = ipo_param_1_6(lampam, mat, sym)
print(f'In-plane orthotropy parameters = \n {param[0:6]}\n')
print(f'calc_penalty_ipo : {calc_penalty_ipo_param(param, threshold)}\n')
param = ipo_param_7_12(lampam, mat, sym)
print(f'In-plane orthotropy parameters = \n {param[0:6]}\n')
print(f'calc_penalty_ipo : {calc_penalty_ipo_param(param, threshold)}\n')
param = ipo_param_1_12(lampam, mat, sym)
print(
f'In-plane orthotropy parameters = \n {param[0:6]} \n{param[6:12]}\n')
print(f'calc_penalty_ipo : {calc_penalty_ipo_param(param, threshold)}\n')
print('\n*** Test for the functions calc_penalty_ipo_oopo_mp***\n')
constraints = Constraints(bal=True, oopo=True)
lampam = 0.22 * np.ones((2, 12))
print(calc_penalty_ipo_oopo_mp(lampam, constraints=constraints))
print('\n*** Test for the functions calc_penalty_ipo_oopo_ss***\n')
constraints = Constraints(bal=True, oopo=True)
parameters = Parameters(constraints)
lampam = 0.22 * np.ones((2, 12))
lampam_target = 0.11 * np.ones((12, ))
lampam_weightings = np.ones((12, ), dtype=float)
mat = Material()
print(
calc_penalty_ipo_oopo_ss(lampam,
constraints=constraints,
parameters=parameters,
cummul_areas=4,
"""
__version__ = '1.0'
__author__ = 'Noemie Fedon'
import sys
import pytest
import numpy as np
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.guidelines.balance import is_balanced
from src.guidelines.balance import calc_penalty_bal
@pytest.mark.parametrize("stack, constraints, expect",
[(np.array([0, 45, 90]), Constraints(), False),
(np.array([0, 45, 90, -45]), Constraints(), True)])
def test_is_balanced(stack, constraints, expect):
output = is_balanced(stack, constraints)
assert output == expect
@pytest.mark.parametrize(
"n_plies_per_angle, constraints, cummul_areas, expect",
[(np.array([0, 0, 1, 0]), Constraints(), 1, 1.),
(np.array([0, 0, 2, 0]), Constraints(), 0.5, 0.5),
(np.array([[0, 0, 2, 0], [0, 2, 2, 0]
]), Constraints(), 1, np.array([1., 0.5]))])
def test_calc_penalty_bal(n_plies_per_angle, constraints, cummul_areas,
expect):
output = calc_penalty_bal(n_plies_per_angle, constraints, cummul_areas)
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}')
INPUTS
- ply_order: array of the ply indices sorted in the order in which plies
are optimised (middle ply of symmetric laminates included)
- n_plies_in_groups: number of plies in each ply group
- n_groups: number of ply groups
"""
levels_in_groups = [None] * n_groups
for ind_group in range(n_groups):
levels_in_groups[ind_group] = []
ind_all_plies = 0
for ind_group in range(n_groups):
for ind_plies in range(n_plies_in_groups[ind_group]):
levels_in_groups[ind_group].append(ply_order[ind_all_plies])
ind_all_plies += 1
return levels_in_groups
if __name__ == "__main__":
import sys
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.parameters import Parameters
from src.LAYLA_V02.constraints import Constraints
from src.LAYLA_V02.targets import Targets
constraints = Constraints(sym=False)
targets = Targets(n_plies=6)
ply_order = calc_ply_order(constraints, targets)
print(ply_order)
ss, inward = repair_diso_contig_from_outside_asym(ss, ply_queue,
constraints, n_D1)
if not inward:
ss, outward = repair_diso_contig_from_inside_asym(
ss, ply_queue, constraints, n_D1)
return ss, inward, outward
return ss, inward, True
if __name__ == "__main__":
print('\n*** Test for the function repair_diso_contig ***')
constraints = Constraints(sym=True,
ipo=False,
dam_tol=False,
rule_10_percent=False,
diso=True,
contig=True,
delta_angle=45,
n_contig=4,
set_of_angles=[0, 45, -45, 90])
ss_ini = np.array([0, 45, -45, 666, 666, 666, 666], int)
ss_ini = np.hstack((ss_ini, np.flip(ss_ini)))
print_ss(ss_ini, 40)
print('ss_ini.size', ss_ini.size)
n_D1 = 6
ply_queue = [-45, 90, 90, 90]
ss, inward, outward = repair_diso_contig(ss_ini, ply_queue, constraints,
n_D1)
print('Inward repair successful?', inward)
print('Outward repair successful?', outward)
print_ss(ss, 40)
equality_0_90=equality_0_90):
raise Exception("10% rule not satisfied")
return 0
if __name__ == "__main__":
print('\n*** Test for the function check_lay_up_rules ***')
constraints = Constraints(sym=True,
bal=True,
ipo=True,
oopo=False,
dam_tol=False,
rule_10_percent=True,
percent_0=10,
percent_45=0,
percent_90=10,
percent_135=0,
percent_45_135=10,
diso=True,
contig=True,
n_contig=5,
delta_angle=45,
set_of_angles=np.array([0, 45, -45, 90]))
ss = np.array([
0, 0, 0, 0, 0, -45, 0, 0, 0, 0, 0, -45, 0, 0, 0, 0, 0, -45, 0, 0, 0, 0,
0, -45, 0, 0, 0, 0, 0, 45, 0, 0, 0, 45, 0, 0, 0, 0, 45, 90, 90, 90, 90,
90, -45, 90, 90, 90, 90, 45, 0, 0, 0, 0, 0, 45, 0, 0, 0, 0, -45, 90,
90, 90, 90, 90, -45, 90, 90, 90, 90, 90, 45, 0, 0, 45, 90, 90, 90, 90,
45, 0, 0, 0, 0, 0, -45, 0, 0, 0, 0, 0, 45, 90, 90, 90, -45, 0, 0, 45,
45, 0, 0, -45, 90, 90, 90, 45, 0, 0, 0, 0, 0, -45, 0, 0, 0, 0, 0, 45,
90, 90, 90, 90, 45, 0, 0, 45, 90, 90, 90, 90, 90, -45, 90, 90, 90, 90,
# print('''
#The number of plies of the last group (parameters.group_size_max) is
#recommended to be equal to or greater than 5.
#''')
if n_groups > maxi:
raise PartitioningError('''
No partition possible of the plies into groups of smaller size
parameters.group_size_minand bigger size parameters.group_size_max.
Increase parameters.group_size_max or decrease parameters.group_size_min.
''')
return n_plies_in_groups, pos_first_ply_groups, n_groups
if __name__ == "__main__":
import sys
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.LAYLA_V02.parameters import Parameters
from src.LAYLA_V02.targets import Targets
constraints = Constraints(sym=False, bal=True)
targets = Targets(n_plies=200)
parameters = Parameters(
constraints=constraints,
n_outer_step=5,
group_size_min=3,
group_size_max=6)
n_plies_in_groups, pos_first_ply_groups, n_groups \
= divide_laminate_asym(parameters, targets)
print(n_plies_in_groups)
print(pos_first_ply_groups)
print(n_groups)
pos_mom_areas = np.array([
(abs(pos_top[-1]) + abs(pos_bot[-1])) / 2,
(abs(pos_top[-1]**2) + abs(pos_bot[-1]**2)) / 2,
(abs(pos_top[-1]**3) + abs(pos_bot[-1]**3)) / 2
])
cummul_mom_areas[-1, :] += pos_mom_areas
mom_areas_ply_group += pos_mom_areas
group_mom_areas[-1, :] += mom_areas_ply_group
return mom_areas, cummul_mom_areas, group_mom_areas
if __name__ == "__main__":
print('*** Test for the functions calc_moment_of_areas ***\n')
import sys
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.LAYLA_V02.targets import Targets
from src.LAYLA_V02.ply_order import calc_ply_order
constraints = Constraints(sym=True)
targets = Targets(n_plies=21)
ply_order = calc_ply_order(constraints, targets)
n_plies_in_groups = np.array([5, 6])
mom_areas, cummul_mom_areas, group_mom_areas = calc_mom_of_areas(
constraints, targets, ply_order, n_plies_in_groups)
print(mom_areas)
print(cummul_mom_areas)
print(group_mom_areas, sum(group_mom_areas))
else:
raise Exception(
'constraints.n_contig must be 2, 3, 4 or 5')
return angle, angle2
if __name__ == "__main__":
'Test'
import sys
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.divers.pretty_print import print_ss, print_list_ss
constraints = Constraints()
constraints.diso = True
constraints.delta_angle = 45
constraints.contig = True
constraints.n_contig = 2
print('*** Test for the function external_diso_contig ***\n')
print('Input stacking sequences:\n')
ss = np.array([[-45, -45, 0, 45, 90],
[0, 45, 45, 45, 45],
[0, 0, 0, 45, 45]])
print_list_ss(ss)
print('Stacking sequence of adajacent sublaminate:\n')
ss_before = np.array([-45])
print_ss(ss_before)
n_plies_group = 5
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]
contig = True
n_contig = 4
# No more that constraints.n_contig plies with same fibre orientation should be
# next to each other if the contiguity constraint is active. The value taken
# can only be 2, 3, 4 or 5, otherwise test functions should be modified
constraints = Constraints(sym=sym,
bal=bal,
ipo=ipo,
oopo=oopo,
dam_tol=dam_tol,
dam_tol_rule=dam_tol_rule,
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,
combine_45_135=combine_45_135,
diso=diso,
contig=contig,
n_contig=n_contig,
delta_angle=delta_angle,
set_of_angles=set_of_angles)
#==============================================================================
# Material properties
#==============================================================================
# Elastic modulus in the fibre direction (Pa)
E11 = 130e9
# Elastic modulus in the transverse direction (Pa)
# - * - coding: utf - 8 - * -
"""
This module tests the functions in dam_tol.py.
"""
__version__ = '1.0'
__author__ = 'Noemie Fedon'
import sys
import pytest
import numpy as np
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.guidelines.dam_tol import is_dam_tol
@pytest.mark.parametrize("stack, constraints, expect", [
(np.array([45, 0, -45]), Constraints(dam_tol=True, dam_tol_rule=1), True),
(np.array([45, 0, 0]), Constraints(dam_tol=True, dam_tol_rule=1), False),
(np.array([45, -45, 0, 45, -45]), Constraints(dam_tol=True,
dam_tol_rule=2), True),
(np.array([45, -45, 0, 90, -45]), Constraints(dam_tol=True,
dam_tol_rule=2), False),
])
def test_is_dam_tol(stack, constraints, expect):
output = is_dam_tol(stack, constraints)
assert output == expect
return stack, False
ss_group = remaining_plies[good_permut]
stack = np.hstack((stack_top, ss_group[:real_n_D1 // 2], stack,
ss_group[real_n_D1 // 2:], 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_inside_asym ***')
ss_ini = np.array([
90, -45, -45, 0, 0, -45, -45, 0, 45, 90, 90, 90, 90, -45, 0, 45, 0,
-45, 90, -45, 90, 45, 90, 90, 90, 90, -45, -45, -45, 0, 0, -45, -45,
90, -45, -45, 0, -45, -45, 0, 0, 0, 45, 45, 0, 45, 45, 0, 45, 0
], int)
constraints = Constraints(sym=False,
dam_tol=True,
diso=True,
contig=True,
delta_angle=45,
n_contig=4,
set_of_angles=[0, 45, -45, 90])
print_ss(ss_ini, 200)
n_D1 = 4
ply_queue = []
print('ss_ini.size', ss_ini.size)
ss, completed = repair_diso_contig_from_inside_asym(
ss_ini, ply_queue, constraints, n_D1)
print('Repair successful?', completed)
print_ss(ss - ss_ini, 200)
# 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:
#
# FIXED VALUES
# do not change it
#
# ----- ----- ----- ----- ----- ----- -----
set_of_angles= np.array([-45, 0, 45, 90], dtype=int)
constraints = Constraints(
sym=sym,
bal=bal,
dam_tol = dam_tol,
rule_10_percent = rule_10_percent,
ply_counts = ply_counts,
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)
#print(constraints)
Pop = pd.DataFrame()
# Initialisation
print(' Creating Pop ... ')
ipop = 1
__version__ = '1.0'
__author__ = 'Noemie Fedon'
import sys
import pytest
import numpy as np
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.guidelines.ten_percent_rule import is_ten_percent_rule
@pytest.mark.parametrize(
"""constraints, stack, ply_queue, n_plies_per_angle, equality_45_135,
equality_0_90, expect""",
[(Constraints(rule_10_percent=True, percent_0=50),
np.array([0, 45, 90], int), [], None, False, False, False),
(Constraints(rule_10_percent=True, percent_0=50),
np.array([0, 45, 90], int), None, None, False, False, False),
(Constraints(rule_10_percent=True, percent_0=50),
np.array([0, 666, 666], int), [0, 45], None, False, False, True),
(Constraints(rule_10_percent=True, percent_0=50), None, None,
np.array([3, 0, 3, 0]), False, False, False),
(Constraints(rule_10_percent=True, percent_0=50), None, None,
np.array([0, 3, 0, 3]), False, False, True)])
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