def HJSolver(dynamics_obj, grid, multiple_value, tau, compMethod, plot_option, saveAllTimeSteps=False, accuracy="low"): print("Welcome to optimized_dp \n") if type(multiple_value) == list: init_value = multiple_value[0] constraint = multiple_value[1] else: init_value = multiple_value constraint = None hcl.init() hcl.config.init_dtype = hcl.Float(32) ################# INITIALIZE DATA TO BE INPUT INTO EXECUTABLE ########################## print("Initializing\n") if constraint is None: print("No obstacles set !") else: print("Obstacles set exists !") constraint_dim = constraint.ndim # Time-varying obstacle sets if constraint_dim > grid.dims: constraint_i = constraint[..., 0] else: # Time-invariant obstacle set constraint_i = constraint # Tensors input to our computation graph V_0 = hcl.asarray(init_value) V_1 = hcl.asarray(np.zeros(tuple(grid.pts_each_dim))) l0 = hcl.asarray(init_value) # For debugging purposes probe = hcl.asarray(np.zeros(tuple(grid.pts_each_dim))) # Array for each state values list_x1 = np.reshape(grid.vs[0], grid.pts_each_dim[0]) list_x2 = np.reshape(grid.vs[1], grid.pts_each_dim[1]) list_x3 = np.reshape(grid.vs[2], grid.pts_each_dim[2]) if grid.dims >= 4: list_x4 = np.reshape(grid.vs[3], grid.pts_each_dim[3]) if grid.dims >= 5: list_x5 = np.reshape(grid.vs[4], grid.pts_each_dim[4]) if grid.dims >= 6: list_x6 = np.reshape(grid.vs[5], grid.pts_each_dim[5]) # Convert state arrays to hcl array type list_x1 = hcl.asarray(list_x1) list_x2 = hcl.asarray(list_x2) list_x3 = hcl.asarray(list_x3) if grid.dims >= 4: list_x4 = hcl.asarray(list_x4) if grid.dims >= 5: list_x5 = hcl.asarray(list_x5) if grid.dims >= 6: list_x6 = hcl.asarray(list_x6) # Get executable, obstacle check intial value function if grid.dims == 3: solve_pde = graph_3D(dynamics_obj, grid, compMethod["PrevSetsMode"], accuracy) if grid.dims == 4: solve_pde = graph_4D(dynamics_obj, grid, compMethod["PrevSetsMode"], accuracy) if grid.dims == 5: solve_pde = graph_5D(dynamics_obj, grid, compMethod["PrevSetsMode"], accuracy) if grid.dims == 6: solve_pde = graph_6D(dynamics_obj, grid, compMethod["PrevSetsMode"], accuracy) """ Be careful, for high-dimensional array (5D or higher), saving value arrays at all the time steps may cause your computer to run out of memory """ if saveAllTimeSteps is True: valfuncs = np.zeros( np.insert(tuple(grid.pts_each_dim), grid.dims, len(tau))) valfuncs[..., -1] = V_0.asnumpy() print(valfuncs.shape) ################ USE THE EXECUTABLE ############ # Variables used for timing execution_time = 0 iter = 0 tNow = tau[0] print("Started running\n") for i in range(1, len(tau)): #tNow = tau[i-1] t_minh = hcl.asarray(np.array((tNow, tau[i]))) # taking obstacle at each timestep if "TargetSetMode" in compMethod and constraint_dim > grid.dims: constraint_i = constraint[..., i] while tNow <= tau[i] - 1e-4: tmp_arr = V_0.asnumpy() # Start timing iter += 1 start = time.time() # Run the execution and pass input into graph if grid.dims == 3: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, t_minh, l0) if grid.dims == 4: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, t_minh, l0, probe) if grid.dims == 5: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, list_x5, t_minh, l0) if grid.dims == 6: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, list_x5, list_x6, t_minh, l0) tNow = np.asscalar((t_minh.asnumpy())[0]) # Calculate computation time execution_time += time.time() - start # If TargetSetMode is specified by user if "TargetSetMode" in compMethod: if compMethod["TargetSetMode"] == "max": tmp_val = np.maximum(V_0.asnumpy(), -constraint_i) elif compMethod["TargetSetMode"] == "min": tmp_val = np.minimum(V_0.asnumpy(), -constraint_i) # Update final result V_1 = hcl.asarray(tmp_val) # Update input for next iteration V_0 = hcl.asarray(tmp_val) # Some information printing print(t_minh) print("Computational time to integrate (s): {:.5f}".format( time.time() - start)) if saveAllTimeSteps is True: valfuncs[..., -1 - i] = V_1.asnumpy() # Time info printing print("Total kernel time (s): {:.5f}".format(execution_time)) print("Finished solving\n") ##################### PLOTTING ##################### if plot_option.do_plot: # Only plots last value array for now plot_isosurface(grid, V_1.asnumpy(), plot_option) if saveAllTimeSteps is True: return valfuncs return V_1.asnumpy()
def main(): ################### PARSING ARGUMENTS FROM USERS ##################### parser = ArgumentParser() parser.add_argument("-p", "--plot", default=True, type=bool) # Print out LLVM option only parser.add_argument("-l", "--llvm", default=False, type=bool) args = parser.parse_args() hcl.init() hcl.config.init_dtype = hcl.Float() ################# INITIALIZE DATA TO BE INPUT INTO EXECUTABLE ########################## print("Initializing\n") V_0 = hcl.asarray(my_shape) V_1 = hcl.asarray(np.zeros(tuple(g.pts_each_dim))) l0 = hcl.asarray(my_shape) #probe = hcl.asarray(np.zeros(tuple(g.pts_each_dim))) #obstacle = hcl.asarray(cstraint_values) list_x1 = np.reshape(g.vs[0], g.pts_each_dim[0]) list_x2 = np.reshape(g.vs[1], g.pts_each_dim[1]) list_x3 = np.reshape(g.vs[2], g.pts_each_dim[2]) if g.dims >= 4: list_x4 = np.reshape(g.vs[3], g.pts_each_dim[3]) if g.dims >= 5: list_x5 = np.reshape(g.vs[4], g.pts_each_dim[4]) if g.dims >= 6: list_x6 = np.reshape(g.vs[5], g.pts_each_dim[5]) # Convert to hcl array type list_x1 = hcl.asarray(list_x1) list_x2 = hcl.asarray(list_x2) list_x3 = hcl.asarray(list_x3) if g.dims >= 4: list_x4 = hcl.asarray(list_x4) if g.dims >= 5: list_x5 = hcl.asarray(list_x5) if g.dims >= 6: list_x6 = hcl.asarray(list_x6) # Get executable if g.dims == 4: solve_pde = graph_4D() if g.dims == 5: solve_pde = graph_5D() if g.dims == 6: solve_pde = graph_6D() # Print out code for different backend #print(solve_pde) ################ USE THE EXECUTABLE ############ # Variables used for timing execution_time = 0 lookback_time = 0 tNow = tau[0] for i in range(1, len(tau)): #tNow = tau[i-1] t_minh = hcl.asarray(np.array((tNow, tau[i]))) while tNow <= tau[i] - 1e-4: # Start timing start = time.time() print("Started running\n") # Run the execution and pass input into graph if g.dims == 4: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, t_minh, l0) if g.dims == 5: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, list_x5, t_minh, l0) if g.dims == 6: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, list_x5, list_x6, t_minh, l0) tNow = np.asscalar((t_minh.asnumpy())[0]) # Calculate computation time execution_time += time.time() - start # Some information printing print(t_minh) print("Computational time to integrate (s): {:.5f}".format( time.time() - start)) # Saving data into disk # Time info printing print("Total kernel time (s): {:.5f}".format(execution_time)) print("Finished solving\n") # V1 is the final value array, fill in anything to use it ##################### PLOTTING ##################### if args.plot: plot_isosurface(g, V_1.asnumpy(), [0, 1, 3])
def HJSolver(dynamics_obj, grid, init_value, tau, compMethod, plot_option): print("Welcome to optimized_dp \n") ################### PARSING ARGUMENTS FROM USERS ##################### parser = ArgumentParser() parser.add_argument("-p", "--plot", default=True, type=bool) # # Print out LLVM option only # parser.add_argument("-l", "--llvm", default=False, type=bool) args = parser.parse_args() hcl.init() hcl.config.init_dtype = hcl.Float(32) ################# INITIALIZE DATA TO BE INPUT INTO EXECUTABLE ########################## print("Initializing\n") V_0 = hcl.asarray(init_value) V_1 = hcl.asarray(np.zeros(tuple(grid.pts_each_dim))) l0 = hcl.asarray(init_value) probe = hcl.asarray(np.zeros(tuple(grid.pts_each_dim))) #obstacle = hcl.asarray(cstraint_values) list_x1 = np.reshape(grid.vs[0], grid.pts_each_dim[0]) list_x2 = np.reshape(grid.vs[1], grid.pts_each_dim[1]) list_x3 = np.reshape(grid.vs[2], grid.pts_each_dim[2]) if grid.dims >= 4: list_x4 = np.reshape(grid.vs[3], grid.pts_each_dim[3]) if grid.dims >= 5: list_x5 = np.reshape(grid.vs[4], grid.pts_each_dim[4]) if grid.dims >= 6: list_x6 = np.reshape(grid.vs[5], grid.pts_each_dim[5]) # Convert to hcl array type list_x1 = hcl.asarray(list_x1) list_x2 = hcl.asarray(list_x2) list_x3 = hcl.asarray(list_x3) if grid.dims >= 4: list_x4 = hcl.asarray(list_x4) if grid.dims >= 5: list_x5 = hcl.asarray(list_x5) if grid.dims >= 6: list_x6 = hcl.asarray(list_x6) # Get executable if grid.dims == 3: solve_pde = graph_3D(dynamics_obj, grid, compMethod) if grid.dims == 4: solve_pde = graph_4D(dynamics_obj, grid, compMethod) if grid.dims == 5: solve_pde = graph_5D(dynamics_obj, grid, compMethod) if grid.dims == 6: solve_pde = graph_6D(dynamics_obj, grid, compMethod) # Print out code for different backend #print(solve_pde) ################ USE THE EXECUTABLE ############ # Variables used for timing execution_time = 0 iter = 0 tNow = tau[0] print("Started running\n") for i in range (1, len(tau)): #tNow = tau[i-1] t_minh= hcl.asarray(np.array((tNow, tau[i]))) while tNow <= tau[i] - 1e-4: tmp_arr = V_0.asnumpy() # Start timing iter += 1 start = time.time() # Run the execution and pass input into graph if grid.dims == 3: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, t_minh, l0) if grid.dims == 4: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, t_minh, l0, probe) if grid.dims == 5: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, list_x5 ,t_minh, l0) if grid.dims == 6: solve_pde(V_1, V_0, list_x1, list_x2, list_x3, list_x4, list_x5, list_x6, t_minh, l0) tNow = np.asscalar((t_minh.asnumpy())[0]) # Calculate computation time execution_time += time.time() - start # Some information printing print(t_minh) print("Computational time to integrate (s): {:.5f}".format(time.time() - start)) # Time info printing print("Total kernel time (s): {:.5f}".format(execution_time)) print("Finished solving\n") # Save into file np.save("new_center_final.npy", V_1.asnumpy()) print(np.sum(V_1.asnumpy() < 0)) ##################### PLOTTING ##################### if args.plot: # plot Value table when speed is maximum plot_isosurface(grid, V_1.asnumpy(), plot_option) #plot_isosurface(g, my_V, [0, 1, 3], 10) return V_1.asnumpy()