def testLatticeMap(self): """ Make sure the lattice map we get correspond to the lattice we give. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 4, 1), periodic=(True, True, False)) types = [ 'a', 'a', 'a', 'a', 'b', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'b', 'a', 'b', 'b', 'b', 'a', 'b', 'a', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'a', 'b', 'b', 'a' ] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a', 'c', 'b']) # Get the lattice map. cpp_lattice_map = config._latticeMap() # Get the map from the lattice. cpp_lattice_map_ref = lattice._map() # Check that these two are references to the same underlying object. self.assertTrue(cpp_lattice_map == cpp_lattice_map_ref)
def notestTypesBucketFormat(self): """ Test that the configuration accepts the bucket input format. """ # Define the unit cell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.1,0.0,0.0], [0.0,1.0,0.0], [0.0,0.0,1.0]]), basis_points=[[0.0,0.0,0.0]]) # And a lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(10,1,1), periodic=(True,False,False)) # Populate the lattice with types. types = [(2,"A"), "B", ["B", "B", "A"], ["B", (2,"A")], "B", "empty", [(3,"A")], [(1,"B"), "A"], [(2,"A")], "empty"] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['A','B','empty']) # Retrieve the types information from the configuration backend. # FXME: NEEDS IMPLEMENTATION print config.types()
def testLatticeQuery(self): """ Test the query function for the lattice. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 4, 1), periodic=(True, True, False)) types = [ 'a', 'a', 'a', 'a', 'b', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'b', 'a', 'b', 'b', 'b', 'a', 'b', 'a', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'a', 'b', 'b', 'a' ] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a', 'c', 'b']) # Query for the lattice. ret_lattice = config.lattice() # Check by reference. self.assertTrue(lattice == ret_lattice)
def testLatticeQuery(self): """ Test the query function for the lattice. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['a','a','a','a','b','b', 'a','a','a','b','b','b', 'b','b','a','a','b','a', 'b','b','b','a','b','a', 'b','a','a','a','b','b', 'b','b','b','b','b','b', 'a','a','a','a','b','b', 'b','b','a','b','b','a'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a','c','b']) # Query for the lattice. ret_lattice = config.lattice() # Check by reference. self.assertTrue( lattice == ret_lattice )
def notestTypesBucketFormat(self): """ Test that the configuration accepts the bucket input format. """ # Define the unit cell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.1, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]), basis_points=[[0.0, 0.0, 0.0]]) # And a lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(10, 1, 1), periodic=(True, False, False)) # Populate the lattice with types. types = [(2, "A"), "B", ["B", "B", "A"], ["B", (2, "A")], "B", "empty", [(3, "A")], [(1, "B"), "A"], [(2, "A")], "empty"] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['A', 'B', 'empty']) # Retrieve the types information from the configuration backend. # FXME: NEEDS IMPLEMENTATION print config.types()
def testConstructionLongFormat(self): """ Test that the KMCConfiguration class can be constructed with the long types format. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 3, 2), periodic=(True, True, False)) types = [(0, 0, 0, 0, 'g'), (3, 2, 1, 2, 'h')] default_type = 'a' # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, default_type=default_type) # Get the types information out. ret_types = config.types() ref_types = [ 'g', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'h' ] # Check that they are what we inserted. self.assertEqual(ref_types, ret_types) # Check that the possible types are what we expect. self.assertEqual(set(['a', 'g', 'h', '*']), set(config._KMCConfiguration__possible_types)) # Check that the number of lattice sites corresponds # to the lattice. self.assertEqual(config._KMCConfiguration__n_lattice_sites, len(lattice.sites())) # Construct again, now with a list of possible types. config = KMCConfiguration(lattice=lattice, types=types, default_type=default_type, possible_types=['aa', 'a', 'h', 'g']) # Check that the possible types are what we expect. self.assertEqual(set(['aa', 'a', 'g', 'h', '*']), set(config._KMCConfiguration__possible_types))
def testConstructionLongFormat(self): """ Test that the KMCConfiguration class can be constructed with the long types format. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,3,2), periodic=(True,True,False)) types = [(0,0,0,0,'g'),(3,2,1,2,'h')] default_type = 'a' # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, default_type=default_type) # Get the types information out. ret_types = config.types() ref_types = ['g', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'h'] # Check that they are what we inserted. self.assertEqual(ref_types, ret_types) # Check that the possible types are what we expect. self.assertEqual(set(['a','g','h','*']), set(config._KMCConfiguration__possible_types)) # Check that the number of lattice sites corresponds # to the lattice. self.assertEqual(config._KMCConfiguration__n_lattice_sites, len(lattice.sites())) # Construct again, now with a list of possible types. config = KMCConfiguration(lattice=lattice, types=types, default_type=default_type, possible_types=['aa','a','h','g']) # Check that the possible types are what we expect. self.assertEqual(set(['aa','a','g','h','*']), set(config._KMCConfiguration__possible_types))
def testConstructionShortFormat(self): """ Test that the KMCConfiguration class can be constructed. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['a','a','a','a','b','b', 'a','a','a','b','b','b', 'b','b','a','a','b','a', 'b','b','b','a','b','a', 'b','a','a','a','b','b', 'b','b','b','b','b','b', 'a','a','a','a','b','b', 'b','b','a','b','b','a'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a','c','b']) # Get the types information out. ret_types = config.types() # Check that they are what we inserted. self.assertEqual(types, ret_types) # Check that the possible types are what we expect. self.assertEqual(set(['a','c','b','*']), set(config._KMCConfiguration__possible_types.keys())) # Check that the number of lattice sites corresponds to the lattice. self.assertEqual(config._KMCConfiguration__n_lattice_sites, len(lattice.sites())) # Check that the lattice site can be returned from the configuration. self.assertAlmostEqual( numpy.linalg.norm(numpy.array(config.sites()) - numpy.array(lattice.sites())), 0.0, 10 ) # Construct without possible types and check that the list is set correctly # from the given types. config = KMCConfiguration(lattice=lattice, types=types) self.assertEqual(set(['a','b','*']), set(config._KMCConfiguration__possible_types.keys()))
def testQueries(self): """ Test the configuration's query functions. """ config = KMCConfiguration.__new__(KMCConfiguration) c0_ref = numpy.random.random() c1_ref = numpy.random.random() c2_ref = numpy.random.random() # Set the backend proxy. class BackendProxy(object): def __init__(self): pass def elements(self): return ("B", "F", "A") def atomIDElements(self): return ("A", "B", "F") def atomIDCoordinates(self): return (Backend.Coordinate(c0_ref, c1_ref, c2_ref), ) config._KMCConfiguration__backend = BackendProxy() # Query and check. atom_id_types = config.atomIDTypes() atom_id_coords = config.atomIDCoordinates() lattice_types = config.types() self.assertEqual(atom_id_types, ("A", "B", "F")) self.assertEqual(lattice_types, ["B", "F", "A"]) self.assertAlmostEqual(atom_id_coords[0][0], c0_ref, 10) self.assertAlmostEqual(atom_id_coords[0][1], c1_ref, 10) self.assertAlmostEqual(atom_id_coords[0][2], c2_ref, 10)
def testConstruction(self): """ Test that the XYZTrajectory object can be constructed. """ filename = "abc123.xyz" name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "..") name = os.path.join(name, "TestUtilities", "Scratch") filename = os.path.join(name, filename) if MPICommons.isMaster(): self.__files_to_remove.append(filename) unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], basis_points=[[0.0, 0.0, 0.0]]) lattice = KMCLattice(unit_cell=unit_cell, periodic=(True, True, True), repetitions=(4,4,4)) config = KMCConfiguration(lattice=lattice, types=["A","B","C","D"]*16) t = XYZTrajectory(trajectory_filename=filename, configuration=config, max_buffer_size=12345, max_buffer_time=123.0) # Check that the internal memory buffers have been initiated. self.assertEqual(t._XYZTrajectory__atom_id_types, []) self.assertEqual(t._XYZTrajectory__atom_id_coordinates, []) self.assertEqual(t._XYZTrajectory__time, []) self.assertEqual(t._XYZTrajectory__step, [])
def testQueries(self): """ Test the configuration's query functions. """ config = KMCConfiguration.__new__(KMCConfiguration) c0_ref = numpy.random.random() c1_ref = numpy.random.random() c2_ref = numpy.random.random() # Set the backend proxy. class BackendProxy(object): def __init__(self): pass def elements(self): return ("B", "F", "A") def atomIDElements(self): return ("A", "B", "F") def atomIDCoordinates(self): return (Backend.Coordinate(c0_ref,c1_ref,c2_ref),) config._KMCConfiguration__backend = BackendProxy() # Query and check. atom_id_types = config.atomIDTypes() atom_id_coords = config.atomIDCoordinates() lattice_types = config.types() self.assertEqual(atom_id_types, ("A","B","F")) self.assertEqual(lattice_types, ["B","F","A"]) self.assertAlmostEqual(atom_id_coords[0][0], c0_ref, 10) self.assertAlmostEqual(atom_id_coords[0][1], c1_ref, 10) self.assertAlmostEqual(atom_id_coords[0][2], c2_ref, 10)
def testQueries(self): """ Test the configuration's query functions. """ config = KMCConfiguration.__new__(KMCConfiguration) config._KMCConfiguration__use_buckets = False c0_ref = numpy.random.random() c1_ref = numpy.random.random() c2_ref = numpy.random.random() # Set the backend proxy. class BackendProxy(object): def __init__(self): pass def elements(self): return ("B", "F", "A") def atomIDElements(self): return ("A", "B", "F") def atomIDCoordinates(self): return (Backend.Coordinate(c0_ref, c1_ref, c2_ref), ) def movedAtomIDs(self): return (123, 234) def latestEventProcess(self): return 995976943 def latestEventSite(self): return 556462676 def particlesPerType(self): return (123, 467, 432) config._KMCConfiguration__backend = BackendProxy() # Query and check. atom_id_types = config.atomIDTypes() atom_id_coords = config.atomIDCoordinates() lattice_types = config.types() moved_atom_ids = config.movedAtomIDs() latest_event_process = config.latestEventProcess() latest_event_site = config.latestEventSite() particles_per_type = config.particlesPerType() self.assertEqual(atom_id_types, ("A", "B", "F")) self.assertEqual(lattice_types, ["B", "F", "A"]) self.assertAlmostEqual(atom_id_coords[0][0], c0_ref, 10) self.assertAlmostEqual(atom_id_coords[0][1], c1_ref, 10) self.assertAlmostEqual(atom_id_coords[0][2], c2_ref, 10) self.assertEqual(moved_atom_ids, (123, 234)) self.assertEqual(latest_event_process, 995976943) self.assertEqual(latest_event_site, 556462676) self.assertEqual(particles_per_type, (123, 467, 432))
def testBackend(self): """ Make sure the C++ backend is what we expect. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['a','a','a','a','b','b', 'a','a','a','b','b','b', 'b','b','a','a','b','a', 'b','b','b','a','b','a', 'b','a','a','a','b','b', 'b','b','b','b','b','b', 'a','a','a','a','b','b', 'b','b','a','b','b','a'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a','c','b']) # Make sure that the backend stored on the config is None. self.assertTrue(config._KMCConfiguration__backend is None) # Query for the backend. cpp_backend = config._backend() # Check that the backend on the class is returned. self.assertTrue(config._KMCConfiguration__backend == cpp_backend) # Check the type of the cpp backend. self.assertTrue(isinstance(cpp_backend, Backend.Configuration))
def testLatticeMap(self): """ Make sure the lattice map we get correspond to the lattice we give. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['a','a','a','a','b','b', 'a','a','a','b','b','b', 'b','b','a','a','b','a', 'b','b','b','a','b','a', 'b','a','a','a','b','b', 'b','b','b','b','b','b', 'a','a','a','a','b','b', 'b','b','a','b','b','a'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a','c','b']) # Get the lattice map. cpp_lattice_map = config._latticeMap() # Get the map from the lattice. cpp_lattice_map_ref = lattice._map() # Check that these two are references to the same underlying object. self.assertTrue(cpp_lattice_map == cpp_lattice_map_ref)
def testQueries(self): """ Test the configuration's query functions. """ config = KMCConfiguration.__new__(KMCConfiguration) config._KMCConfiguration__use_buckets = False c0_ref = numpy.random.random() c1_ref = numpy.random.random() c2_ref = numpy.random.random() # Set the backend proxy. class BackendProxy(object): def __init__(self): pass def elements(self): return ("B", "F", "A") def atomIDElements(self): return ("A", "B", "F") def atomIDCoordinates(self): return (Backend.Coordinate(c0_ref,c1_ref,c2_ref),) def movedAtomIDs(self): return (123, 234) def latestEventProcess(self): return 995976943 def latestEventSite(self): return 556462676 def particlesPerType(self): return (123, 467, 432) config._KMCConfiguration__backend = BackendProxy() # Query and check. atom_id_types = config.atomIDTypes() atom_id_coords = config.atomIDCoordinates() lattice_types = config.types() moved_atom_ids = config.movedAtomIDs() latest_event_process = config.latestEventProcess() latest_event_site = config.latestEventSite() particles_per_type = config.particlesPerType() self.assertEqual(atom_id_types, ("A","B","F")) self.assertEqual(lattice_types, ["B","F","A"]) self.assertAlmostEqual(atom_id_coords[0][0], c0_ref, 10) self.assertAlmostEqual(atom_id_coords[0][1], c1_ref, 10) self.assertAlmostEqual(atom_id_coords[0][2], c2_ref, 10) self.assertEqual(moved_atom_ids, (123, 234)) self.assertEqual(latest_event_process, 995976943) self.assertEqual(latest_event_site, 556462676) self.assertEqual(particles_per_type, (123, 467, 432))
def testWriteHeader(self): """ Test the header output. """ # Get a file name. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "..") name = os.path.join(name, "TestUtilities", "Scratch") trajectory_filename = os.path.join(name, "tmp_trajectory.xyz") if MPICommons.isMaster(): self.__files_to_remove.append(trajectory_filename) # Setup the trajectory object. unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], basis_points=[[0.0, 0.0, 0.0]]) lattice = KMCLattice(unit_cell=unit_cell, periodic=(True, True, True), repetitions=(4,2,3)) config = KMCConfiguration(lattice=lattice, types=["A","B","C"]*8) t = XYZTrajectory(trajectory_filename=trajectory_filename, configuration=config, max_buffer_size=12345, max_buffer_time=123.0) if MPICommons.isMaster(): # Check that the header was written. self.assertTrue(os.path.exists(trajectory_filename)) # Check the content of the header. with open(trajectory_filename, "r") as f: content = f.read() ref_content = """KMCLib XYZ FORMAT VERSION 2013.10.15 CELL VECTORS a: 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 b: 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 c: 0.0000000000e+00 0.0000000000e+00 1.0000000000e+00 REPETITIONS 4 2 3 PERIODICITY True True True """ self.assertEqual( content, ref_content )
def testBackend(self): """ Make sure the C++ backend is what we expect. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 4, 1), periodic=(True, True, False)) types = [ 'a', 'a', 'a', 'a', 'b', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'b', 'a', 'b', 'b', 'b', 'a', 'b', 'a', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'a', 'b', 'b', 'a' ] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a', 'c', 'b']) # Make sure that the backend stored on the config is None. self.assertTrue(config._KMCConfiguration__backend is None) # Query for the backend. cpp_backend = config._backend() # Check that the backend on the class is returned. self.assertTrue(config._KMCConfiguration__backend == cpp_backend) # Check the type of the cpp backend. self.assertTrue(isinstance(cpp_backend, Backend.Configuration))
def testConstructionShortFormat(self): """ Test that the KMCConfiguration class can be constructed. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 4, 1), periodic=(True, True, False)) types = [ 'a', 'a', 'a', 'a', 'b', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'b', 'a', 'b', 'b', 'b', 'a', 'b', 'a', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'a', 'b', 'b', 'a' ] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a', 'c', 'b']) # Get the types information out. ret_types = config.types() # Check that they are what we inserted. self.assertEqual(types, ret_types) # Check that the possible types are what we expect. self.assertEqual(set(['a', 'c', 'b', '*']), set(config._KMCConfiguration__possible_types.keys())) # Check that the number of lattice sites corresponds to the lattice. self.assertEqual(config._KMCConfiguration__n_lattice_sites, len(lattice.sites())) # Check that the lattice site can be returned from the configuration. self.assertAlmostEqual( numpy.linalg.norm( numpy.array(config.sites()) - numpy.array(lattice.sites())), 0.0, 10) # Construct without possible types and check that the list is set correctly # from the given types. config = KMCConfiguration(lattice=lattice, types=types) self.assertEqual(set(['a', 'b', '*']), set(config._KMCConfiguration__possible_types.keys()))
def testScript(self): """ Test that we can generate a valid script. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['a','a','a','a','b','b', 'a','a','a','b','b','b', 'b','b','a','a','b','a', 'b','b','b','a','b','a', 'b','a','a','a','b','b', 'b','b','b','b','b','b', 'a','a','a','a','b','b', 'b','b','a','b','b','a'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a','c','b']) # Get the script. script = config._script() ref_script = """ # ----------------------------------------------------------------------------- # Unit cell cell_vectors = [[ 2.800000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 3.200000e+00, 0.000000e+00], [ 0.000000e+00, 5.000000e-01, 3.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 5.000000e-01, 5.000000e-01, 5.000000e-01], [ 2.500000e-01, 2.500000e-01, 7.500000e-01]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # ----------------------------------------------------------------------------- # Lattice lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True, True, False)) # ----------------------------------------------------------------------------- # Configuration types = ['a','a','a','a','b','b','a','a','a','b','b','b','b', 'b','a','a','b','a','b','b','b','a','b','a','b','a', 'a','a','b','b','b','b','b','b','b','b','a','a','a', 'a','b','b','b','b','a','b','b','a'] possible_types = ['a','c','b'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) """ self.assertEqual(script, ref_script) # Try another one. # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(1,1,1), periodic=(False,False,False)) types = ['ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure'] possible_types = ['ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure', "A", "B", "CDEFGHI"] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=possible_types) # Get the script. script = config._script(variable_name="config") ref_script = """ # ----------------------------------------------------------------------------- # Unit cell cell_vectors = [[ 2.800000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 3.200000e+00, 0.000000e+00], [ 0.000000e+00, 5.000000e-01, 3.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # ----------------------------------------------------------------------------- # Lattice lattice = KMCLattice( unit_cell=unit_cell, repetitions=(1,1,1), periodic=(False, False, False)) # ----------------------------------------------------------------------------- # Configuration types = ['ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure'] possible_types = ['A','CDEFGHI','ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure', 'B'] config = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) """ self.assertEqual(script, ref_script)
def testFlush2(self): """ Test the file output. """ # Get a file name. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "..") name = os.path.join(name, "TestUtilities", "Scratch") trajectory_filename = os.path.join(name, "tmp_trajectory.xyz") if MPICommons.isMaster(): self.__files_to_remove.append(trajectory_filename) # Setup the trajectory object. unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], basis_points=[[0.0, 0.0, 0.0]]) lattice = KMCLattice(unit_cell=unit_cell, periodic=(True, False, True), repetitions=(4,4,4)) config = KMCConfiguration(lattice=lattice, types=["A","B","C","D"]*16) t = XYZTrajectory(trajectory_filename=trajectory_filename, configuration=config, max_buffer_size=12345, max_buffer_time=123.0) # Set data directly on the class. t._XYZTrajectory__atom_id_types = [("A","B","C","D","E"), ("This","is","the","next","step")] t._XYZTrajectory__atom_id_coordinates = [numpy.zeros((5,3)), numpy.ones((5,3))*1.234] t._XYZTrajectory__step = [0, 12] t._XYZTrajectory__time = [12.123,75.43] # Flush. t.flush() ref_content = """KMCLib XYZ FORMAT VERSION 2013.10.15 CELL VECTORS a: 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 b: 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 c: 0.0000000000e+00 0.0000000000e+00 1.0000000000e+00 REPETITIONS 4 4 4 PERIODICITY True False True STEP 0 5 TIME 1.2123000000e+01 A 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 0 B 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 1 C 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 2 D 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 3 E 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 4 STEP 12 5 TIME 7.5430000000e+01 This 1.2340000000e+00 1.2340000000e+00 1.2340000000e+00 0 is 1.2340000000e+00 1.2340000000e+00 1.2340000000e+00 1 the 1.2340000000e+00 1.2340000000e+00 1.2340000000e+00 2 next 1.2340000000e+00 1.2340000000e+00 1.2340000000e+00 3 step 1.2340000000e+00 1.2340000000e+00 1.2340000000e+00 4 """ if MPICommons.isMaster(): with open(trajectory_filename, "r") as f: content = f.read() self.assertEqual( content, ref_content ) # Check that the buffers are empty. self.assertEqual(t._XYZTrajectory__atom_id_types, []) self.assertEqual(t._XYZTrajectory__atom_id_coordinates, []) self.assertEqual(t._XYZTrajectory__time, []) self.assertEqual(t._XYZTrajectory__step, [])
def testConstructionFailLongFormat(self): """ Test everything that can go wrong when constructing with the long fomat. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 3, 2), periodic=(True, True, False)) types = [(0, 0, 0, 0, 'g'), (3, 2, 1, 2, 'h')] default_type = 'a' # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, default_type=default_type) # This fails because the lattice is of wrong type. self.assertRaises( Error, lambda: KMCConfiguration( lattice=unit_cell, types=types, default_type=default_type)) # This fails because no default type is given. self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types)) # This fails because no default type is not a string. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types, default_type=['a'])) # This fails because the possible types are not set correctly. self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types, default_type=default_type, possible_types="agh")) # This fails because there are types missing in the possible types. self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types, default_type=default_type, possible_types=['a', 'h'])) # This fails because there is a wildcard character in the possible types list. self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types, default_type=default_type, possible_types=['g', 'a', '*', 'h'])) types_1 = [123, 345] # This fails because of wrong type in the types list. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 0, 0, 'a'), (0, 0, 0, 'a')] # This fails because of wrong type in the types list. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 0, 0, 'a'), (0, 0, 0, 1, 'b', 3)] # This fails because of wrong type in the types list. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [[0, 0, 0, 0, 'a'], [0, 0, 0, 1, 'b']] # This fails because of wrong type in the types list. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 0, 0, 'a'), (-1, 0, 0, 0, 'b')] # This fails because of a negative first index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(100, 0, 0, 0, 'a'), (0, 0, 0, 0, 'b')] # This fails because of a too large firs index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 0, 0, 'a'), (0, -1, 0, 0, 'b')] # This fails because of a negative second index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 100, 0, 0, 'a'), (0, 0, 0, 1, 'b')] # This fails because of a too large second index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 0, 0, 'a'), (0, 0, -1, 0, 'b')] # This fails because of a negative third index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 100, 0, 'a'), (0, 0, 0, 0, 'b')] # This fails because of a too large third index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 0, 0, 'a'), (0, 0, 0, -1, 'b')] # This fails because of a negative fourth index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type)) types_1 = [(0, 0, 0, 100, 'a'), (0, 0, 0, 1, 'b')] # This fails because of a too large fourth index. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types_1, default_type=default_type))
def testFlush(self): """ Test the file output. """ # Get a file name. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "..") name = os.path.join(name, "TestUtilities", "Scratch") trajectory_filename = os.path.join(name, "tmp_trajectory.xyz") if MPICommons.isMaster(): self.__files_to_remove.append(trajectory_filename) # Setup the trajectory object. unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], basis_points=[[0.0, 0.0, 0.0]]) lattice = KMCLattice(unit_cell=unit_cell, periodic=(True, False, True), repetitions=(4,4,4)) config = KMCConfiguration(lattice=lattice, types=["A","B","C","D"]*16) t = XYZTrajectory(trajectory_filename=trajectory_filename, configuration=config, max_buffer_size=12345, max_buffer_time=123.0) # Store data. simulation_time = 1.234 step = 123 t._storeData(simulation_time, step, config) # Flush. t.flush() # Check the file. ref_content = """KMCLib XYZ FORMAT VERSION 2013.10.15 CELL VECTORS a: 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 b: 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 c: 0.0000000000e+00 0.0000000000e+00 1.0000000000e+00 REPETITIONS 4 4 4 PERIODICITY True False True STEP 123 64 TIME 1.2340000000e+00 A 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 0 B 0.0000000000e+00 0.0000000000e+00 1.0000000000e+00 1 C 0.0000000000e+00 0.0000000000e+00 2.0000000000e+00 2 D 0.0000000000e+00 0.0000000000e+00 3.0000000000e+00 3 A 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 4 B 0.0000000000e+00 1.0000000000e+00 1.0000000000e+00 5 C 0.0000000000e+00 1.0000000000e+00 2.0000000000e+00 6 D 0.0000000000e+00 1.0000000000e+00 3.0000000000e+00 7 A 0.0000000000e+00 2.0000000000e+00 0.0000000000e+00 8 B 0.0000000000e+00 2.0000000000e+00 1.0000000000e+00 9 C 0.0000000000e+00 2.0000000000e+00 2.0000000000e+00 10 D 0.0000000000e+00 2.0000000000e+00 3.0000000000e+00 11 A 0.0000000000e+00 3.0000000000e+00 0.0000000000e+00 12 B 0.0000000000e+00 3.0000000000e+00 1.0000000000e+00 13 C 0.0000000000e+00 3.0000000000e+00 2.0000000000e+00 14 D 0.0000000000e+00 3.0000000000e+00 3.0000000000e+00 15 A 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 16 B 1.0000000000e+00 0.0000000000e+00 1.0000000000e+00 17 C 1.0000000000e+00 0.0000000000e+00 2.0000000000e+00 18 D 1.0000000000e+00 0.0000000000e+00 3.0000000000e+00 19 A 1.0000000000e+00 1.0000000000e+00 0.0000000000e+00 20 B 1.0000000000e+00 1.0000000000e+00 1.0000000000e+00 21 C 1.0000000000e+00 1.0000000000e+00 2.0000000000e+00 22 D 1.0000000000e+00 1.0000000000e+00 3.0000000000e+00 23 A 1.0000000000e+00 2.0000000000e+00 0.0000000000e+00 24 B 1.0000000000e+00 2.0000000000e+00 1.0000000000e+00 25 C 1.0000000000e+00 2.0000000000e+00 2.0000000000e+00 26 D 1.0000000000e+00 2.0000000000e+00 3.0000000000e+00 27 A 1.0000000000e+00 3.0000000000e+00 0.0000000000e+00 28 B 1.0000000000e+00 3.0000000000e+00 1.0000000000e+00 29 C 1.0000000000e+00 3.0000000000e+00 2.0000000000e+00 30 D 1.0000000000e+00 3.0000000000e+00 3.0000000000e+00 31 A 2.0000000000e+00 0.0000000000e+00 0.0000000000e+00 32 B 2.0000000000e+00 0.0000000000e+00 1.0000000000e+00 33 C 2.0000000000e+00 0.0000000000e+00 2.0000000000e+00 34 D 2.0000000000e+00 0.0000000000e+00 3.0000000000e+00 35 A 2.0000000000e+00 1.0000000000e+00 0.0000000000e+00 36 B 2.0000000000e+00 1.0000000000e+00 1.0000000000e+00 37 C 2.0000000000e+00 1.0000000000e+00 2.0000000000e+00 38 D 2.0000000000e+00 1.0000000000e+00 3.0000000000e+00 39 A 2.0000000000e+00 2.0000000000e+00 0.0000000000e+00 40 B 2.0000000000e+00 2.0000000000e+00 1.0000000000e+00 41 C 2.0000000000e+00 2.0000000000e+00 2.0000000000e+00 42 D 2.0000000000e+00 2.0000000000e+00 3.0000000000e+00 43 A 2.0000000000e+00 3.0000000000e+00 0.0000000000e+00 44 B 2.0000000000e+00 3.0000000000e+00 1.0000000000e+00 45 C 2.0000000000e+00 3.0000000000e+00 2.0000000000e+00 46 D 2.0000000000e+00 3.0000000000e+00 3.0000000000e+00 47 A 3.0000000000e+00 0.0000000000e+00 0.0000000000e+00 48 B 3.0000000000e+00 0.0000000000e+00 1.0000000000e+00 49 C 3.0000000000e+00 0.0000000000e+00 2.0000000000e+00 50 D 3.0000000000e+00 0.0000000000e+00 3.0000000000e+00 51 A 3.0000000000e+00 1.0000000000e+00 0.0000000000e+00 52 B 3.0000000000e+00 1.0000000000e+00 1.0000000000e+00 53 C 3.0000000000e+00 1.0000000000e+00 2.0000000000e+00 54 D 3.0000000000e+00 1.0000000000e+00 3.0000000000e+00 55 A 3.0000000000e+00 2.0000000000e+00 0.0000000000e+00 56 B 3.0000000000e+00 2.0000000000e+00 1.0000000000e+00 57 C 3.0000000000e+00 2.0000000000e+00 2.0000000000e+00 58 D 3.0000000000e+00 2.0000000000e+00 3.0000000000e+00 59 A 3.0000000000e+00 3.0000000000e+00 0.0000000000e+00 60 B 3.0000000000e+00 3.0000000000e+00 1.0000000000e+00 61 C 3.0000000000e+00 3.0000000000e+00 2.0000000000e+00 62 D 3.0000000000e+00 3.0000000000e+00 3.0000000000e+00 63 """ if MPICommons.isMaster(): with open(trajectory_filename, "r") as f: content = f.read() self.assertEqual( content, ref_content ) # Check that the buffers are empty. self.assertEqual(t._XYZTrajectory__atom_id_types, []) self.assertEqual(t._XYZTrajectory__atom_id_coordinates, []) self.assertEqual(t._XYZTrajectory__time, []) self.assertEqual(t._XYZTrajectory__step, [])
def testBufferSize(self): """ Test the buffer size function. """ # Get a file name. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "..") name = os.path.join(name, "TestUtilities", "Scratch") trajectory_filename = os.path.join(name, "tmp_trajectory.xyz") if MPICommons.isMaster(): self.__files_to_remove.append(trajectory_filename) # Setup the trajectory object. unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], basis_points=[[0.0, 0.0, 0.0]]) lattice = KMCLattice(unit_cell=unit_cell, periodic=(True, True, True), repetitions=(4,4,4)) config = KMCConfiguration(lattice=lattice, types=["A","B","C","D"]*16) t = XYZTrajectory(trajectory_filename=trajectory_filename, configuration=config, max_buffer_size=12345, max_buffer_time=123.0) # Store a bunch of data. simulation_time = 1.234 step = 123 t._storeData(simulation_time, step, config) buffer_size = t._bufferSize() # Check the size again. ref_size = sys.getsizeof(t._XYZTrajectory__atom_id_coordinates) ref_size += sys.getsizeof(t._XYZTrajectory__atom_id_coordinates[0])*len(t._XYZTrajectory__atom_id_coordinates) ref_size += sys.getsizeof(t._XYZTrajectory__atom_id_types) ref_size += sys.getsizeof(t._XYZTrajectory__atom_id_types[0])*len(t._XYZTrajectory__atom_id_types) ref_size += sys.getsizeof(t._XYZTrajectory__time) ref_size += sys.getsizeof(t._XYZTrajectory__time[0])*len(t._XYZTrajectory__time) ref_size += sys.getsizeof(t._XYZTrajectory__step) ref_size += sys.getsizeof(t._XYZTrajectory__step[0])*len(t._XYZTrajectory__step) self.assertEqual(buffer_size, ref_size) # Store more data. t._storeData(simulation_time, step, config) # Check the size again. t._storeData(simulation_time, step, config) t._storeData(simulation_time, step, config) t._storeData(simulation_time, step, config) t._storeData(simulation_time, step, config) t._storeData(simulation_time, step, config) ref_size = sys.getsizeof(t._XYZTrajectory__atom_id_coordinates) ref_size += sys.getsizeof(t._XYZTrajectory__atom_id_coordinates[0])*len(t._XYZTrajectory__atom_id_coordinates) ref_size += sys.getsizeof(t._XYZTrajectory__atom_id_types) ref_size += sys.getsizeof(t._XYZTrajectory__atom_id_types[0])*len(t._XYZTrajectory__atom_id_types) ref_size += sys.getsizeof(t._XYZTrajectory__time) ref_size += sys.getsizeof(t._XYZTrajectory__time[0])*len(t._XYZTrajectory__time) ref_size += sys.getsizeof(t._XYZTrajectory__step) ref_size += sys.getsizeof(t._XYZTrajectory__step[0])*len(t._XYZTrajectory__step) buffer_size = t._bufferSize() self.assertEqual(buffer_size, ref_size)
def testConstructionFailShort(self): """ Test every thing that should fail when using the short format. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 3, 2), periodic=(True, True, False)) types = [ 'g', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'h' ] default_type = 'a' # This fails because the lattice is of wrong type. self.assertRaises( Error, lambda: KMCConfiguration(lattice=unit_cell, types=types)) # This fails because there is a default type given. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types, default_type=default_type)) # This fails becaulse of wrong length of the types. types_1 = ['g', 'a', 'a'] self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types_1)) types_1 = [ 'g', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 3, 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 1 ] # This fails because of the wrong type of the types information. self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types_1)) types_1 = "ABCDE" # And this also. self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types_1)) # Use an incompatible possible types list. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types, possible_types=['a'])) # Use an incompatible possible types list. self.assertRaises( Error, lambda: KMCConfiguration( lattice=lattice, types=types, possible_types="ABCD")) # Use a possible types list with a wildcard. self.assertRaises( Error, lambda: KMCConfiguration(lattice=lattice, types=types, possible_types=['g', 'a', 'h', '*']))
def testRunRngTypeDevice(self): """ Test to use the PRNG DEVICE. """ # Cell. cell_vectors = [[ 1.000000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 1.000000e+00, 0.000000e+00], [ 0.000000e+00, 0.000000e+00, 1.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # Lattice. lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True, True, False)) # Configuration. types = ['B']*16 possible_types = ['A','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # Interactions. coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] process_0 = KMCProcess(coordinates, ['A'], ['B'], basis_sites=[0], rate_constant=4.0) process_1 = KMCProcess(coordinates, ['B'], ['A'], basis_sites=[0], rate_constant=1.0) processes = [process_0, process_1] interactions = KMCInteractions(processes) # Setup the model. ab_flip_model_DEVICE = KMCLatticeModel(configuration, interactions) support_device = False if (not support_device): # If DEVICE is not supported on your system this is the test you should run. self.assertRaises( Error, lambda: ab_flip_model_DEVICE.run(KMCControlParameters(number_of_steps=10000, dump_interval=5000, seed=2013, rng_type="DEVICE"))) else: # If DEVICE is supported the aboove test will fail, and you should run this tests instead. # Run the model for 10000 steps with DEVICE. ab_flip_model_DEVICE.run(KMCControlParameters(number_of_steps=10000, dump_interval=5000, seed=2013, rng_type="DEVICE")) # Get the simulation time out. t_DEVICE = ab_flip_model_DEVICE._KMCLatticeModel__cpp_timer.simulationTime() self.assertTrue(t_DEVICE < 410.0 and t_DEVICE > 370.0)
def testConstruction(self): """ Test the construction of the lattice model """ # Setup a unitcell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['A','A','A','A','B','B', 'A','A','A','B','B','B', 'B','B','A','A','B','A', 'B','B','B','A','B','A', 'B','A','A','A','B','B', 'B','B','B','B','B','B', 'A','A','A','A','B','B', 'B','B','A','B','B','A'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['A','C','B']) # A first process. coords = [[1.0,2.0,3.4],[1.1,1.2,1.3]] types0 = ["A","B"] types1 = ["B","A"] sites = [0,1,2] rate_0_1 = 3.5 process_0 = KMCProcess(coords, types0, types1, basis_sites=sites, rate_constant=rate_0_1) # A second process. coords = [[1.0,2.0,3.4],[1.1,1.2,1.3]] types0 = ["A","C"] types1 = ["C","A"] sites = [0,1,2] rate_0_1 = 1.5 process_1 = KMCProcess(coords, types0, types1, basis_sites=sites, rate_constant=rate_0_1) # Construct the interactions object. processes = [process_0, process_1] interactions = KMCInteractions(processes=processes) # Construct the model. model = KMCLatticeModel(config, interactions) # Check that it has the attribute _backend which is None self.assertTrue(hasattr(model,"_KMCLatticeModel__backend")) self.assertTrue(model._KMCLatticeModel__backend is None) # Check that it has the correct interactions stored. self.assertTrue(model._KMCLatticeModel__interactions == interactions) # Check that it has the correct configuration stored. self.assertTrue(model._KMCLatticeModel__configuration == config)
def testRunTrajectory(self): """ Test the run of an A-B flip model with trajectory output. """ # Cell. cell_vectors = [[ 1.000000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 1.000000e+00, 0.000000e+00], [ 0.000000e+00, 0.000000e+00, 1.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # Lattice. lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True, True, False)) # Configuration. types = ['B']*16 possible_types = ['A','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # Interactions. coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] process_0 = KMCProcess(coordinates, ['A'], ['B'], basis_sites=[0], rate_constant=4.0) process_1 = KMCProcess(coordinates, ['B'], ['A'], basis_sites=[0], rate_constant=1.0) processes = [process_0, process_1] interactions = KMCInteractions(processes) # Setup the model. ab_flip_model = KMCLatticeModel(configuration, interactions) # Construct the trajectory fileames. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "TestUtilities", "Scratch") lattice_trajectory_filename = os.path.join(name, "ab_flip_traj_lattice.py") xyz_trajectory_filename = os.path.join(name, "ab_flip_traj_xyz.xyz") self.__files_to_remove.append(lattice_trajectory_filename) self.__files_to_remove.append(xyz_trajectory_filename) # The control parameters. control_parameters = KMCControlParameters(number_of_steps=1000, dump_interval=500, seed=2013) # Run the model for 1000 steps with a lattice trajectory. ab_flip_model.run(control_parameters, trajectory_filename=lattice_trajectory_filename, trajectory_type='lattice') # Check the file content. ref_lattice = """ sites=[[ 0.000000, 0.000000, 0.000000], [ 0.000000, 1.000000, 0.000000], [ 0.000000, 2.000000, 0.000000], [ 0.000000, 3.000000, 0.000000], [ 1.000000, 0.000000, 0.000000], [ 1.000000, 1.000000, 0.000000], [ 1.000000, 2.000000, 0.000000], [ 1.000000, 3.000000, 0.000000], [ 2.000000, 0.000000, 0.000000], [ 2.000000, 1.000000, 0.000000], [ 2.000000, 2.000000, 0.000000], [ 2.000000, 3.000000, 0.000000], [ 3.000000, 0.000000, 0.000000], [ 3.000000, 1.000000, 0.000000], [ 3.000000, 2.000000, 0.000000], [ 3.000000, 3.000000, 0.000000]] times=[] steps=[] types=[] times.append( 0.0000000000e+00) steps.append(0) types.append(["B","B","B","B","B","B","B","B","B","B","B","B","B","B","B","B"]) times.append( 1.9093684175e+01) steps.append(500) types.append(["B","A","B","B","A","B","B","B","A","B","B","B","B","B","B","A"]) times.append( 4.0622006972e+01) steps.append(1000) types.append(["B","A","A","B","B","B","B","A","B","B","B","A","B","B","B","B"]) """ with open(lattice_trajectory_filename, "r") as t: lattice_data = t.read() # Check with "in" to avoid comparing dates. self.assertTrue(ref_lattice in lattice_data) # Run the model for 1000 steps with an xyz trajectory. ab_flip_model.run(control_parameters, trajectory_filename=xyz_trajectory_filename, trajectory_type='xyz') ref_xyz = """KMCLib XYZ FORMAT VERSION 2013.10.15 CELL VECTORS a: 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 b: 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 c: 0.0000000000e+00 0.0000000000e+00 1.0000000000e+00 REPETITIONS 4 1 1 PERIODICITY True True False STEP 0 16 TIME 4.0622006972e+01 B 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 0 A 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 1 A 0.0000000000e+00 2.0000000000e+00 0.0000000000e+00 2 B 0.0000000000e+00 3.0000000000e+00 0.0000000000e+00 3 B 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 4 B 1.0000000000e+00 1.0000000000e+00 0.0000000000e+00 5 B 1.0000000000e+00 2.0000000000e+00 0.0000000000e+00 6 A 1.0000000000e+00 3.0000000000e+00 0.0000000000e+00 7 B 2.0000000000e+00 0.0000000000e+00 0.0000000000e+00 8 B 2.0000000000e+00 1.0000000000e+00 0.0000000000e+00 9 B 2.0000000000e+00 2.0000000000e+00 0.0000000000e+00 10 A 2.0000000000e+00 3.0000000000e+00 0.0000000000e+00 11 B 3.0000000000e+00 0.0000000000e+00 0.0000000000e+00 12 B 3.0000000000e+00 1.0000000000e+00 0.0000000000e+00 13 B 3.0000000000e+00 2.0000000000e+00 0.0000000000e+00 14 B 3.0000000000e+00 3.0000000000e+00 0.0000000000e+00 15 STEP 500 16 TIME 5.9660935122e+01 B 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 0 A 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 1 B 0.0000000000e+00 2.0000000000e+00 0.0000000000e+00 2 B 0.0000000000e+00 3.0000000000e+00 0.0000000000e+00 3 B 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 4 B 1.0000000000e+00 1.0000000000e+00 0.0000000000e+00 5 B 1.0000000000e+00 2.0000000000e+00 0.0000000000e+00 6 A 1.0000000000e+00 3.0000000000e+00 0.0000000000e+00 7 B 2.0000000000e+00 0.0000000000e+00 0.0000000000e+00 8 B 2.0000000000e+00 1.0000000000e+00 0.0000000000e+00 9 B 2.0000000000e+00 2.0000000000e+00 0.0000000000e+00 10 B 2.0000000000e+00 3.0000000000e+00 0.0000000000e+00 11 A 3.0000000000e+00 0.0000000000e+00 0.0000000000e+00 12 A 3.0000000000e+00 1.0000000000e+00 0.0000000000e+00 13 B 3.0000000000e+00 2.0000000000e+00 0.0000000000e+00 14 B 3.0000000000e+00 3.0000000000e+00 0.0000000000e+00 15 STEP 1000 16 TIME 8.1189257919e+01 A 0.0000000000e+00 0.0000000000e+00 0.0000000000e+00 0 B 0.0000000000e+00 1.0000000000e+00 0.0000000000e+00 1 B 0.0000000000e+00 2.0000000000e+00 0.0000000000e+00 2 B 0.0000000000e+00 3.0000000000e+00 0.0000000000e+00 3 B 1.0000000000e+00 0.0000000000e+00 0.0000000000e+00 4 A 1.0000000000e+00 1.0000000000e+00 0.0000000000e+00 5 B 1.0000000000e+00 2.0000000000e+00 0.0000000000e+00 6 B 1.0000000000e+00 3.0000000000e+00 0.0000000000e+00 7 B 2.0000000000e+00 0.0000000000e+00 0.0000000000e+00 8 B 2.0000000000e+00 1.0000000000e+00 0.0000000000e+00 9 A 2.0000000000e+00 2.0000000000e+00 0.0000000000e+00 10 A 2.0000000000e+00 3.0000000000e+00 0.0000000000e+00 11 B 3.0000000000e+00 0.0000000000e+00 0.0000000000e+00 12 B 3.0000000000e+00 1.0000000000e+00 0.0000000000e+00 13 B 3.0000000000e+00 2.0000000000e+00 0.0000000000e+00 14 B 3.0000000000e+00 3.0000000000e+00 0.0000000000e+00 15 """ with open(xyz_trajectory_filename, "r") as t: xyz_data = t.read() self.assertEqual(ref_xyz, xyz_data) # Running with wrong trajectory_type input fails. self.assertRaises( Error, lambda : ab_flip_model.run(control_parameters, trajectory_filename=xyz_trajectory_filename, trajectory_type='abc') ) self.assertRaises( Error, lambda : ab_flip_model.run(control_parameters, trajectory_filename=xyz_trajectory_filename, trajectory_type=123) )
def testCustomRatesRun(self): """ Test the run of an A-B flip model with custom rates. """ # Cell. cell_vectors = [[ 1.000000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 1.000000e+00, 0.000000e+00], [ 0.000000e+00, 0.000000e+00, 1.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # Lattice. lattice = KMCLattice( unit_cell=unit_cell, repetitions=(10,10,1), periodic=(True, True, False)) # Configuration. types = ['B']*100 possible_types = ['A','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # Interactions. coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] process_0 = KMCProcess(coordinates, ['A'], ['B'], None, [0], 4.0) process_1 = KMCProcess(coordinates, ['B'], ['A'], None, [0], 1.0) processes = [process_0, process_1] interactions = KMCInteractions(processes, implicit_wildcards=True) # Custom rates. rate_calculator = CustomRateCalculator interactions.setRateCalculator(rate_calculator) # Setup the model. ab_flip_model = KMCLatticeModel(configuration, interactions) # Run the model with a trajectory file. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "TestUtilities", "Scratch") trajectory_filename = os.path.join(name, "ab_flip_traj_custom.py") self.__files_to_remove.append(trajectory_filename) # The control parameters. control_parameters = KMCControlParameters(number_of_steps=1000, dump_interval=500, seed=2013) # Run the model for 1000 steps. ab_flip_model.run(control_parameters, trajectory_filename=trajectory_filename) # Read the first last frames from the trajectory file and check that # the fraction of A is close to 75% in the last, and 0 in the first. if MPICommons.isMaster(): global_dict = {} local_dict = {} execfile(trajectory_filename, global_dict, local_dict) # Count the first frame. elem = local_dict["types"][0] nA = len([ ee for ee in elem if ee == "A" ]) nB = len([ ee for ee in elem if ee == "B" ]) self.assertEqual(nA, 0) self.assertEqual(nB, 100) # Count the last frame. elem = local_dict["types"][-1] nA = len([ ee for ee in elem if ee == "A" ]) nB = len([ ee for ee in elem if ee == "B" ]) # Note that the average over a long simulation should be # 75% A using the modified rate function. In this particular # step the A population is 74%. value = 1.0 * nA / (nA + nB) self.assertAlmostEqual(0.74, value, 2)
def testATKScript1(self): """ Test that we can generate an ATK script from the configuration. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.0, 0.5, 0.5], [0.5, 0.75, 0.75]]) # Setup the lattice and types. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(1, 1, 1), periodic=(False, False, False)) types = ['B', 'A', 'C'] possible_types = ['C', "A", "B", "D"] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=possible_types) # Determine a mapping between our types and valid ATK types. # Types not present in the mapping are ignored in the ATK script. types_mapping = { 'A': 'Copper', 'C': 'Iron', 'D': 'Vanadium', } # Get the ATK script. atk_script = config._atkScript(types_mapping) # Check that it looks as we expect. ref_script = """# ---------------------------------------------------------- # ATK 12.8.2 BulkConfiguration script generated from KMCLib # configuration version 1.0. # ---------------------------------------------------------- # Specify the lattice parameters. vector_a = [ 2.80000000, 0.00000000, 0.00000000]*Angstrom vector_b = [ 0.00000000, 3.20000000, 0.00000000]*Angstrom vector_c = [ 0.00000000, 0.50000000, 3.00000000]*Angstrom lattice = UnitCell(vector_a, vector_b, vector_c) # Define the elements. elements = [Copper, Iron] # Define the coordinates. coordinates = [[ 0.00000000e+00, 5.00000000e-01, 5.00000000e-01], [ 5.00000000e-01, 7.50000000e-01, 7.50000000e-01]] # Setup the configuration. bulk_configuration = BulkConfiguration( bravais_lattice=lattice, elements=elements, fractional_coordinates=coordinates ) # ---------------------------------------------------------- """ self.assertEqual(atk_script, ref_script)
def testScript(self): """ Test that we can generate a valid script. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 4, 1), periodic=(True, True, False)) types = [ 'a', 'a', 'a', 'a', 'b', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'b', 'a', 'b', 'b', 'b', 'a', 'b', 'a', 'b', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'a', 'b', 'b', 'a' ] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['a', 'c', 'b']) # Get the script. script = config._script() ref_script = """ # ----------------------------------------------------------------------------- # Unit cell cell_vectors = [[ 2.800000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 3.200000e+00, 0.000000e+00], [ 0.000000e+00, 5.000000e-01, 3.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 5.000000e-01, 5.000000e-01, 5.000000e-01], [ 2.500000e-01, 2.500000e-01, 7.500000e-01]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # ----------------------------------------------------------------------------- # Lattice lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True, True, False)) # ----------------------------------------------------------------------------- # Configuration types = ['a','a','a','a','b','b','a','a','a','b','b','b','b', 'b','a','a','b','a','b','b','b','a','b','a','b','a', 'a','a','b','b','b','b','b','b','b','b','a','a','a', 'a','b','b','b','b','a','b','b','a'] possible_types = ['a','c','b'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) """ self.assertEqual(script, ref_script) # Try another one. # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8, 0.0, 0.0], [0.0, 3.2, 0.0], [0.0, 0.5, 3.0]]), basis_points=[[0.0, 0.0, 0.0]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(1, 1, 1), periodic=(False, False, False)) types = [ 'ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure' ] possible_types = [ 'ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure', "A", "B", "CDEFGHI" ] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=possible_types) # Get the script. script = config._script(variable_name="config") ref_script = """ # ----------------------------------------------------------------------------- # Unit cell cell_vectors = [[ 2.800000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 3.200000e+00, 0.000000e+00], [ 0.000000e+00, 5.000000e-01, 3.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # ----------------------------------------------------------------------------- # Lattice lattice = KMCLattice( unit_cell=unit_cell, repetitions=(1,1,1), periodic=(False, False, False)) # ----------------------------------------------------------------------------- # Configuration types = ['ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure'] possible_types = ['A','CDEFGHI','ThisIsTheTypeOfMyOnlySiteInThisUnrealisticallyShortStructure', 'B'] config = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) """ self.assertEqual(script, ref_script)
def testRunRngType(self): """ Test that it is possible to run with each of the supported PRNG:s. """ # Cell. cell_vectors = [[ 1.000000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 1.000000e+00, 0.000000e+00], [ 0.000000e+00, 0.000000e+00, 1.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # Lattice. lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True, True, False)) # Configuration. types = ['B']*16 possible_types = ['A','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # Interactions. coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] process_0 = KMCProcess(coordinates, ['A'], ['B'], basis_sites=[0], rate_constant=4.0) process_1 = KMCProcess(coordinates, ['B'], ['A'], basis_sites=[0], rate_constant=1.0) processes = [process_0, process_1] interactions = KMCInteractions(processes) # Setup the models. ab_flip_model_MT = KMCLatticeModel(configuration, interactions) ab_flip_model_RANLUX24 = KMCLatticeModel(configuration, interactions) ab_flip_model_RANLUX48 = KMCLatticeModel(configuration, interactions) ab_flip_model_MINSTD = KMCLatticeModel(configuration, interactions) ab_flip_model_DEVICE = KMCLatticeModel(configuration, interactions) # Run the model for 10000 steps with MT. ab_flip_model_MT.run(KMCControlParameters(number_of_steps=10000, dump_interval=5000, seed=2013, rng_type="MT")) # Get the simulation time out. t_MT = ab_flip_model_MT._KMCLatticeModel__cpp_timer.simulationTime() # Run the model for 10000 steps with RANLUX24. ab_flip_model_RANLUX24.run(KMCControlParameters(number_of_steps=10000, dump_interval=5000, seed=2013, rng_type="RANLUX24")) # Get the simulation time out. t_RANLUX24 = ab_flip_model_RANLUX24._KMCLatticeModel__cpp_timer.simulationTime() # Run the model for 10000 steps with RANLUX48. ab_flip_model_RANLUX48.run(KMCControlParameters(number_of_steps=10000, dump_interval=5000, seed=2013, rng_type="RANLUX48")) # Get the simulation time out. t_RANLUX48 = ab_flip_model_RANLUX48._KMCLatticeModel__cpp_timer.simulationTime() # Run the model for 10000 steps with MINSTD. ab_flip_model_MINSTD.run(KMCControlParameters(number_of_steps=10000, dump_interval=5000, seed=2013, rng_type="MINSTD")) # Get the simulation time out. t_MINSTD = ab_flip_model_MINSTD._KMCLatticeModel__cpp_timer.simulationTime() # These values should be simillar but not equal. Check against hardcoded values. self.assertAlmostEqual(t_MT, 394.569398158, 5) self.assertAlmostEqual(t_RANLUX24, 389.712162523, 5) self.assertAlmostEqual(t_RANLUX48, 390.544423280, 5) self.assertAlmostEqual(t_MINSTD, 384.712302086, 5)
def testRunFailAnalysis(self): """ Test that the analyis plugins get called correctly. """ # Cell. cell_vectors = [[ 1.000000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 1.000000e+00, 0.000000e+00], [ 0.000000e+00, 0.000000e+00, 1.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # Lattice. lattice = KMCLattice( unit_cell=unit_cell, repetitions=(10,10,1), periodic=(True, True, False)) # Configuration. types = ['B']*100 possible_types = ['A','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # Interactions. coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] process_0 = KMCProcess(coordinates, ['A'], ['B'], basis_sites=[0], rate_constant=4.0) process_1 = KMCProcess(coordinates, ['B'], ['A'], basis_sites=[0], rate_constant=1.0) processes = [process_0, process_1] interactions = KMCInteractions(processes) # Setup the model. ab_flip_model = KMCLatticeModel(configuration, interactions) # The control parameters. control_parameters = KMCControlParameters(number_of_steps=1000, dump_interval=500) # Setup a valid minimal analysis object. class AnalysisProxy1(KMCAnalysisPlugin): def __init__(self): pass # Fail because of not instantitated analysis. self.assertRaises( Error, lambda : ab_flip_model.run(control_parameters, analysis=[AnalysisProxy1]) ) # Fail because of empty analyis list. self.assertRaises( Error, lambda : ab_flip_model.run(control_parameters, analysis=[]) ) # Fail because of not list. self.assertRaises( Error, lambda : ab_flip_model.run(control_parameters, analysis=AnalysisProxy1()) ) # Fail because of wrong type. self.assertRaises( Error, lambda : ab_flip_model.run(control_parameters, analysis=[AnalysisProxy1(), "AP3"]) )
def testATKScript2(self): """ Test that we can generate an ATK script from the configuration. """ # Setup a valid KMCUnitCell. cell_vectors = [[ 5.640000e+00, 0.330000e+00, 0.120000e+00], [ 0.110000e+00, 5.460000e+00, 0.100000e+00], [ 0.500000e+00, 0.430000e+00, 5.410000e+00]] basis_points = [[ 0.200000e+00, 0.300000e+00, 0.400000e+00], [ 5.200000e-01, 5.400000e-01, 5.010000e-01]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # Setup the lattice and types. lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,4), periodic=(True, True, True)) types = ['Ce3','O','Empty','O','Ce','O','Empty','O','Empty', 'O','Ce','O','Empty','Vacancy','Ce','O','Ce','O','Empty', 'O','Ce','O','Empty','O','Empty','O','Ce','O','Empty', 'O','Ce','O','Empty','O','Ce','O','Empty','O','Ce', 'O','Ce3','O','Empty','O','Ce','O','Empty','O','Empty', 'O','Ce','O','Empty','O','Ce','O','Ce','O','Empty', 'O','Ce','O','Empty','O','Ce','O','Empty','O','Ce', 'O','Empty','O','Empty','O','Ce','O','Empty','O','Ce', 'O','Ce','O','Empty','O','Ce','O','Empty','O','Empty', 'O','Ce','O','Empty','O','Ce','O','Empty','O','Ce', 'O','Empty','O','Ce','O','Ce','O','Empty','O','Ce', 'O','Empty','O','Empty','O','Ce','O','Empty','O','Ce', 'O','Ce','O','Empty','O','Ce','O','Empty','O'] possible_types = ['Ce3','Empty','O','Ce','Vacancy'] # Setup the configuration. configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # Determine a mapping between our types and valid ATK types. # Types not present in the mapping are ignored in the ATK script. type_map = { "Ce3" : "Vanadium", "Ce" : "Cerium", "O" : "Oxygen", } # Get the ATK script. atk_script = configuration._atkScript(type_map) # Check that it looks as we expect. ref_script = """# ---------------------------------------------------------- # ATK 12.8.2 BulkConfiguration script generated from KMCLib # configuration version 1.0. # ---------------------------------------------------------- # Specify the lattice parameters. vector_a = [ 22.56000000, 1.32000000, 0.48000000]*Angstrom vector_b = [ 0.44000000, 21.84000000, 0.40000000]*Angstrom vector_c = [ 2.00000000, 1.72000000, 21.64000000]*Angstrom lattice = UnitCell(vector_a, vector_b, vector_c) # Define the elements. elements = [Vanadium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Vanadium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen] # Define the coordinates. coordinates = [[ 5.00000000e-02, 7.50000000e-02, 1.00000000e-01], [ 1.30000000e-01, 1.35000000e-01, 1.25250000e-01], [ 1.30000000e-01, 1.35000000e-01, 3.75250000e-01], [ 5.00000000e-02, 7.50000000e-02, 6.00000000e-01], [ 1.30000000e-01, 1.35000000e-01, 6.25250000e-01], [ 1.30000000e-01, 1.35000000e-01, 8.75250000e-01], [ 1.30000000e-01, 3.85000000e-01, 1.25250000e-01], [ 5.00000000e-02, 3.25000000e-01, 3.50000000e-01], [ 1.30000000e-01, 3.85000000e-01, 3.75250000e-01], [ 5.00000000e-02, 3.25000000e-01, 8.50000000e-01], [ 1.30000000e-01, 3.85000000e-01, 8.75250000e-01], [ 5.00000000e-02, 5.75000000e-01, 1.00000000e-01], [ 1.30000000e-01, 6.35000000e-01, 1.25250000e-01], [ 1.30000000e-01, 6.35000000e-01, 3.75250000e-01], [ 5.00000000e-02, 5.75000000e-01, 6.00000000e-01], [ 1.30000000e-01, 6.35000000e-01, 6.25250000e-01], [ 1.30000000e-01, 6.35000000e-01, 8.75250000e-01], [ 1.30000000e-01, 8.85000000e-01, 1.25250000e-01], [ 5.00000000e-02, 8.25000000e-01, 3.50000000e-01], [ 1.30000000e-01, 8.85000000e-01, 3.75250000e-01], [ 1.30000000e-01, 8.85000000e-01, 6.25250000e-01], [ 5.00000000e-02, 8.25000000e-01, 8.50000000e-01], [ 1.30000000e-01, 8.85000000e-01, 8.75250000e-01], [ 3.80000000e-01, 1.35000000e-01, 1.25250000e-01], [ 3.00000000e-01, 7.50000000e-02, 3.50000000e-01], [ 3.80000000e-01, 1.35000000e-01, 3.75250000e-01], [ 3.80000000e-01, 1.35000000e-01, 6.25250000e-01], [ 3.00000000e-01, 7.50000000e-02, 8.50000000e-01], [ 3.80000000e-01, 1.35000000e-01, 8.75250000e-01], [ 3.00000000e-01, 3.25000000e-01, 1.00000000e-01], [ 3.80000000e-01, 3.85000000e-01, 1.25250000e-01], [ 3.80000000e-01, 3.85000000e-01, 3.75250000e-01], [ 3.00000000e-01, 3.25000000e-01, 6.00000000e-01], [ 3.80000000e-01, 3.85000000e-01, 6.25250000e-01], [ 3.80000000e-01, 3.85000000e-01, 8.75250000e-01], [ 3.80000000e-01, 6.35000000e-01, 1.25250000e-01], [ 3.00000000e-01, 5.75000000e-01, 3.50000000e-01], [ 3.80000000e-01, 6.35000000e-01, 3.75250000e-01], [ 3.80000000e-01, 6.35000000e-01, 6.25250000e-01], [ 3.00000000e-01, 5.75000000e-01, 8.50000000e-01], [ 3.80000000e-01, 6.35000000e-01, 8.75250000e-01], [ 3.00000000e-01, 8.25000000e-01, 1.00000000e-01], [ 3.80000000e-01, 8.85000000e-01, 1.25250000e-01], [ 3.80000000e-01, 8.85000000e-01, 3.75250000e-01], [ 3.00000000e-01, 8.25000000e-01, 6.00000000e-01], [ 3.80000000e-01, 8.85000000e-01, 6.25250000e-01], [ 3.80000000e-01, 8.85000000e-01, 8.75250000e-01], [ 5.50000000e-01, 7.50000000e-02, 1.00000000e-01], [ 6.30000000e-01, 1.35000000e-01, 1.25250000e-01], [ 6.30000000e-01, 1.35000000e-01, 3.75250000e-01], [ 5.50000000e-01, 7.50000000e-02, 6.00000000e-01], [ 6.30000000e-01, 1.35000000e-01, 6.25250000e-01], [ 6.30000000e-01, 1.35000000e-01, 8.75250000e-01], [ 6.30000000e-01, 3.85000000e-01, 1.25250000e-01], [ 5.50000000e-01, 3.25000000e-01, 3.50000000e-01], [ 6.30000000e-01, 3.85000000e-01, 3.75250000e-01], [ 6.30000000e-01, 3.85000000e-01, 6.25250000e-01], [ 5.50000000e-01, 3.25000000e-01, 8.50000000e-01], [ 6.30000000e-01, 3.85000000e-01, 8.75250000e-01], [ 5.50000000e-01, 5.75000000e-01, 1.00000000e-01], [ 6.30000000e-01, 6.35000000e-01, 1.25250000e-01], [ 6.30000000e-01, 6.35000000e-01, 3.75250000e-01], [ 5.50000000e-01, 5.75000000e-01, 6.00000000e-01], [ 6.30000000e-01, 6.35000000e-01, 6.25250000e-01], [ 6.30000000e-01, 6.35000000e-01, 8.75250000e-01], [ 6.30000000e-01, 8.85000000e-01, 1.25250000e-01], [ 5.50000000e-01, 8.25000000e-01, 3.50000000e-01], [ 6.30000000e-01, 8.85000000e-01, 3.75250000e-01], [ 6.30000000e-01, 8.85000000e-01, 6.25250000e-01], [ 5.50000000e-01, 8.25000000e-01, 8.50000000e-01], [ 6.30000000e-01, 8.85000000e-01, 8.75250000e-01], [ 8.80000000e-01, 1.35000000e-01, 1.25250000e-01], [ 8.00000000e-01, 7.50000000e-02, 3.50000000e-01], [ 8.80000000e-01, 1.35000000e-01, 3.75250000e-01], [ 8.80000000e-01, 1.35000000e-01, 6.25250000e-01], [ 8.00000000e-01, 7.50000000e-02, 8.50000000e-01], [ 8.80000000e-01, 1.35000000e-01, 8.75250000e-01], [ 8.00000000e-01, 3.25000000e-01, 1.00000000e-01], [ 8.80000000e-01, 3.85000000e-01, 1.25250000e-01], [ 8.80000000e-01, 3.85000000e-01, 3.75250000e-01], [ 8.00000000e-01, 3.25000000e-01, 6.00000000e-01], [ 8.80000000e-01, 3.85000000e-01, 6.25250000e-01], [ 8.80000000e-01, 3.85000000e-01, 8.75250000e-01], [ 8.80000000e-01, 6.35000000e-01, 1.25250000e-01], [ 8.00000000e-01, 5.75000000e-01, 3.50000000e-01], [ 8.80000000e-01, 6.35000000e-01, 3.75250000e-01], [ 8.80000000e-01, 6.35000000e-01, 6.25250000e-01], [ 8.00000000e-01, 5.75000000e-01, 8.50000000e-01], [ 8.80000000e-01, 6.35000000e-01, 8.75250000e-01], [ 8.00000000e-01, 8.25000000e-01, 1.00000000e-01], [ 8.80000000e-01, 8.85000000e-01, 1.25250000e-01], [ 8.80000000e-01, 8.85000000e-01, 3.75250000e-01], [ 8.00000000e-01, 8.25000000e-01, 6.00000000e-01], [ 8.80000000e-01, 8.85000000e-01, 6.25250000e-01], [ 8.80000000e-01, 8.85000000e-01, 8.75250000e-01]] # Setup the configuration. bulk_configuration = BulkConfiguration( bravais_lattice=lattice, elements=elements, fractional_coordinates=coordinates ) # ---------------------------------------------------------- """ self.assertEqual(atk_script, ref_script)
def testCalculationNonOrthogonal(self): """ Test a calculation with the on-the-fly MSD analysis. """ # Setup a system, a periodic 10 atoms long 1D chain. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.0,1.0,0.0], [0.0,1.0,0.0], [0.0,2.0,1.0]]), basis_points=[[0.0,0.0,0.0]]) # And a lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(10,10,10), periodic=(True,True,True)) # Setup an initial configuration with one B in a sea of A:s. types = ["A"]*10*10*10 types[5] = "B" config = KMCConfiguration(lattice=lattice, types=types, possible_types=["A","B"]) # Setup a diffusion process to the left. coordinates_p0 = [[0.0, 0.0, 0.0],[-1.0, 0.0, 0.0]] p0 = KMCProcess(coordinates=coordinates_p0, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p1 = [[0.0, 0.0, 0.0],[1.0, 0.0, 0.0]] p1 = KMCProcess(coordinates=coordinates_p1, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p2 = [[0.0, 0.0, 0.0],[0.0,-1.0, 0.0]] p2 = KMCProcess(coordinates=coordinates_p2, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p3 = [[0.0, 0.0, 0.0],[0.0, 1.0, 0.0]] p3 = KMCProcess(coordinates=coordinates_p3, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p4 = [[0.0, 0.0, 0.0],[0.0, 0.0,-1.0]] p4 = KMCProcess(coordinates=coordinates_p4, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p5 = [[0.0, 0.0, 0.0],[0.0, 0.0, 1.0]] p5 = KMCProcess(coordinates=coordinates_p5, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) interactions = KMCInteractions(processes=[p0, p1, p2, p3, p4, p5], implicit_wildcards=True) model = KMCLatticeModel(configuration=config, interactions=interactions) # Setup the analysis. msd = OnTheFlyMSD(history_steps=400, n_bins=10, t_max=25.0, track_type="B") # Setup the control parameters. control_parameters = KMCControlParameters(number_of_steps=4000, dump_interval=100, analysis_interval=1, seed=2013) # Run the model. model.run(control_parameters=control_parameters, analysis=[msd]) # Get the results out. results = msd.results() time_steps = msd.timeSteps() std_dev = msd.stdDev() bin_counters = msd.binCounters() # Compare against references. ref_results = numpy.array([[ 11.10849324 , 32.89332622 , 56.86314552 , 84.47799379 , 110.30394149, 135.26081658, 162.25612518, 189.40268295, 219.32538873, 252.00244119], [ 17.33153679 , 50.69982999 , 82.74958435 , 111.33382274 , 136.44824258, 164.84499628, 193.94367236, 234.25340515, 272.64453361, 302.94924061], [ 2.98786918 , 8.65022668 , 14.01808716 , 18.62678885 , 22.65708384, 26.03107861, 30.03937616, 35.1483 , 40.68319007, 47.21074474], [ 28.44003004 , 83.59315621 , 139.61272987 , 195.81181652 , 246.75218407, 300.10581285, 356.19979754, 423.65608811, 491.96992234, 554.95168181], [ 14.09636242 , 41.5435529 , 70.88123268 , 103.10478264 , 132.96102533, 161.29189519, 192.29550134, 224.55098295, 260.00857879, 299.21318593], [ 20.31940597 , 59.35005667 , 96.76767151 , 129.96061158 , 159.10532643, 190.87607489, 223.98304852, 269.40170515, 313.32772368, 350.15998535], [ 31.42789922 , 92.24338289 , 153.63081703 , 214.43860537 , 269.40926791, 326.13689146, 386.2391737 , 458.8043881 , 532.65311241, 602.16242655]]) diff = numpy.linalg.norm(ref_results - results) self.assertAlmostEqual(diff, 0.0, 6) ref_time_steps = numpy.array([ 1.25, 3.75, 6.25, 8.75, 11.25, 13.75, 16.25, 18.75, 21.25, 23.75]) diff = numpy.linalg.norm(ref_time_steps - time_steps) self.assertAlmostEqual(diff, 0.0, 8) ref_std_dev = numpy.array([[ 0.59348826 , 2.92235801 , 6.47651272 , 11.36067446 , 16.79740936, 22.78018427, 29.72954492, 37.27728411, 45.97782684, 55.88661276], [ 0.92596389 , 4.50435001 , 9.42488725 , 14.97226982 , 20.7787406, 27.76265504, 35.53552825, 46.10457783, 57.15527613, 67.18509081], [ 0.15963149 , 0.76851636 , 1.59661093 , 2.50494685 , 3.45028752, 4.38406911 , 5.5039955 , 6.91771175 , 8.52853689 , 10.46993274], [ 1.07441492 , 5.2514756 , 11.24398775 , 18.62020347 , 26.57035045, 35.73918442, 46.14937581, 58.95988 , 72.92611647, 87.02483617], [ 0.53253608 , 2.60984229 , 5.70856048 , 9.80447485 , 14.31728377, 19.20802777, 24.91387536, 31.25058126, 38.54181941, 46.9211633 ], [ 0.76763185 , 3.72847956 , 7.7933761 , 12.35825842 , 17.13251009, 22.73116664, 29.01932554, 37.49242051, 46.4454696 , 54.91039375], [ 0.96941939 , 4.731515 , 10.1024813 , 16.6495642 , 23.68662473, 31.71206536, 40.85854085, 52.13448317, 64.46787783, 77.10029967]]) diff = numpy.linalg.norm(ref_std_dev - std_dev) self.assertAlmostEqual(diff, 0.0, 6) ref_bin_counters = (59930, 59996, 59545, 59256, 59064, 59076, 58284, 58294, 57817, 57349) self.assertEqual(bin_counters, ref_bin_counters)
def testBackend(self): """ Test that the backend object is correctly constructed. """ # Setup a unitcell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['A','A','A','A','B','B', 'A','A','A','B','B','B', 'B','B','A','A','B','A', 'B','B','B','A','B','A', 'B','A','A','A','B','B', 'B','B','B','B','B','B', 'A','A','A','A','B','B', 'B','B','A','B','B','A'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['A','C','B']) # A first process. coords = [[1.0,2.0,3.4],[1.1,1.2,1.3]] types0 = ["A","B"] types1 = ["B","A"] sites = [0,1,2,3,4] rate_0_1 = 3.5 process_0 = KMCProcess(coords, types0, types1, basis_sites=sites, rate_constant=rate_0_1) # A second process. types0 = ["A","C"] types1 = ["C","A"] rate_0_1 = 1.5 process_1 = KMCProcess(coords, types0, types1, basis_sites=sites, rate_constant=rate_0_1) # Construct the interactions object. processes = [process_0, process_1] interactions = KMCInteractions(processes=processes) # Construct the model. model = KMCLatticeModel(config, interactions) # Get the c++ backend out. cpp_model = model._backend() # Check that this backend object is stored on the class. self.assertTrue(model._KMCLatticeModel__backend == cpp_model)
def testRunWithAnalysis(self): """ Test that the analyis plugins get called correctly. """ # Cell. cell_vectors = [[ 1.000000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 1.000000e+00, 0.000000e+00], [ 0.000000e+00, 0.000000e+00, 1.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # Lattice. lattice = KMCLattice( unit_cell=unit_cell, repetitions=(10,10,1), periodic=(True, True, False)) # Configuration. types = ['B']*100 possible_types = ['A','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # Interactions. coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00]] process_0 = KMCProcess(coordinates, ['A'], ['B'], basis_sites=[0], rate_constant=4.0) process_1 = KMCProcess(coordinates, ['B'], ['A'], basis_sites=[0], rate_constant=1.0) processes = [process_0, process_1] interactions = KMCInteractions(processes) # Setup the model. ab_flip_model = KMCLatticeModel(configuration, interactions) # Run the model with a trajectory file. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "TestUtilities", "Scratch") trajectory_filename = os.path.join(name, "ab_flip_traj.py") self.__files_to_remove.append(trajectory_filename) # The control parameters. control_parameters = KMCControlParameters(number_of_steps=1000, dump_interval=500, analysis_interval=300) # Setup a valid minimal analysis object. class AnalysisProxy1(KMCAnalysisPlugin): def __init__(self): pass # Setup a slightly larger analyis object. class AnalysisProxy2(KMCAnalysisPlugin): def __init__(self): self.setup_called = False self.finalize_called = False self.register_step_counts = 0 def setup(self, step, time, configuration): self.setup_called = True def registerStep(self, step, time, configuration): self.register_step_counts += 1 def finalize(self): self.finalize_called = True ap2 = AnalysisProxy2() analysis = [ AnalysisProxy1(), ap2 ] # Run the model for 1000 steps with the analysis objects. # With dump interval 500 the analysis objects should be # called on startup, the at step 300, 600 and step 900 and # a finalization after that. ab_flip_model.run(control_parameters, trajectory_filename=trajectory_filename, analysis=analysis) self.assertTrue(ap2.setup_called) self.assertTrue(ap2.finalize_called) self.assertEqual(ap2.register_step_counts, 3)
def testCalculation(self): """ Test a calculation with the on-the-fly MSD analysis. """ # Setup a system, a periodic 10 atoms long 1D chain. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[1.0,0.0,0.0], [0.0,1.0,0.0], [0.0,0.0,1.0]]), basis_points=[[0.0,0.0,0.0]]) # And a lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(10,10,10), periodic=(True,True,True)) # Setup an initial configuration with one B in a sea of A:s. types = ["A"]*10*10*10 types[5] = "B" config = KMCConfiguration(lattice=lattice, types=types, possible_types=["A","B"]) # Setup a diffusion process to the left. coordinates_p0 = [[0.0, 0.0, 0.0],[-1.0, 0.0, 0.0]] p0 = KMCProcess(coordinates=coordinates_p0, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p1 = [[0.0, 0.0, 0.0],[1.0, 0.0, 0.0]] p1 = KMCProcess(coordinates=coordinates_p1, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p2 = [[0.0, 0.0, 0.0],[0.0,-1.0, 0.0]] p2 = KMCProcess(coordinates=coordinates_p2, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p3 = [[0.0, 0.0, 0.0],[0.0, 1.0, 0.0]] p3 = KMCProcess(coordinates=coordinates_p3, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p4 = [[0.0, 0.0, 0.0],[0.0, 0.0,-1.0]] p4 = KMCProcess(coordinates=coordinates_p4, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) coordinates_p5 = [[0.0, 0.0, 0.0],[0.0, 0.0, 1.0]] p5 = KMCProcess(coordinates=coordinates_p5, elements_before=["B","A"], elements_after=["A","B"], move_vectors=None, basis_sites=[0], rate_constant=1.0) interactions = KMCInteractions(processes=[p0, p1, p2, p3, p4, p5], implicit_wildcards=True) model = KMCLatticeModel(configuration=config, interactions=interactions) # Setup the analysis. msd = OnTheFlyMSD(history_steps=400, n_bins=10, t_max=25.0, track_type="B") # Setup the control parameters. control_parameters = KMCControlParameters(number_of_steps=4000, dump_interval=100, analysis_interval=1, seed=2013) # Run the model. model.run(control_parameters=control_parameters, analysis=[msd]) # Get the results out. results = msd.results() time_steps = msd.timeSteps() std_dev = msd.stdDev() bin_counters = msd.binCounters() # Compare against references. ref_results = numpy.array([[ 2.77712331 , 8.22333156 , 14.21578638 , 21.11949845 , 27.57598537, 33.81520414, 40.5640313 , 47.35067074, 54.83134718, 63.0006103 ], [ 2.80810946 , 8.48503234 , 13.7997313 , 17.62812205 , 22.37202018, 29.12157221, 35.40750463, 41.44944591, 48.94392653, 56.67111894], [ 2.98786918 , 8.65022668 , 14.01808716 , 18.62678885 , 22.65708384, 26.03107861, 30.03937616, 35.1483 , 40.68319007, 47.21074474], [ 5.58523277 , 16.70836389 , 28.01551768 , 38.74762049 , 49.94800555, 62.93677636, 75.97153593, 88.80011665, 103.77527371, 119.67172924], [ 5.76499249 , 16.87355824 , 28.23387354 , 39.7462873 , 50.23306921, 59.84628275, 70.60340745, 82.49897073, 95.51453725, 110.21135504], [ 5.79597864 , 17.13525902 , 27.81781846 , 36.2549109 , 45.02910402, 55.15265082, 65.44688079, 76.59774591, 89.62711659, 103.88186368], [ 8.57310195 , 25.35859057 , 42.03360484 , 57.37440934 , 72.60508939, 88.96785497, 106.01091209, 123.94841665, 144.45846377, 166.88247398]]) diff = numpy.linalg.norm(ref_results - results) self.assertAlmostEqual(diff, 0.0, 6) ref_time_steps = numpy.array([ 1.25, 3.75, 6.25, 8.75, 11.25, 13.75, 16.25, 18.75, 21.25, 23.75]) diff = numpy.linalg.norm(ref_time_steps - time_steps) self.assertAlmostEqual(diff, 0.0, 8) ref_std_dev = numpy.array( [[ 0.14837207, 0.7305895 , 1.61912818, 2.84016862, 4.19935234, 5.69504607, 7.43238623, 9.31932103, 11.49445671, 13.97165319], [ 0.15002755, 0.75383991, 1.57174096, 2.37064526, 3.40687718, 4.90455993, 6.48757634, 8.15787162, 10.26025939, 12.5679611 ], [ 0.15963149, 0.76851636, 1.59661093, 2.50494685, 3.45028752, 4.38406911, 5.5039955 , 6.91771175, 8.52853689, 10.46993274], [ 0.21100039, 1.04965011, 2.25628521, 3.68460183, 5.37841647, 7.49505328, 9.84289993, 12.35824143, 15.38290727, 18.76634124], [ 0.2177914 , 1.06002792, 2.27387093, 3.77956739, 5.40911222, 7.12701069, 9.14740325, 11.48131598, 14.15839455, 17.28281115], [ 0.218962 , 1.07646844, 2.24036311, 3.44756425, 4.84874766, 6.56805258, 8.47932177, 10.66004723, 13.28568526, 16.29025096], [ 0.26444438, 1.30073885, 2.76405291, 4.45469653, 6.38348309, 8.65082886, 11.21442742, 14.08440462, 17.48404426, 21.36747194]]) diff = numpy.linalg.norm(ref_std_dev - std_dev) self.assertAlmostEqual(diff, 0.0, 6) ref_bin_counters = (59930, 59996, 59545, 59256, 59064, 59076, 58284, 58294, 57817, 57349) self.assertEqual(bin_counters, ref_bin_counters)
def testATKScript1(self): """ Test that we can generate an ATK script from the configuration. """ # Setup a valid KMCUnitCell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0, 0.0, 0.0], [0.0, 0.5, 0.5], [0.5,0.75,0.75]]) # Setup the lattice and types. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(1,1,1), periodic=(False,False,False)) types = ['B','A','C'] possible_types = ['C', "A", "B", "D"] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=possible_types) # Determine a mapping between our types and valid ATK types. # Types not present in the mapping are ignored in the ATK script. types_mapping = { 'A' : 'Copper', 'C' : 'Iron', 'D' : 'Vanadium', } # Get the ATK script. atk_script = config._atkScript(types_mapping) # Check that it looks as we expect. ref_script = """# ---------------------------------------------------------- # ATK 12.8.2 BulkConfiguration script generated from KMCLib # configuration version 1.0. # ---------------------------------------------------------- # Specify the lattice parameters. vector_a = [ 2.80000000, 0.00000000, 0.00000000]*Angstrom vector_b = [ 0.00000000, 3.20000000, 0.00000000]*Angstrom vector_c = [ 0.00000000, 0.50000000, 3.00000000]*Angstrom lattice = UnitCell(vector_a, vector_b, vector_c) # Define the elements. elements = [Copper, Iron] # Define the coordinates. coordinates = [[ 0.00000000e+00, 5.00000000e-01, 5.00000000e-01], [ 5.00000000e-01, 7.50000000e-01, 7.50000000e-01]] # Setup the configuration. bulk_configuration = BulkConfiguration( bravais_lattice=lattice, elements=elements, fractional_coordinates=coordinates ) # ---------------------------------------------------------- """ self.assertEqual(atk_script, ref_script)
def testStoreData(self): """ Test the data storage function. """ # Get a file name. name = os.path.abspath(os.path.dirname(__file__)) name = os.path.join(name, "..", "..") name = os.path.join(name, "TestUtilities", "Scratch") trajectory_filename = os.path.join(name, "tmp_trajectory.xyz") if MPICommons.isMaster(): self.__files_to_remove.append(trajectory_filename) # Setup the trajectory object. unit_cell = KMCUnitCell(cell_vectors=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], basis_points=[[0.0, 0.0, 0.0]]) lattice = KMCLattice(unit_cell=unit_cell, periodic=(True, True, True), repetitions=(4,4,4)) config = KMCConfiguration(lattice=lattice, types=["A","B","C","D"]*16) t = XYZTrajectory(trajectory_filename=trajectory_filename, configuration=config, max_buffer_size=12345, max_buffer_time=123.0) # Construct data to store. simulation_time = 1.234 step = 123 configuration = config # Store. t._storeData(simulation_time, step, configuration) # Check that the member data was updated. self.assertEqual(len(t._XYZTrajectory__atom_id_types), 1) self.assertEqual(len(t._XYZTrajectory__atom_id_coordinates), 1) self.assertEqual(len(t._XYZTrajectory__time), 1) self.assertEqual(len(t._XYZTrajectory__step), 1) # store again. simulation_time = 1.999 step = 4444 t._storeData(simulation_time, step, configuration) # Check that the member data was updated. self.assertEqual(len(t._XYZTrajectory__atom_id_types), 2) self.assertEqual(len(t._XYZTrajectory__atom_id_coordinates), 2) self.assertEqual(len(t._XYZTrajectory__time), 2) self.assertEqual(len(t._XYZTrajectory__step), 2) # Check the values of the stored data. self.assertAlmostEqual(t._XYZTrajectory__time[0], 1.234, 10) self.assertAlmostEqual(t._XYZTrajectory__time[1], 1.999, 10) self.assertEqual(t._XYZTrajectory__step[0], 123) self.assertEqual(t._XYZTrajectory__step[1], 4444) diff = numpy.linalg.norm(config.atomIDCoordinates() - t._XYZTrajectory__atom_id_coordinates[0]) self.assertAlmostEqual(diff, 0.0, 10) diff = numpy.linalg.norm(config.atomIDCoordinates() - t._XYZTrajectory__atom_id_coordinates[1]) self.assertAlmostEqual(diff, 0.0, 10) self.assertEqual(t._XYZTrajectory__atom_id_types[0], config.atomIDTypes()) self.assertEqual(t._XYZTrajectory__atom_id_types[1], config.atomIDTypes())
def testATKScript2(self): """ Test that we can generate an ATK script from the configuration. """ # Setup a valid KMCUnitCell. cell_vectors = [[5.640000e+00, 0.330000e+00, 0.120000e+00], [0.110000e+00, 5.460000e+00, 0.100000e+00], [0.500000e+00, 0.430000e+00, 5.410000e+00]] basis_points = [[0.200000e+00, 0.300000e+00, 0.400000e+00], [5.200000e-01, 5.400000e-01, 5.010000e-01]] unit_cell = KMCUnitCell(cell_vectors=cell_vectors, basis_points=basis_points) # Setup the lattice and types. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4, 4, 4), periodic=(True, True, True)) types = [ 'Ce3', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'Vacancy', 'Ce', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Ce3', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Ce', 'O', 'Empty', 'O', 'Ce', 'O', 'Empty', 'O' ] possible_types = ['Ce3', 'Empty', 'O', 'Ce', 'Vacancy'] # Setup the configuration. configuration = KMCConfiguration(lattice=lattice, types=types, possible_types=possible_types) # Determine a mapping between our types and valid ATK types. # Types not present in the mapping are ignored in the ATK script. type_map = { "Ce3": "Vanadium", "Ce": "Cerium", "O": "Oxygen", } # Get the ATK script. atk_script = configuration._atkScript(type_map) # Check that it looks as we expect. ref_script = """# ---------------------------------------------------------- # ATK 12.8.2 BulkConfiguration script generated from KMCLib # configuration version 1.0. # ---------------------------------------------------------- # Specify the lattice parameters. vector_a = [ 22.56000000, 1.32000000, 0.48000000]*Angstrom vector_b = [ 0.44000000, 21.84000000, 0.40000000]*Angstrom vector_c = [ 2.00000000, 1.72000000, 21.64000000]*Angstrom lattice = UnitCell(vector_a, vector_b, vector_c) # Define the elements. elements = [Vanadium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Vanadium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Cerium, Oxygen, Oxygen, Cerium, Oxygen, Oxygen] # Define the coordinates. coordinates = [[ 5.00000000e-02, 7.50000000e-02, 1.00000000e-01], [ 1.30000000e-01, 1.35000000e-01, 1.25250000e-01], [ 1.30000000e-01, 1.35000000e-01, 3.75250000e-01], [ 5.00000000e-02, 7.50000000e-02, 6.00000000e-01], [ 1.30000000e-01, 1.35000000e-01, 6.25250000e-01], [ 1.30000000e-01, 1.35000000e-01, 8.75250000e-01], [ 1.30000000e-01, 3.85000000e-01, 1.25250000e-01], [ 5.00000000e-02, 3.25000000e-01, 3.50000000e-01], [ 1.30000000e-01, 3.85000000e-01, 3.75250000e-01], [ 5.00000000e-02, 3.25000000e-01, 8.50000000e-01], [ 1.30000000e-01, 3.85000000e-01, 8.75250000e-01], [ 5.00000000e-02, 5.75000000e-01, 1.00000000e-01], [ 1.30000000e-01, 6.35000000e-01, 1.25250000e-01], [ 1.30000000e-01, 6.35000000e-01, 3.75250000e-01], [ 5.00000000e-02, 5.75000000e-01, 6.00000000e-01], [ 1.30000000e-01, 6.35000000e-01, 6.25250000e-01], [ 1.30000000e-01, 6.35000000e-01, 8.75250000e-01], [ 1.30000000e-01, 8.85000000e-01, 1.25250000e-01], [ 5.00000000e-02, 8.25000000e-01, 3.50000000e-01], [ 1.30000000e-01, 8.85000000e-01, 3.75250000e-01], [ 1.30000000e-01, 8.85000000e-01, 6.25250000e-01], [ 5.00000000e-02, 8.25000000e-01, 8.50000000e-01], [ 1.30000000e-01, 8.85000000e-01, 8.75250000e-01], [ 3.80000000e-01, 1.35000000e-01, 1.25250000e-01], [ 3.00000000e-01, 7.50000000e-02, 3.50000000e-01], [ 3.80000000e-01, 1.35000000e-01, 3.75250000e-01], [ 3.80000000e-01, 1.35000000e-01, 6.25250000e-01], [ 3.00000000e-01, 7.50000000e-02, 8.50000000e-01], [ 3.80000000e-01, 1.35000000e-01, 8.75250000e-01], [ 3.00000000e-01, 3.25000000e-01, 1.00000000e-01], [ 3.80000000e-01, 3.85000000e-01, 1.25250000e-01], [ 3.80000000e-01, 3.85000000e-01, 3.75250000e-01], [ 3.00000000e-01, 3.25000000e-01, 6.00000000e-01], [ 3.80000000e-01, 3.85000000e-01, 6.25250000e-01], [ 3.80000000e-01, 3.85000000e-01, 8.75250000e-01], [ 3.80000000e-01, 6.35000000e-01, 1.25250000e-01], [ 3.00000000e-01, 5.75000000e-01, 3.50000000e-01], [ 3.80000000e-01, 6.35000000e-01, 3.75250000e-01], [ 3.80000000e-01, 6.35000000e-01, 6.25250000e-01], [ 3.00000000e-01, 5.75000000e-01, 8.50000000e-01], [ 3.80000000e-01, 6.35000000e-01, 8.75250000e-01], [ 3.00000000e-01, 8.25000000e-01, 1.00000000e-01], [ 3.80000000e-01, 8.85000000e-01, 1.25250000e-01], [ 3.80000000e-01, 8.85000000e-01, 3.75250000e-01], [ 3.00000000e-01, 8.25000000e-01, 6.00000000e-01], [ 3.80000000e-01, 8.85000000e-01, 6.25250000e-01], [ 3.80000000e-01, 8.85000000e-01, 8.75250000e-01], [ 5.50000000e-01, 7.50000000e-02, 1.00000000e-01], [ 6.30000000e-01, 1.35000000e-01, 1.25250000e-01], [ 6.30000000e-01, 1.35000000e-01, 3.75250000e-01], [ 5.50000000e-01, 7.50000000e-02, 6.00000000e-01], [ 6.30000000e-01, 1.35000000e-01, 6.25250000e-01], [ 6.30000000e-01, 1.35000000e-01, 8.75250000e-01], [ 6.30000000e-01, 3.85000000e-01, 1.25250000e-01], [ 5.50000000e-01, 3.25000000e-01, 3.50000000e-01], [ 6.30000000e-01, 3.85000000e-01, 3.75250000e-01], [ 6.30000000e-01, 3.85000000e-01, 6.25250000e-01], [ 5.50000000e-01, 3.25000000e-01, 8.50000000e-01], [ 6.30000000e-01, 3.85000000e-01, 8.75250000e-01], [ 5.50000000e-01, 5.75000000e-01, 1.00000000e-01], [ 6.30000000e-01, 6.35000000e-01, 1.25250000e-01], [ 6.30000000e-01, 6.35000000e-01, 3.75250000e-01], [ 5.50000000e-01, 5.75000000e-01, 6.00000000e-01], [ 6.30000000e-01, 6.35000000e-01, 6.25250000e-01], [ 6.30000000e-01, 6.35000000e-01, 8.75250000e-01], [ 6.30000000e-01, 8.85000000e-01, 1.25250000e-01], [ 5.50000000e-01, 8.25000000e-01, 3.50000000e-01], [ 6.30000000e-01, 8.85000000e-01, 3.75250000e-01], [ 6.30000000e-01, 8.85000000e-01, 6.25250000e-01], [ 5.50000000e-01, 8.25000000e-01, 8.50000000e-01], [ 6.30000000e-01, 8.85000000e-01, 8.75250000e-01], [ 8.80000000e-01, 1.35000000e-01, 1.25250000e-01], [ 8.00000000e-01, 7.50000000e-02, 3.50000000e-01], [ 8.80000000e-01, 1.35000000e-01, 3.75250000e-01], [ 8.80000000e-01, 1.35000000e-01, 6.25250000e-01], [ 8.00000000e-01, 7.50000000e-02, 8.50000000e-01], [ 8.80000000e-01, 1.35000000e-01, 8.75250000e-01], [ 8.00000000e-01, 3.25000000e-01, 1.00000000e-01], [ 8.80000000e-01, 3.85000000e-01, 1.25250000e-01], [ 8.80000000e-01, 3.85000000e-01, 3.75250000e-01], [ 8.00000000e-01, 3.25000000e-01, 6.00000000e-01], [ 8.80000000e-01, 3.85000000e-01, 6.25250000e-01], [ 8.80000000e-01, 3.85000000e-01, 8.75250000e-01], [ 8.80000000e-01, 6.35000000e-01, 1.25250000e-01], [ 8.00000000e-01, 5.75000000e-01, 3.50000000e-01], [ 8.80000000e-01, 6.35000000e-01, 3.75250000e-01], [ 8.80000000e-01, 6.35000000e-01, 6.25250000e-01], [ 8.00000000e-01, 5.75000000e-01, 8.50000000e-01], [ 8.80000000e-01, 6.35000000e-01, 8.75250000e-01], [ 8.00000000e-01, 8.25000000e-01, 1.00000000e-01], [ 8.80000000e-01, 8.85000000e-01, 1.25250000e-01], [ 8.80000000e-01, 8.85000000e-01, 3.75250000e-01], [ 8.00000000e-01, 8.25000000e-01, 6.00000000e-01], [ 8.80000000e-01, 8.85000000e-01, 6.25250000e-01], [ 8.80000000e-01, 8.85000000e-01, 8.75250000e-01]] # Setup the configuration. bulk_configuration = BulkConfiguration( bravais_lattice=lattice, elements=elements, fractional_coordinates=coordinates ) # ---------------------------------------------------------- """ self.assertEqual(atk_script, ref_script)
def testScript(self): """ Test that a script can be created. """ # Setup a unitcell. unit_cell = KMCUnitCell(cell_vectors=numpy.array([[2.8,0.0,0.0], [0.0,3.2,0.0], [0.0,0.5,3.0]]), basis_points=[[0.0,0.0,0.0], [0.5,0.5,0.5], [0.25,0.25,0.75]]) # Setup the lattice. lattice = KMCLattice(unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True,True,False)) types = ['A','A','A','A','B','B', 'A','A','A','B','B','B', 'B','B','A','A','B','A', 'B','B','B','A','B','A', 'B','A','A','A','B','B', 'B','B','B','B','B','B', 'A','A','A','A','B','B', 'B','B','A','B','B','A'] # Setup the configuration. config = KMCConfiguration(lattice=lattice, types=types, possible_types=['A','C','B']) # A first process. coords = [[1.0,2.0,3.4],[1.1,1.2,1.3]] types0 = ["A","B"] types1 = ["B","A"] rate_0_1 = 3.5 process_0 = KMCProcess(coords, types0, types1, basis_sites=[0], rate_constant=rate_0_1) # A second process. types0 = ["A","C"] types1 = ["C","A"] rate_0_1 = 1.5 process_1 = KMCProcess(coords, types0, types1, basis_sites=[0], rate_constant=rate_0_1) # Construct the interactions object. processes = [process_0, process_1] interactions = KMCInteractions(processes) # Construct the model. model = KMCLatticeModel(config, interactions) # Get the script. script = model._script() ref_script = """ # ----------------------------------------------------------------------------- # Unit cell cell_vectors = [[ 2.800000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 3.200000e+00, 0.000000e+00], [ 0.000000e+00, 5.000000e-01, 3.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 5.000000e-01, 5.000000e-01, 5.000000e-01], [ 2.500000e-01, 2.500000e-01, 7.500000e-01]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # ----------------------------------------------------------------------------- # Lattice lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True, True, False)) # ----------------------------------------------------------------------------- # Configuration types = ['A','A','A','A','B','B','A','A','A','B','B','B','B', 'B','A','A','B','A','B','B','B','A','B','A','B','A', 'A','A','B','B','B','B','B','B','B','B','A','A','A', 'A','B','B','B','B','A','B','B','A'] possible_types = ['A','C','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # ----------------------------------------------------------------------------- # Interactions coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 1.000000e-01, -8.000000e-01, -2.100000e+00]] elements_before = ['A','B'] elements_after = ['B','A'] move_vectors = [( 0,[ 1.000000e-01, -8.000000e-01, -2.100000e+00]), ( 1,[ -1.000000e-01, 8.000000e-01, 2.100000e+00])] basis_sites = [0] rate_constant = 3.500000e+00 process_0 = KMCProcess( coordinates=coordinates, elements_before=elements_before, elements_after=elements_after, move_vectors=move_vectors, basis_sites=basis_sites, rate_constant=rate_constant) coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 1.000000e-01, -8.000000e-01, -2.100000e+00]] elements_before = ['A','C'] elements_after = ['C','A'] move_vectors = [( 0,[ 1.000000e-01, -8.000000e-01, -2.100000e+00]), ( 1,[ -1.000000e-01, 8.000000e-01, 2.100000e+00])] basis_sites = [0] rate_constant = 1.500000e+00 process_1 = KMCProcess( coordinates=coordinates, elements_before=elements_before, elements_after=elements_after, move_vectors=move_vectors, basis_sites=basis_sites, rate_constant=rate_constant) processes = [process_0, process_1] interactions = KMCInteractions( processes=processes, implicit_wildcards=True) # ----------------------------------------------------------------------------- # Lattice model model = KMCLatticeModel( configuration=configuration, interactions=interactions) """ self.assertEqual(script, ref_script) # Get the script again, with a different variable name. script = model._script(variable_name="my_model") ref_script = """ # ----------------------------------------------------------------------------- # Unit cell cell_vectors = [[ 2.800000e+00, 0.000000e+00, 0.000000e+00], [ 0.000000e+00, 3.200000e+00, 0.000000e+00], [ 0.000000e+00, 5.000000e-01, 3.000000e+00]] basis_points = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 5.000000e-01, 5.000000e-01, 5.000000e-01], [ 2.500000e-01, 2.500000e-01, 7.500000e-01]] unit_cell = KMCUnitCell( cell_vectors=cell_vectors, basis_points=basis_points) # ----------------------------------------------------------------------------- # Lattice lattice = KMCLattice( unit_cell=unit_cell, repetitions=(4,4,1), periodic=(True, True, False)) # ----------------------------------------------------------------------------- # Configuration types = ['A','A','A','A','B','B','A','A','A','B','B','B','B', 'B','A','A','B','A','B','B','B','A','B','A','B','A', 'A','A','B','B','B','B','B','B','B','B','A','A','A', 'A','B','B','B','B','A','B','B','A'] possible_types = ['A','C','B'] configuration = KMCConfiguration( lattice=lattice, types=types, possible_types=possible_types) # ----------------------------------------------------------------------------- # Interactions coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 1.000000e-01, -8.000000e-01, -2.100000e+00]] elements_before = ['A','B'] elements_after = ['B','A'] move_vectors = [( 0,[ 1.000000e-01, -8.000000e-01, -2.100000e+00]), ( 1,[ -1.000000e-01, 8.000000e-01, 2.100000e+00])] basis_sites = [0] rate_constant = 3.500000e+00 process_0 = KMCProcess( coordinates=coordinates, elements_before=elements_before, elements_after=elements_after, move_vectors=move_vectors, basis_sites=basis_sites, rate_constant=rate_constant) coordinates = [[ 0.000000e+00, 0.000000e+00, 0.000000e+00], [ 1.000000e-01, -8.000000e-01, -2.100000e+00]] elements_before = ['A','C'] elements_after = ['C','A'] move_vectors = [( 0,[ 1.000000e-01, -8.000000e-01, -2.100000e+00]), ( 1,[ -1.000000e-01, 8.000000e-01, 2.100000e+00])] basis_sites = [0] rate_constant = 1.500000e+00 process_1 = KMCProcess( coordinates=coordinates, elements_before=elements_before, elements_after=elements_after, move_vectors=move_vectors, basis_sites=basis_sites, rate_constant=rate_constant) processes = [process_0, process_1] interactions = KMCInteractions( processes=processes, implicit_wildcards=True) # ----------------------------------------------------------------------------- # Lattice model my_model = KMCLatticeModel( configuration=configuration, interactions=interactions) """ # Check. self.assertEqual(script, ref_script)