def test_Laminate_eq1(): '''Compare 5-ply to self should be True; testing == of LaminateModels''' case1 = ut.laminator('400-[200]-800') case2 = ut.laminator('400-200-800') standard = [LM for case_ in case1.values() for LM in case_.LMs] unconventional = [LM for case_ in case2.values() for LM in case_.LMs] # Internal converts unconventional string to be equivalent to standard. actual = (standard[0] == unconventional[0]) nt.assert_true(actual)
def test_Laminate_ne1(): '''Compare 5-ply to even plies should be False; testing != of LaminateModels''' case1 = ut.laminator(dft.geos_standard) cases1 = ut.laminator(dft.geos_even) standard = [LM for case_ in case1.values() for LM in case_.LMs] for case in cases1.values(): for even_LM in case.LMs: actual = (even_LM != standard[0]) print(even_LM) print(standard[0]) print(actual) nt.assert_true(actual)
def test_Laminate_attr_extrema(): case1 = ut.laminator(dft.geos_full, ps=[5]) case2 = ut.laminator(dft.geos_full, ps=[2]) for case_full, case_trimmed in zip(case1.values(), case2.values()): for LM_full, LM_trimmed in zip(case_full.LMs, case_trimmed.LMs): actual = LM_full.extrema actual.reset_index(drop=True, inplace=True) expected = LM_trimmed.LMFrame #print(actual) #print(expected) ut.assertFrameEqual(actual, expected)
def test_theories_FeatureInput_globals1(): '''Check globals are correct in updated FeatureInput for 400-[200]-800 post-theories.''' case = ut.laminator(geos=dft.geos_standard) for case_ in case.values(): for LM in case_.LMs: actual = LM.FeatureInput # updated FeatureInput expected = {'Geometry': LM.Geometry, 'Parameters': {'P_a': 1, 'R': 0.012, 'a': 0.0075, 'p': 5, 'r': 2e-4}, 'Properties': LM.mat_props, 'Materials': LM.materials, 'Model': 'Wilson_LT', 'Globals': {'D_11T': 31.664191802890315, 'D_12T': 7.9406108505093584, 'D_11p': 0.033700807714524279, 'D_12n': -0.0084513446948124519, 'M_r': 0.15666895161350616, 'M_t': 0.216290324549788, 'K_r': 0.0034519261262397653, 'K_t:': 0.0059650953251038216, 'v_eq ': 0.25077573114575868}, } #print(actual) #print(expected) #assert actual == expected '''Refactor dict comparison''' ##del actual['Materials'] ##del expected['Materials'] nt.assert_equal(actual, expected)
def test_distribplot_instance1(): '''Check distribplot returns an axes.''' case = ut.laminator(['400-200-800'])[0] plot = la.output_._distribplot(case.LMs, normalized=True, extrema=True) nt.assert_is_instance(plot, mpl.axes.Axes) plt.close()
def test_distribplot_input_error2(): '''Check still looks for stress column, even if bad x column name given.''' x_col = 'bad_column_name' case = ut.laminator(['400-200-800'])[0] plot = la.output_._distribplot(case.LMs, x=x_col) nt.assert_is_instance(plot, mpl.axes.Axes) plt.close()
def test_getmultigeo1(): '''Check strings are extracted from a "multi" laminate Frame, nplies >= 5.''' case = ut.laminator(['400-200-800']) for case_ in case.values(): for LM in case_.LMs: actual = ut.get_multi_geometry(LM.LMFrame) #expected = '400-[200]-800' # pre to_gen_convention() expected = '400.0-[200.0]-800.0' nt.assert_equal(actual, expected)
def test_getspecialgeo1(): '''Check strings are extracted from a special laminate Frame, nplies <= 4.''' case = ut.laminator(['400-200-0']) for case_ in case.values(): for LM in case_.LMs: actual = ut.get_special_geometry(LM.LMFrame) ##expected = '400-[200]-0' # pre to_gen_convention() expected = '400.0-[200.0]-0.0' nt.assert_equal(actual, expected)
def test_distribplot_annotate1(): '''Check iif text exists on the plot when annotate=True.''' case = ut.laminator(['400-200-800'])[0] plot = la.output_._distribplot(case.LMs, annotate=True) actual = upt.has_annotations(plot.texts) nt.assert_true(actual) plt.close()
def test_laminator_type3(): '''Check defaults triggerd if nothing is passed in.''' case1 = ut.laminator() LM = case1[0] actual = LM.frames[0] case2 = la.distributions.Case(dft.load_params, dft.mat_props) case2.apply(['400-200-800']) expected = case2.frames[0] ut.assertFrameEqual(actual, expected)
def test_distribplot_annotate2(): '''Check ift text exists; return False when annotate=False''' case = ut.laminator(['400-200-800'])[0] plot = la.output_._distribplot(case.LMs, annotate=False) actual = upt.has_annotations(plot.texts) nt.assert_false(actual) plt.close()
def test_laminator_gencon1(): '''Check returns a geometry string in General Convention; converts 'S'.''' case = ut.laminator(['400-0-400S']) for case_ in case.values(): for LM in case_.LMs: actual = ut.get_special_geometry(LM.LMFrame) ##expected = '400-[0]-800' # pre to_gen_convention() expected = '400.0-[0.0]-800.0' nt.assert_equal(actual, expected)
def test_models_WisonLT_diameter1(): '''Check the support radius, a, is smaller than the sample radius, R.''' case = ut.laminator(geos=dft.geos_standard) for case_ in case.values(): for LM in case_.LMs: actual = LM.FeatureInput['Parameters']['a'] expected = LM.FeatureInput['Parameters']['R'] #assert actual < expected nt.assert_less(actual, expected)
def test_theories_FeatureInput_globels2(): '''Globals stay None if p=1, post LMFrame processing.''' # TODO: Opportunity to use a select method for p spefically. case = ut.laminator(geos=dft.geos_standard, ps=[1]) for case_ in case.values(): for LM in case_.LMs: actual = LM.FeatureInput['Globals'] expected = None #print(LM.FeatureInput) nt.assert_equal(actual, expected)
def test_extract_equivalence4(): '''Given a case, line plot data agrees with the DataFrame data; {extrema,normalized}=False.''' case = ut.laminator(['400-[200]-800']) # unnormalized multiplot requires only one geoemetry line_df_case = upt.extract_plot_LM_xy(case, extrema=False, normalized=False) line_data, df_data = line_df_case actual = line_data expected = df_data nt.assert_equal(actual, expected)
def test_extract_equivalence2(): '''Given a case, line plot data agrees with the DataFrame data; extrema=True.''' case = ut.laminator(['400-[200]-800', '400-[400]-400']) line_df_case = upt.extract_plot_LM_xy(case, extrema=True) line_data, df_data = line_df_case actual = line_data expected = df_data nt.assert_equal(actual, expected)
def test_Laminate_compare_sets1(): '''Check __eq__, __ne__ and sets containing Laminate object instances.''' # Tests __hash__ cases1 = ut.laminator(dft.geo_inputs['5-ply']) cases2 = ut.laminator(dft.geo_inputs['1-ply']) LM1 = cases1[0].LMs[0] # 400-200-800 LM2 = cases1[0].LMs[1] # 400-[200]-800 LM3 = cases1[0].LMs[2] # 400-[200]-400S LM4 = cases2[0].LMs[0] # 0-0-2000 #assert set([LM1]) == set([LM1]) #assert set([LM1]) == set([LM2]) #assert set([LM1]) != set([LM3]) #assert set([LM1]) != set([LM4]) nt.assert_set_equal(set([LM1, LM2]), set([LM1, LM2])) nt.assert_set_equal(set([LM1]), set([LM2])) nt.assert_set_equal(set([LM2]), set([LM1])) nt.assert_true(set([LM1]) != set([LM3])) nt.assert_true(set([LM1]) != set([LM4])) nt.assert_equal(len(set([LM1,LM2,LM3,LM4])), 3)
def test_models_WisonLT_r1(): '''Check singularity in log of moment eqn when r = 0; ZeroDivisionError.''' zero_r = {'R' : 12e-3, # specimen radius 'a' : 7.5e-3, # support ring radius 'p' : 5, # points/layer 'P_a' : 1, # applied load 'r' : 0, # # radial distance from center loading } case = ut.laminator(geos=dft.geos_standard, load_params=zero_r) for case_ in case.values(): for LM in case_.LMs: actual = LM.LMFrame
def test_models_WisonLT_a2(): '''Check the singularity in log of moment eqn when support radius, a < 0; ValueError.''' neg_a = {'R' : 12e-3, # specimen radius 'a' : -7.5e-3, # # support ring radius 'p' : 5, # points/layer 'P_a' : 1, # applied load 'r' : 2e-4, # radial distance from center loading } case = ut.laminator(geos=dft.geos_standard, load_params=neg_a) for case_ in case.values(): for LM in case_.LMs: actual = LM.LMFrame
def test_laminator_consistency1(): '''Check laminator yields same LMFrame as classic case building.''' case = ut.laminator(geos=dft.geos_all, ps=[5]) for case_ in case.values(): case1 = case_ case2 = la.distributions.Case(load_params, mat_props) case2.apply(dft.geos_all) #print(case1) #print(case2) ##for actual, expected in zip(case1, case2.LMs): for actual, expected in zip(case1.LMs, case2.LMs): #print(actual) #print(expected) ut.assertFrameEqual(actual.LMFrame, expected.LMFrame)
def test_theories_FeatureInput_differ(): '''Check last FeatureInput Geometry in a case differfrom random others.''' case = ut.laminator(dft.geos_full) LM = [LM for case_ in case.values() for LM in case_.LMs] actual1 = LM[4].FeatureInput['Geometry'] actual2 = LM[2].FeatureInput['Geometry'] expected1 = la.input_.Geometry('400-[200]-800') expected2 = la.input_.Geometry('600-[0]-800') last_item = LM[-1].FeatureInput['Geometry'] nt.assert_equal(actual1, expected1) nt.assert_equal(actual2, expected2) nt.assert_not_equal(actual1, last_item) nt.assert_not_equal(actual2, last_item)
def test_theories_Exception_default1(): '''Check LMFrame is set by LFrame if exception raised.''' # Force an exception in Wilson_LT; r must be non-zero zero_r = {'R' : 12e-3, # specimen radius 'a' : 7.5e-3, # support ring radius 'p' : 5, # points/layer 'P_a' : 1, # applied load 'r' : 0, # # radial distance from center loading } case = ut.laminator(geos=dft.geos_standard, load_params=zero_r) for case_ in case.values(): for LM in case_.LMs: actual = LM.LMFrame expected = LM.LFrame #print(actual) # should get LFrame ut.assertFrameEqual(actual, expected)
def test_theories_FeatureInput_consistency1(): '''Check FeatureInput from classic case building is consistent with utils tools automatic case building, post-theories.''' case1 = la.distributions.Case(dft.load_params, dft.mat_props) case1.apply(dft.geos_standard) # classic case build case2 = ut.laminator(geos=dft.geos_standard) # auto case build LM = case1.LMs[0] ##del LM.FeatureInput['Geometry'] # comp. unsupported 0.4.3d ##del LM.FeatureInput['Materials'] expected = LM.FeatureInput for case_ in case2.values(): for LM in case_.LMs: ##del LM.FeatureInput['Geometry'] ##del LM.FeatureInput['Materials'] actual = LM.FeatureInput # updated FeatureInput #print(actual) #print(expected) nt.assert_equal(actual, expected)
def test_models_WisonLT_a3(): '''Raise exception if support radius, a, is larger than the sample radius, R. See Also -------- - test_models_WisonLT_diameter1() ''' big_a = { 'R': 12e-3, # specimen radius 'a': 7.5, # support ring radius 'p': 5, # points/layer 'P_a': 1, # applied load 'r': 2e-4, # radial distance from center loading } case = ut.laminator(geos=dft.geos_standard, load_params=big_a) for case_ in case.values(): for LM in case_.LMs: actual = LM.FeatureInput['Parameters']['a'] expected = LM.FeatureInput['Parameters']['R'] #assert actual < expected nt.assert_less(actual, expected)
def test_theories_matl_order1(): '''Check the material stack order is correct in LMFrame.''' # Amend geometry inputs even and dissimilar dft.geos_full.append(dft.geos_even[0]) case = ut.laminator(geos=dft.geos_full) expected_mix = [['HA'], ['HA', 'PSu'], ['HA', 'PSu', 'HA'], ['HA', 'PSu', 'HA', 'PSu'], ['HA', 'PSu', 'HA', 'PSu', 'HA'], ['HA', 'PSu', 'HA', 'PSu', 'HA', 'PSu'], ['HA', 'PSu', 'HA', 'PSu', 'HA', 'PSu', 'HA',], ['HA', 'PSu', 'HA', 'PSu', 'HA', 'PSu', 'HA', 'PSu', 'HA'], # even -------------------------------------- ['HA', 'PSu'] # simple to preserve test ] for case_ in case.values(): for LM, expected in zip(case_.LMs, expected_mix): grouped = LM.LMFrame.groupby('layer')['matl'] actual = grouped.unique().tolist() #print(actual) #assert actual == expected nt.assert_equal(actual, expected)
# Commented nt.raise --> handled in Laminate._update_calculations(). # Although program will run, tracebacks will print if exceptions were raised. import pandas as pd import nose.tools as nt import lamana as la from lamana.input_ import BaseDefaults #from lamana.lt_exceptions import IndeterminateError # unused from lamana.models import Wilson_LT as wlt from lamana.utils import tools as ut # Global Cases bdft = BaseDefaults() dft = wlt.Defaults() case = ut.laminator(geos=dft.geos_standard) cases = ut.laminator(geos=dft.geos_all, ps=[2, 3, 4, 5], verbose=True) # TESTS ----------------------------------------------------------------------- # Tests that check the LMFrame rollsback to LFrame if exceptions are made. # Models ---------------------------------------------------------------------- # NOTE: the test for errors are commented out because errors are caught # in constructs and prevent breaking @nt.raises(ZeroDivisionError) def test_models_WisonLT_r1(): '''Check singularity in log of moment eqn when r = 0; ZeroDivisionError.''' zero_r = { 'R': 12e-3, # specimen radius 'a': 7.5e-3, # support ring radius
def test_distribplot_unnormalized_error1(): '''Check raises PlottingError if geometry > 1 for unnormalized plot.''' case = ut.laminator(['400-200-800', '400-400-400'])[0] plot = la.output_._distribplot(case.LMs, normalized=False) plt.close()
def test_lamainator_type1(): '''Check raises Exception if geos is not a list.''' actual = ut.laminator(geos={'400-200-800'})
def test_getspecialgeo2(): '''Check error is raised if not special, nplies > 4.''' case = ut.laminator(['400-200-800']) for case_ in case.values(): for LM in case_.LMs: actual = ut.get_special_geometry(LM.LMFrame)
def test_getmultigeo2(): '''Check error is raised if not "multi", rather a special, nplies < 4.''' case = ut.laminator(['400-200-0']) for case_ in case.values(): for LM in case_.LMs: actual = ut.get_multi_geometry(LM.LMFrame)