def testAppendAndFlushBufferSize(self): """ Test that the append function flushes when the buffer size is large. """ # Setup data. simulation_time = 12.3 step = 14 class Config: def __init__(self): pass configuration = Config() # Instantiate a trajectory. t = Trajectory(trajectory_filename="filename") # Add the needed functions. def storeData(*args, **kwargs): pass t._storeData = storeData ret_buffer = 10.0 def bufferSize(*args, **kwargs): return ret_buffer t._bufferSize = bufferSize class Dummy: self.fc = False d = Dummy() def flush(): d.fc = True t.flush = flush # Append. t.append(simulation_time, step, configuration) # The first time allways flushes. self.assertTrue(d.fc) # Append again. d.fc = False t.append(simulation_time, step, configuration) self.assertFalse(d.fc) # Change the value of the buffer size so that flush() gets called. ret_buffer = t._Trajectory__max_buffer_size + 1 # Append. t.append(simulation_time, step, configuration) # Check. self.assertTrue(d.fc)
def testAppendInterface(self): """ Test that the append function can not be called directly from the baseclass. """ # Setup data. simulation_time = 12.3 step = 14 class Config: def __init__(self): pass configuration = Config() # Instantiate a trajectory. t = Trajectory(trajectory_filename="filename") # Call append. self.assertRaises( AttributeError, lambda: t.append(simulation_time, step, configuration)) # Add the missing function. def storeData(*args, **kwargs): pass t._storeData = storeData self.assertRaises( AttributeError, lambda: t.append(simulation_time, step, configuration)) # Add the missing function. def bufferSize(*args, **kwargs): pass t._bufferSize = bufferSize self.assertRaises( AttributeError, lambda: t.append(simulation_time, step, configuration)) # Add the missing function. def flush(*args, **kwargs): pass t.flush = flush # Now it works. t.append(simulation_time, step, configuration)
def testAppendInterface(self): """ Test that the append function can not be called directly from the baseclass. """ # Setup data. simulation_time = 12.3 step = 14 class Config: def __init__(self): pass configuration = Config() # Instantiate a trajectory. t = Trajectory(trajectory_filename="filename") # Call append. self.assertRaises(AttributeError, lambda: t.append(simulation_time, step, configuration)) # Add the missing function. def storeData(*args, **kwargs): pass t._storeData = storeData self.assertRaises(AttributeError, lambda: t.append(simulation_time, step, configuration)) # Add the missing function. def bufferSize(*args, **kwargs): pass t._bufferSize = bufferSize self.assertRaises(AttributeError, lambda: t.append(simulation_time, step, configuration)) # Add the missing function. def flush(*args, **kwargs): pass t.flush = flush # Now it works. t.append(simulation_time, step, configuration)
def testAppendTimeUpdate(self): """ Test that the append function updates the time only when it flushes. """ # Setup data. simulation_time = 12.3 step = 14 class Config: def __init__(self): pass configuration = Config() # Instantiate a trajectory. t = Trajectory(trajectory_filename="filename") # Add the needed functions. def storeData(*args, **kwargs): pass t._storeData = storeData ret_buffer = 10.0 def bufferSize(*args, **kwargs): return ret_buffer t._bufferSize = bufferSize class Dummy: self.fc = False d = Dummy() def flush(): d.fc = True t.flush = flush # Append. t.append(simulation_time, step, configuration) # The first time allways flushes. self.assertTrue(d.fc) # This updates the time last dump variable. ref_time_last_dump = t._Trajectory__time_last_dump # Sleep 10 ms. time.sleep(0.01) # Append again. d.fc = False t.append(simulation_time, step, configuration) self.assertFalse(d.fc) # This does not update the time last dump. self.assertAlmostEqual(ref_time_last_dump, t._Trajectory__time_last_dump, 10) # Change the value of the max buffer time so that flush() gets called. t._Trajectory__max_buffer_time = 0.0 # Sleep 10 ms. time.sleep(0.01) # Append. t.append(simulation_time, step, configuration) # Check. self.assertTrue(d.fc) # The time last dump should have been updated. self.assertTrue( (t._Trajectory__time_last_dump - ref_time_last_dump) > 0.0001 )
def run(self, control_parameters=None, trajectory_filename=None): """ Run the KMC lattice model simulation with specified parameters. :param control_paramters: An instance of KMCControlParameters specifying number of steps to run etc. :param trajectory_filename: The filename of the trajectory. If not given no trajectory will be saved. """ # Check the input. if not isinstance(control_parameters, KMCControlParameters): msg =""" The 'control_parameters' input to the KMCLatticeModel run funtion must be an instance of type KMCControlParameters.""" raise Error(msg) # Check the trajectory filename. use_trajectory = True if trajectory_filename is None: use_trajectory = False msg =""" KMCLib: WARNING: No trajectory filename given -> no trajectory will be saved.""" prettyPrint(msg) elif not isinstance(trajectory_filename, str): msg = """ The 'trajectory_filename' input to the KMCLattice model run function must be given as string.""" raise Error(msg) # Construct the C++ lattice model. prettyPrint(" KMCLib: setting up the backend C++ object.") cpp_model = self._backend() # Print the initial matching information if above the verbosity threshold. if self.__verbosity_level > 9: self._printMatchInfo(cpp_model) # Check that we have at least one available process to run the KMC simulation. if cpp_model.interactions().totalAvailableSites() == 0: raise Error("No available processes. None of the processes you have defined as input match any position in the configuration. Change your initial configuration or processes to run KMC.") # Setup a trajectory object. if use_trajectory: trajectory = Trajectory(trajectory_filename=trajectory_filename, sites=self.__configuration.sites()) # Add the first step. trajectory.append(simulation_time = self.__cpp_timer.simulationTime(), step = 0, types = self.__configuration.types()) # Get the needed parameters. n_steps = control_parameters.numberOfSteps() n_dump = control_parameters.dumpInterval() prettyPrint(" KMCLib: Runing for %i steps, starting from time: %f\n"%(n_steps,self.__cpp_timer.simulationTime())) # Run the KMC simulation. try: # Loop over the steps. for s in range(n_steps): step = s+1 # Check if it is possible to take a step. nP = cpp_model.interactions().totalAvailableSites() if nP == 0: raise Error("No more available processes.") # Take a step. cpp_model.singleStep() if ((step)%n_dump == 0): prettyPrint(" KMCLib: %i steps executed. time: %f "%(step, self.__cpp_timer.simulationTime())) # Perform IO using the trajectory object. if use_trajectory: trajectory.append(simulation_time = self.__cpp_timer.simulationTime(), step = step, types = self.__configuration.types()) finally: # Flush the buffers when done. if use_trajectory: trajectory.flush()
def testFlush(self): """ Make sure we can flush the buffer as expected. """ # Get a filename. 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_file.py") self.__files_to_remove.append(trajectory_filename) # Construct the trajecctory object. sites = [[0.0,1.0,2.3], [1.0,0.0,2.3], [1.0,1.0,0.3], [1.0,1.0,2.3], [3.4,4.5,4.3], [3.4,4.3,4.3], [3.4,5.5,4.3], [3.7,7.5,6.5]] # Construct. t = Trajectory(trajectory_filename, sites) # Check that the file is created but only with meta information. global_dict = {} local_dict = {} execfile(trajectory_filename, global_dict, local_dict) empty_list = [] ret_types = local_dict['types'] self.assertEqual( ret_types, empty_list ) ret_times = local_dict['times'] self.assertEqual( ret_times, empty_list ) ret_steps = local_dict['steps'] self.assertEqual( ret_steps, empty_list ) # Fill the buffers. t._Trajectory__types_buffer = [["ABC", "123"],["123", "ABC"]] t._Trajectory__simulation_time_buffer = [1.234, 5.678] t._Trajectory__step_buffer = [1, 99] # Flush the buffers. t.flush() # Check that the buffers are empty. self.assertEqual( t._Trajectory__types_buffer, empty_list ) self.assertEqual( t._Trajectory__simulation_time_buffer, empty_list ) self.assertEqual( t._Trajectory__step_buffer, empty_list ) # Check that the file has the flushed values. global_dict = {} local_dict = {} execfile(trajectory_filename, global_dict, local_dict) ret_types = local_dict['types'] self.assertEqual( ret_types, [["ABC", "123"],["123", "ABC"]] ) ret_times = local_dict['times'] self.assertAlmostEqual( ret_times, [1.234, 5.678], 10 ) ret_steps = local_dict['steps'] self.assertEqual( ret_steps, [1, 99] )
def testAppendTimeUpdate(self): """ Test that the append function updates the time only when it flushes. """ # Setup data. simulation_time = 12.3 step = 14 class Config: def __init__(self): pass configuration = Config() # Instantiate a trajectory. t = Trajectory(trajectory_filename="filename") # Add the needed functions. def storeData(*args, **kwargs): pass t._storeData = storeData ret_buffer = 10.0 def bufferSize(*args, **kwargs): return ret_buffer t._bufferSize = bufferSize class Dummy: self.fc = False d = Dummy() def flush(): d.fc = True t.flush = flush # Append. t.append(simulation_time, step, configuration) # The first time allways flushes. self.assertTrue(d.fc) # This updates the time last dump variable. ref_time_last_dump = t._Trajectory__time_last_dump # Sleep 10 ms. time.sleep(0.01) # Append again. d.fc = False t.append(simulation_time, step, configuration) self.assertFalse(d.fc) # This does not update the time last dump. self.assertAlmostEqual(ref_time_last_dump, t._Trajectory__time_last_dump, 10) # Change the value of the max buffer time so that flush() gets called. t._Trajectory__max_buffer_time = 0.0 # Sleep 10 ms. time.sleep(0.01) # Append. t.append(simulation_time, step, configuration) # Check. self.assertTrue(d.fc) # The time last dump should have been updated. self.assertTrue( (t._Trajectory__time_last_dump - ref_time_last_dump) > 0.0001)