def test_sum_modifier(): cp = ConfigParser(io.StringIO()) pfr = Potential_Form_Registry(cp, register_standard=True) pfb = Potential_Form_Builder(pfr, Modifier_Registry()) expression = "sum(as.constant 1.0 >=1.0 as.constant 2.0, >1.5 as.constant 3.0)" potdef = cp._parse_multi_range("A", expression).potential_form_instance potential_func = pfb.create_potential_function(potdef) assert pytest.approx(1.0) == potential_func(0.1) assert pytest.approx(1.0) == potential_func(0.5) assert pytest.approx(2.0) == potential_func(1.1) assert pytest.approx(5.0) == potential_func(1.6) # Try another expression expression = ">=0 as.constant 2.0 >=1.0 sum(as.constant 1.0 >= 2.0 as.constant 0.5, >=1.5 as.constant 10.0) >= 3.0 as.zero" potdef = cp._parse_multi_range("A", expression).potential_form_instance potential_func = pfb.create_potential_function(potdef) assert pytest.approx(2.0) == potential_func(0) assert pytest.approx(1.0) == potential_func(1) assert pytest.approx(11.0) == potential_func(1.6) assert pytest.approx(10.5) == potential_func(2.1) assert pytest.approx(0.0) == potential_func(3.1)
def test_sum_modifier(): """Test instantiation of potential forms that use the sum() modifier and multiple ranges""" k = u"A" v = u"sum( as.constant 1.0 >=1.0 as.constant 2.0, >1.5 as.constant 3.0)" parser = ConfigParser(io.StringIO()) potential_forms = [ PotentialFormInstanceTuple( potential_form=u'as.constant', parameters=[1.0], start=MultiRangeDefinitionTuple(range_type=u">", start=0.0), next=PotentialFormInstanceTuple(potential_form=u'as.constant', parameters=[2.0], start=MultiRangeDefinitionTuple( range_type=u">=", start=1.0), next=None)), PotentialFormInstanceTuple(potential_form=u'as.constant', parameters=[3.0], start=MultiRangeDefinitionTuple( range_type=u">", start=1.5), next=None) ] expect = PotentialModifierTuple(modifier=u"sum", potential_forms=potential_forms, start=MultiRangeDefinitionTuple( range_type=u">", start=0.0), next=None) expect = PairPotentialTuple(species=k, potential_form_instance=expect) actual = parser._parse_multi_range(k, v) assert DeepDiff(expect, actual) == {}
def test_modifier_parse_exceptions(): """Check that a ConfigException is raised when parse errors are encountered""" parser = ConfigParser(io.StringIO()) with pytest.raises(ConfigParserException): parser._parse_multi_range(u"A", u"potential1 1.0 2.0 3.0 potential2 2.0")
def test_with_default_potentials(): """Tests for potential forms defined by atsim.potentials""" cfg_string = u"""[Potential-Form] buck_morse(r, A, rho, C, gamma, r_star, D) : as.buck(r,A,rho,C) + as.morse(r, gamma, r_star, D) """ expect = atsim.potentials.plus(atsim.potentials.potentialforms.buck(1000.0, 0.1, 32.0), atsim.potentials.potentialforms.morse(0.2, 1.3, 25.0))(1.4) cfg = ConfigParser(io.StringIO(cfg_string)) pfr = Potential_Form_Registry(cfg, True) buck_morse = pfr["buck_morse"](1000.0, 0.1, 32.0, 0.2, 1.3, 25.0) actual = buck_morse(1.4) assert pytest.approx(expect) == actual # Effectively the same test but mixing cexprtk definitions with the canned definition. cfg_string = u"""[Potential-Form] buck(r, A, rho, C) : A*exp(-r/rho) - C/r^6 buck_morse(r, A, rho, C, gamma, r_star, D) : buck(r,A,rho,C) + as.morse(r, gamma, r_star, D) """ cfg = ConfigParser(io.StringIO(cfg_string)) pfr = Potential_Form_Registry(cfg, True) buck_morse = pfr["buck_morse"](1000.0, 0.1, 32.0, 0.2, 1.3, 25.0) actual = buck_morse(1.4) assert pytest.approx(expect) == actual
def test_parsed_sections(): expect = [ 'tabulation', 'potential_form', 'eam_embed', 'eam_density', 'pair' ] expect.sort() with _get_dlpoly_resource_dir().join("CRG_Ce.aspot").open() as infile: cp = ConfigParser(infile) actual = cp.parsed_sections actual.sort() assert expect == actual expect = ['tabulation', 'potential_form', 'pair'] expect.sort() with _get_lammps_resource_dir().join("zbl_spline.aspot").open() as infile: cp = ConfigParser(infile) actual = cp.parsed_sections actual.sort() assert expect == actual expect = [ 'tabulation', 'potential_form', 'eam_embed', 'eam_density_fs', 'pair' ] expect.sort() with _get_lammps_resource_dir().join( "AlFe_setfl_fs.aspot").open() as infile: cp = ConfigParser(infile) actual = cp.parsed_sections actual.sort() assert expect == actual
def test_sum_modifier_fs_start(): k = u"Al->Al" v = u">=0 sum(dens4 0.00019850823042883 2.5 >2.5 as.zero)" parser = ConfigParser(io.StringIO()) actual = parser._parse_multi_range(k, v) assert DeepDiff(MultiRangeDefinitionTuple(u">=", 0), actual.potential_form_instance.start) == {}
def test_parse_potential_form_signature(): pfstr = "buck_morse(r_ij, A,rho,C,D,gamma,r0)" cfg = ConfigParser(io.StringIO()) expect = PotentialFormSignatureTuple( u"buck_morse", [u"r_ij", u"A", u"rho", u"C", u"D", u"gamma", u"r0"], False) actual = cfg._parse_potential_form_signature(pfstr) assert expect == actual
def test_duplicate_entries(): assert issubclass(ConfigParserDuplicateEntryException, ConfigParserException) assert issubclass(ConfigParserDuplicateEntryException, ConfigurationException) aspot = u""" [Pair] U-U : as.buck 1000.0 0.1 32.0 U-U : as.buck 1000.0 0.2 32.0""" with pytest.raises(ConfigParserDuplicateEntryException): cp = ConfigParser(io.StringIO(aspot)) aspot = u""" [Pair] O-U : as.buck 1000.0 0.1 32.0 U-O : as.buck 1000.0 0.2 32.0""" with pytest.raises(ConfigParserDuplicateEntryException): cp = ConfigParser(io.StringIO(aspot)) aspot = u""" [Pair] O-U : as.buck 1000.0 0.1 32.0 U-U : as.buck 2000.0 0.2 16.0""" with pytest.raises(ConfigParserDuplicateEntryException): cp = ConfigParser(io.StringIO(aspot), additional=[ ConfigParserOverrideTuple( u"Pair", u"O-U", u"as.buck 1000.0 0.1 32.0") ]) aspot = u""" [Pair] O-U : as.buck 1000.0 0.1 32.0 U-U : as.buck 2000.0 0.2 16.0""" with pytest.raises(ConfigParserDuplicateEntryException): cp = ConfigParser(io.StringIO(aspot), additional=[ ConfigParserOverrideTuple( u"Pair", u"U-O", u"as.buck 1000.0 0.1 32.0") ])
def test_list_items(): expect = [ ("Tabulation:target", "setfl"), ("Tabulation:nr", "1000"), ("Tabulation:dr", "0.01"), ("Tabulation:nrho", "1000"), ("Tabulation:drho", "0.01"), ("Potential-Form:buck_morse(r,A,rho,C,D,gamma,r0)", "as.buck(r,A,rho,C) + as.morse(r, gamma, r0, D)"), ("Potential-Form:density(r,n)", "(n/r^8) * 0.5 * (1+erf(20*(r-1.5)))"), ("EAM-Embed:Th", "as.sqrt -1.185"), ("EAM-Embed:U", "as.sqrt -1.806"), ("EAM-Embed:O", "as.sqrt -0.690"), ("EAM-Density:Th", "density 1742.622"), ("EAM-Density:U", "density 3450.995"), ("EAM-Density:O", "density 106.856"), ("Pair:O-O", "as.buck 830.283 0.352856 3.884372"), ("Pair:Th-Th", "as.buck 18600 0.2884 0.0"), ("Pair:U-U", "as.buck 18600 0.2747 0.0"), ("Pair:Th-O", "buck_morse 315.544 0.395903 0.0 0.62614 1.85960 2.49788"), ("Pair:U-O", "buck_morse 448.779 0.387758 0.0 0.66080 2.05815 2.38051") ] expect.sort() with _get_lammps_resource_dir().join("CRG_U_Th.aspot").open() as infile: cp = ConfigParser(infile) items = _query_actions._list_items(cp) items.sort() assert expect == items
def test_bad_params_inside_expression(): """Check that configuration exceptions thrown when the wrong number of arguments are used with a potentialfunction inside a cexprtk function""" cp = ConfigParser( io.StringIO(u""" [Potential-Form] bad(r) = as.buck(1.0, 2.0) bad_parse(r) = exp() + 5.0 """)) pfr = Potential_Form_Registry(cp, register_standard=True) buck = pfr["as.buck"] buck(1000.0, 0.2, 32.0) with pytest.raises(Potential_Form_Exception): buck(1.0, 2.0) bad_func = pfr["bad"]() with pytest.raises(Potential_Form_Exception): bad_func(1.0) # Test for cexpr parse failure: bad_parse = pfr["bad_parse"]() with pytest.raises(Potential_Form_Exception): bad_parse(1.0)
def main(): # Make a file like object from the potable input string given above. potable_input_file = io.StringIO(potable_input) # Create a Configuration() object and read input from the input file. configuration = Configuration() # This example shows how to override and add items to potable input before it # is passed to the Configuration object. # The tabulation target will be change to 'LAMMPS' # The cutoff will be reduced to 6.5 # An additional pair-interaction will be given for O-O cp = ConfigParser( potable_input_file, overrides=[ ConfigParserOverrideTuple("Tabulation", "target", "LAMMPS"), ConfigParserOverrideTuple("Tabulation", "cutoff", "6.5") ], additional=[ ConfigParserOverrideTuple("Pair", "O-O", "as.buck 444.7686 0.402 0.0") ]) # Create the tabulation by passing the Config_Parser object to the Configuration.read_from_parser method. tabulation = configuration.read_from_parser(cp) # Now write tabulation to console tabulation.write(sys.stderr)
def test_multirange_potential_form_builder(): # Populate potential form registry cp = ConfigParser(io.StringIO()) pfr = Potential_Form_Registry(cp, register_standard=True) pfb = Potential_Form_Builder(pfr, Modifier_Registry()) PFitTup = PotentialFormInstanceTuple MRTup = MultiRangeDefinitionTuple mrdefn = PFitTup(potential_form="as.zero", parameters=[], start=MRTup(">=", 0), next=PFitTup(potential_form="as.buck", parameters=[1000.0, 0.3, 32.0], start=MRTup(">", 1), next=PFitTup(potential_form="as.constant", parameters=[3], start=MRTup(">", 5), next=None))) potential_func = pfb.create_potential_function(mrdefn) assert pytest.approx(0) == potential_func(0.0) v = potential_func(1.0) assert pytest.approx(0) == v v = potential_func(2.0) assert pytest.approx(pforms.buck(2.0, 1000.0, 0.3, 32.0)) == v v = potential_func(5.0) assert pytest.approx(pforms.buck(5.0, 1000.0, 0.3, 32.0)) == v assert 3.0 == potential_func(5.1) assert 3.0 == potential_func(10.0)
def test_filtered_config_parser_finnis_sinclair(): lmpdir = _get_lammps_resource_dir() with lmpdir.join("AlFe_setfl_fs.aspot").open() as infile: orig_cp = ConfigParser(infile) filtered_cp = FilteredConfigParser(orig_cp, exclude=["Fe"]) unfiltered = [ "potential_form", "tabulation", "parsed_sections", "orphan_sections", "raw_config_parser" ] for attr in unfiltered: expect = getattr(orig_cp, attr) actual = getattr(filtered_cp, attr) assert DeepDiff(expect, actual) == {} # Now check the attributes that should be filtered # ... pair ST = SpeciesTuple expect = [ST("Al", "Al")] actual = [p[0] for p in filtered_cp.pair] assert DeepDiff(expect, actual) == {} # ... eam_embed expect = ["Al"] actual = [p[0] for p in filtered_cp.eam_embed] assert DeepDiff(expect, actual) == {} # ... eam_density EDST = EAMFSDensitySpeciesTuple expect = [EDST("Al", "Al")] actual = [p[0] for p in filtered_cp.eam_density_fs] assert DeepDiff(expect, actual) == {}
def test_orphan_sections(): with io.open( _get_lammps_resource_dir().join("AlFe_setfl_fs.aspot").strpath, encoding="utf8") as infile: sio = io.StringIO(infile.read()) sio.seek(0, os.SEEK_END) sio.write(u"\n\n[Charges]\nU : 2.22\nO: -1.11\n") sio.write(u"[Masses]\nU : 1.234\nO: 4.56\n") sio.seek(0) expect = [ u'tabulation', u'potential_form', u'eam_embed', u'eam_density_fs', u'pair' ] expect.sort() cp = ConfigParser(sio) actual = cp.parsed_sections actual.sort() assert expect == actual actual = cp.orphan_sections expect = [u"Charges", u"Masses"] actual.sort() expect.sort() assert expect == actual
def test_orphan_section(): # Check that Table-Form sections do not appear in config parser's orphan sections. cfgio = StringIO(example_input_1) cfgparser = ConfigParser(cfgio) for section in cfgparser.orphan_sections: if section.startswith(_TableFormSection._section_name_prefix): pytest.fail("Section '{}' listed as an orphan section".format(section))
def test_species(): # Test empty reference data section parsed = ConfigParser(io.StringIO()) assert parsed.species == {} # Test reference data with overrides parsed = ConfigParser( io.StringIO(u""" [Species] Gd.atomic_mass = 1.234 Gd.charge = 4.567 NewSpecies.atomic_number = 600 Al.lattice_type = fcc Al.lattice_constant = 7.8910 """)) expect = { u'Gd': { u'atomic_mass': 1.234, u'charge': 4.567 }, u'NewSpecies': { u'atomic_number': 600 }, u'Al': { u'lattice_type': u'fcc', u'lattice_constant': 7.8910 } } actual = parsed.species assert DeepDiff(expect, actual) == {} # Test that an exception is raised if invalid syntax used parsed = ConfigParser(io.StringIO(u""" [Species] Gd : 1.234 """)) with pytest.raises(ConfigParserException): parsed.species
def test_tableforms_in_potentialformregistry(): from atsim.potentials.config._potential_form_registry import Potential_Form_Registry cfg_string = u""" [Table-Form:tabulated_1] interpolation : cubic_spline x : 0.0 0.00728 0.01455 0.02910 0.03347 y : 0.0 -3.2170 -4.6278 -2.7699 0.0 [Table-Form:tabulated_2] interpolation : cubic_spline x : 0 1 2 3 y : 0 1 2 3 """ sio = StringIO(cfg_string) cfg = ConfigParser(sio) pfr = Potential_Form_Registry(cfg, register_standard= False) assert pfr.registered == ["tabulated_1", "tabulated_2"] tabulated_2 = pfr["tabulated_2"] assert pytest.approx(tabulated_2()(1.0)) == 1.0 # Now do a test to make sure other potential forms can use Table-Forms cfg_string = u""" [Potential-Form] test(r) = tabulated(r) + 5 [Table-Form:tabulated] interpolation : cubic_spline x : 0 1 2 3 y : 0 1 2 3 """ sio = StringIO(cfg_string) cfg = ConfigParser(sio) pfr = Potential_Form_Registry(cfg, register_standard= False) assert pfr.registered == ["tabulated", "test"] assert pytest.approx(pfr["tabulated"]()(1.0)) == 1.0 assert pytest.approx(pfr["test"]()(1.0)) == 6.0
def test_indented_input_with_comment(): single_line = u"""[Pair] O-O : sum( as.constant 1.0, as.constant 2.0 ) """ expect = ConfigParser(io.StringIO(single_line)).pair cfg_string = u"""[Pair] O-O : sum( # Interleaved comment as.constant 1.0, as.constant 2.0 ) """ cp = ConfigParser(io.StringIO(cfg_string)) actual = cp.pair assert DeepDiff(expect, actual) == {}
def test_repeat_potential_form_error(): """Make sure error is raised if two potentials have same label""" cfg_string = u"""[Potential-Form] buck(r, A, rho, C) : A*exp(-r/rho) - C/r^6 buck(r, A, rho, C,D) : A*exp(-r/rho) - C/r^6 """ cfg = ConfigParser(io.StringIO(cfg_string)) with pytest.raises(Potential_Form_Registry_Exception): pfr = Potential_Form_Registry(cfg)
def test_config_potential_form_registry_one_potential_form(): cfg_string = u"""[Potential-Form] buck(r, A, rho, C) : A*exp(-r/rho) - C/r^6 """ cfg = ConfigParser(io.StringIO(cfg_string)) pfr = Potential_Form_Registry(cfg) assert ["buck"] == pfr.registered buck = pfr["buck"](1000.0, 0.1, 3.0) assert pytest.approx(-2.9546) == buck(1.0)
def test_modifier_with_nested_modifier(): """Test instantiation of potential forms that has a modifier that has a nested modifier in its argument list""" k = u"A" v = u"zero >=1.0 sum(nested(constant 1.0 >2 zero), buck 10.0 0.1 32.0)" parser = ConfigParser(io.StringIO()) potential_forms = [ PMT(u'nested', [ PFI(u'constant', [1.0], MRD(u'>', 0.0), PFI(u'zero', [], MRD(u'>', 2), None)) ], MRD(u'>', 0.0), None), PFI(u'buck', [10.0, 0.1, 32.0], MRD(u'>', 0.0), None) ] expect = PFI(u'zero', [], MRD(u'>', 0.0), PMT(u'sum', potential_forms, MRD(u'>=', 1.0), None)) expect = PairPotentialTuple(species=k, potential_form_instance=expect) actual = parser._parse_multi_range(k, v) assert DeepDiff(expect, actual) == {}
def test_pot_in_potforms_but_not_potfuncs(): cfg = ConfigParser(io.StringIO()) pfr = Potential_Form_Registry(cfg, True) # The buck4 potential is defined in potentialforms but not potentialfunctions # check that it's still accesible from the Potential_Form_Registry assert "as.buck" in pfr.registered assert PotentialFormSignatureTuple(label = "as.buck", parameter_names = ["r", "A", "rho", "C"], is_varargs=False) == pfr["as.buck"].signature assert "as.buck4" in pfr.registered assert PotentialFormSignatureTuple(label= "as.buck4", parameter_names = ["r", "A", "rho", "C", "r_detach", "r_min", "r_attach"], is_varargs=False) == pfr["as.buck4"].signature
def test_sum_modifier_as_part_of_multi_range(): """Test instantiation of potential forms that use the sum() modifier as sub-range in potential definition""" k = u"A" v = u"as.constant 2.0 >=1.0 sum(as.constant 1.0 >= 2.0 as.constant 0.5, >=1.5 as.constant 10.0) >= 3.0 zero" parser = ConfigParser(io.StringIO()) potential_forms = [ PFI(u'as.constant', [1.0], MRD(u'>', 0.0), PFI(u'as.constant', [0.5], MRD(u'>=', 2.0), None)), PFI(u'as.constant', [10.0], MRD(u'>=', 1.5), None) ] expect = PFI( u'as.constant', [2.0], MRD(u'>', 0.0), PMT(u'sum', potential_forms, MRD(u'>=', 1.0), PFI(u'zero', [], MRD(u'>=', 3.0), None))) expect = PairPotentialTuple(species=k, potential_form_instance=expect) actual = parser._parse_multi_range(k, v) assert DeepDiff(expect, actual) == {}
def test_filtered_config_parser(): lmpdir = _get_lammps_resource_dir() with lmpdir.join("CRG_U_Th.aspot").open() as infile: orig_cp = ConfigParser(infile) filtered_cp = FilteredConfigParser(orig_cp, exclude=["Th"]) u_th_filtered_test(orig_cp, filtered_cp) filtered_cp = FilteredConfigParser(orig_cp, include=["U", "O"]) u_th_filtered_test(orig_cp, filtered_cp) with pytest.raises(ValueError): FilteredConfigParser(orig_cp, include=["U", "O"], exclude=["Th"])
def test_config_parser(cfgstring): cfgio = StringIO(cfgstring) cfgparser = ConfigParser(cfgio) expect = [ TableFormTuple( name = u'cubic_spline', interpolation = u'cubic_spline', x = [0.0, 0.01370, 0.02740, 0.05481, 0.06303], y = [0.0, -2.9239, -4.2953, -2.8523, 0.0]) ] actual = cfgparser.table_form assert DeepDiff(expect, actual) == {}
def test_list_plot_item_labels(): expect = [ "EAM-Embed:Th", "EAM-Embed:U", "EAM-Embed:O", "EAM-Density:Th", "EAM-Density:U", "EAM-Density:O", "Pair:O-O", "Pair:Th-Th", "Pair:U-U", "Pair:Th-O", "Pair:U-O" ] expect.sort() with _get_lammps_resource_dir().join("CRG_U_Th.aspot").open() as infile: cp = ConfigParser(infile) items = _query_actions._list_plot_item_labels(cp) items.sort() assert expect == items
def test_config_potential_form_registry_args(): cfg = ConfigParser(io.StringIO()) # import pdb; pdb.set_trace() pfr = Potential_Form_Registry(cfg, register_standard=True) buck = pfr["as.buck"] actual_pft = buck.signature expect_pft = PotentialFormSignatureTuple("as.buck", ["r", "A", "rho", "C"], False) assert DeepDiff(expect_pft, actual_pft) == {} buck = pfr["as.polynomial"] actual_pft = buck.signature expect_pft = PotentialFormSignatureTuple("as.polynomial", [], True) assert DeepDiff(expect_pft, actual_pft) == {}
def test_eam_density(): """Test reading of density parameters from [EAM-Density] section""" cfg_string = u"""[EAM-Density] A : density1 1000.0 0.1 1.0 B : density2 2000.0 0.2 2.0 """ parsed = ConfigParser(io.StringIO(cfg_string)) expect = [ EAMDensityTuple( u"A", PFI(u"density1", [1000.0, 0.1, 1.0], MRD(u">", 0.0), None)), EAMDensityTuple( u"B", PFI(u"density2", [2000.0, 0.2, 2.0], MRD(u">", 0.0), None)) ] actual = parsed.eam_density assert DeepDiff(expect, actual) == {}
def test_list_item_labels(): expect = [ "Tabulation:target", "Tabulation:nr", "Tabulation:dr", "Tabulation:nrho", "Tabulation:drho", "Potential-Form:buck_morse(r,A,rho,C,D,gamma,r0)", "Potential-Form:density(r,n)", "EAM-Embed:Th", "EAM-Embed:U", "EAM-Embed:O", "EAM-Density:Th", "EAM-Density:U", "EAM-Density:O", "Pair:O-O", "Pair:Th-Th", "Pair:U-U", "Pair:Th-O", "Pair:U-O" ] expect.sort() with _get_lammps_resource_dir().join("CRG_U_Th.aspot").open() as infile: cp = ConfigParser(infile) items = _query_actions._list_item_labels(cp) items.sort() assert expect == items
def test_tabulation_cutoff_and_step(): cfg_string = u"""[Tabulation] cutoff : 10.0 """ parsed = ConfigParser(io.StringIO(cfg_string)) assert 10.0 == parsed.tabulation.cutoff assert parsed.tabulation.nr is None cfg_string = u"""[Tabulation] cutoff : 10.0 nr : 1000 """ parsed = ConfigParser(io.StringIO(cfg_string)) assert 10.0 == parsed.tabulation.cutoff assert parsed.tabulation.nr == 1000 cfg_string = u"""[Tabulation] cutoff : 10.0 dr : 1.0 """ parsed = ConfigParser(io.StringIO(cfg_string)) assert 10.0 == parsed.tabulation.cutoff assert parsed.tabulation.nr == 11 assert type(parsed.tabulation.nr) is int cfg_string = u"""[Tabulation] nr : 11 dr : 1.0 """ parsed = ConfigParser(io.StringIO(cfg_string)) assert 10.0 == parsed.tabulation.cutoff assert parsed.tabulation.nr == 11 with pytest.raises(ConfigParserException): cfg_string = u"""[Tabulation] dr : 11 """ parsed = ConfigParser(io.StringIO(cfg_string)) parsed.tabulation with pytest.raises(ConfigParserException): cfg_string = u"""[Tabulation] cutoff : 10.0 dr : 0.001 nr : 11 """ parsed = ConfigParser(io.StringIO(cfg_string)) parsed.tabulation