def test_f_is_completed(self): traj = Trajectory() traj.f_add_parameter('test', 42) traj.f_explore({'test':[1,2,3,4]}) self.assertFalse(traj.f_is_completed()) for run_name in traj.f_get_run_names(): self.assertFalse(traj.f_is_completed(run_name)) traj._run_information[traj.f_idx_to_run(1)]['completed']=1 self.assertFalse(traj.f_is_completed()) self.assertTrue(traj.f_is_completed(1)) for run_name in traj.f_get_run_names(): traj._run_information[run_name]['completed']=1 self.assertTrue(traj.f_is_completed()) for run_name in traj.f_get_run_names(): self.assertTrue(traj.f_is_completed(run_name))
def main(): env = Environment(trajectory='Example_05_Euler_Integration', filename='experiments/example_05/HDF5/example_05.hdf5', file_title='Example_05_Euler_Integration', log_folder='experiments/example_05/LOGS/', comment = 'Go for Euler!') traj = env.v_trajectory trajectory_name = traj.v_name # 1st a) phase parameter addition add_parameters(traj) # 1st b) phase preparation # We will add the differential equation (well, its source code only) as a derived parameter traj.f_add_derived_parameter(FunctionParameter,'diff_eq', diff_lorenz, comment='Source code of our equation!') # We want to explore some initial conditions traj.f_explore({'initial_conditions' : [ np.array([0.01,0.01,0.01]), np.array([2.02,0.02,0.02]), np.array([42.0,4.2,0.42]) ]}) # 3 different conditions are enough for an illustrative example # 2nd phase let's run the experiment # We pass `euler_scheme` as our top-level simulation function and # the Lorenz equation 'diff_lorenz' as an additional argument env.f_run(euler_scheme, diff_lorenz) # We don't have a 3rd phase of post-processing here # 4th phase analysis. # I would recommend to do post-processing completely independent from the simulation, # but for simplicity let's do it here. # Let's assume that we start all over again and load the entire trajectory new. # Yet, there is an error within this approach, do you spot it? del traj traj = Trajectory(filename='experiments/example_05/HDF5/example_05.hdf5') # We will only fully load parameters and derived parameters. # Results will be loaded manually later on. try: # However, this will fail because our trajectory does not know how to # build the FunctionParameter. You have seen this coming, right? traj.f_load(name=trajectory_name,load_parameters=2, load_derived_parameters=2,load_results=1) except ImportError as e: print 'That did\'nt work, I am sorry. %s ' % e.message # Ok, let's try again but this time with adding our parameter to the imports traj = Trajectory(filename='experiments/example_05/HDF5/example_05.hdf5', dynamically_imported_classes=FunctionParameter) # Now it works: traj.f_load(name=trajectory_name,load_parameters=2, load_derived_parameters=2,load_results=1) #For the fun of it, let's print the source code print '\n ---------- The source code of your function ---------- \n %s' % traj.diff_eq # Let's get the exploration array: initial_conditions_exploration_array = traj.f_get('initial_conditions').f_get_range() # Now let's plot our simulated equations for the different initial conditions: # We will iterate through the run names for idx, run_name in enumerate(traj.f_get_run_names()): #Get the result of run idx from the trajectory euler_result = traj.results.f_get(run_name).euler_evolution # Now we manually need to load the result. Actually the results are not so large and we # could load them all at once. But for demonstration we do as if they were huge: traj.f_load_item(euler_result) euler_data = euler_result.data #Plot fancy 3d plot fig = plt.figure(idx) ax = fig.gca(projection='3d') x = euler_data[:,0] y = euler_data[:,1] z = euler_data[:,2] ax.plot(x, y, z, label='Initial Conditions: %s' % str(initial_conditions_exploration_array[idx])) plt.legend() plt.show() # Now we free the data again (because we assume its huuuuuuge): del euler_data euler_result.f_empty()