def command_line_arguments(year, month, day, plot_day, plot_month): if day!='None': limit = monthrange(int(year), int(month))[1] if int(day) > limit: print("Invalid Date for given month and year. Exiting...\n") exit() val = get_day(year, month, day) if plot_day: try: plot_points = get_day(year, month, day, rtr=True); val=False pl = plotting.Plotting(year=year, month=month, day=day) pl.normal_plot(plot_points) return "plotted" except IndexError: pass elif day == 'None': if month and year: print("\n YEAR: {} | MONTH: {} | \n".format(year, month)) get_data.main(year, month) if plot_month: try: monthly_average = get_month(year, month) plot = plotting.Plotting(year=year, month=month) plot.normal_plot(monthly_average, day=False) except IndexError: raise("Index Error. Can't Plot Monthy Average Values.")
def __init__(self, s_start, s_goal, step_len, goal_sample_rate, waypoint_sample_rate, iter_max): self.s_start = Node(s_start) self.s_goal = Node(s_goal) self.step_len = step_len self.goal_sample_rate = goal_sample_rate self.waypoint_sample_rate = waypoint_sample_rate self.iter_max = iter_max self.vertex = [self.s_start] self.vertex_old = [] self.vertex_new = [] self.edges = [] self.env = env.Env() self.plotting = plotting.Plotting(s_start, s_goal) self.utils = utils.Utils() self.fig, self.ax = plt.subplots() self.x_range = self.env.x_range self.y_range = self.env.y_range self.obs_circle = self.env.obs_circle self.obs_rectangle = self.env.obs_rectangle self.obs_boundary = self.env.obs_boundary self.obs_add = [0, 0, 0] # [x,y,r] self.path = [] self.waypoint = []
def run_sklearn_svm(kernel='linear', C='auto', gamma='auto', degree='auto'): #------------------------------------------------------------------------------------------------------------------ # Initialise Classes: objData = datageneration.Data(); # Data object. objPlot = plotting.Plotting(); # Plotting object. # Generate Data: # Run Fit: if kernel == 'linear': if C>10: X1, y1, X2, y2 = objData.gen_lin_separable_overlap_data(seed=1) else: X1, y1, X2, y2 = objData.generate_linearly_separable_data(seed=1) skl = SVC(kernel=kernel,C=C) # Fit the training data. elif kernel == 'poly': X1, y1, X2, y2 = objData.gen_non_lin_separable_data(seed=1) ### NOTE: polynomial kernel has some input 'coef0'. This is interpretted as C by other kernels. ### sklearn documentation: ### K(X, Y) = (gamma < X, Y > + coef0) ^ degree ### source: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise.polynomial_kernel.html skl = SVC(kernel=kernel,coef0=C, gamma=gamma, degree=degree, tol=0.000001) # Fit the training data. elif kernel == 'rbf': X1, y1, X2, y2 = objData.gen_non_lin_separable_data(seed=1) skl = SVC(kernel=kernel, gamma=gamma) # Fit the training data. percent = 0.80 # The amount of data assigned to training. X_train, y_train, X_test, y_test = datageneration.Data.split_data(X1, y1, X2, y2,percent) # Break up examples into training and test data. objFit = skl.fit(X_train, y_train) objFit.fit_type = 'sklearn' # Output: objPlot.plot_margin(X_train[y_train == 1], X_train[y_train == -1], objFit); # Plot the margin and training data.
def main(): s_start = (2, 2) s_goal = (49, 24) astar = AStar(s_start, s_goal, "euclidean", res=1.0) plot = plotting.Plotting(s_start, s_goal) path, visited = astar.searching() plot.animation(visited, path, "A*") # animation
def main(): s_start = (2, 2) s_goal = (49, 24) astar = Dijkstra(s_start, s_goal, res=1.0) plot = plotting.Plotting(s_start, s_goal) path, visited = astar.searching() plot.animation(visited, path, "Dijkstra*") # animation
def main(): s_start = (7, 7) s_goal = (1, 1) astar = AStar(s_start, s_goal, "manhattan") plot = plotting.Plotting(s_start, s_goal) path, visited = astar.searching() plot.animation(path, visited, "A*") # animation
def main(self): self.PARENT[self.s_start] = None self.g[self.s_start] = 0 self.g[self.s_goal] = math.inf self.OPEN.put(self.s_start, self.f_value(self.s_start)) path, node_list = self.compute_shortest_path() self.plot = plotting.Plotting(self.s_start, self.s_goal) self.plot.animation(node_list, path, "Anytime D*", show=False) self.fig = plt.gcf() self.fig.canvas.mpl_connect('button_press_event', self.on_press) plt.show()
def main(): s_start = (7, 7) s_goal = (1, 1) arastar = AraStar(s_start, s_goal, 2.5, "euclidean") plot = plotting.Plotting(s_start, s_goal) path, visited = arastar.searching() for p in path: print(len(p)) print(len(path)) plot.animation_ara_star(path, visited, "Anytime Repairing A* (ARA*)")
def cla(): val = True try: year = sys.argv[1] month = sys.argv[2] except IndexError: display_error() exit() try: if int(year) > 2013 or int(year) < 1950: print("Year beyond the range. Exiting...\n") display_error() exit() if int(month) < 1 or int(month) > 12: print("Invlaid Month. Exiting...\n") display_error() exit() except ValueError: print("Invalid Numerical Value") exit() try: day = sys.argv[3] if int(day) > 31 or int(day) < 1: print("Invalid Dates. Exiting...\n") display_error() exit() limit = monthrange(int(year), int(month))[1] if int(day) > limit: print("Invalid Date for given month and year. Exiting...\n") display_error() exit() try: if not sys.argv[4]: val = get_day(year, month, day) except: pass except IndexError: pass try: if sys.argv[4]: plot_points = get_day(year, month, day, rtr=True) val = False pl = plotting.Plotting(year=year, month=month, day=day) pl.normal_plot(plot_points) return "plotted" except IndexError: pass if val: get_data.main(year, month)
def __init__(self, start, goal, obs, bot_size, ratio): self.decider = Decider() self.decider.reinit(start, goal) self.astar = Astar(start, goal, obs, bot_size, ratio) self.plot = plotting.Plotting(start, goal, obs) # self.astar_sol = self.astar.searching()[0] # self.REWARD_STEP = 0.01 self.REWARD_REACH = 100 self.REWARD_BOUND = -10 self.REWARD_CRASH = -10 self.REWARD_OVERRUN = -10 self.MAX_STEPS = 100 self.BOUNDS = [1000,800] # tune according to the environment self.TOTAL_DISTANCE = self.count_distance() # the Original distance between goal and start
def __init__(self, s_start, s_goal, step_len, goal_sample_rate, iter_max): self.s_start = Node(s_start) self.s_goal = Node(s_goal) self.step_len = step_len self.goal_sample_rate = goal_sample_rate self.iter_max = iter_max self.vertex = [self.s_start] self.env = env.Env() self.plotting = plotting.Plotting(s_start, s_goal) self.utils = utils.Utils() self.x_range = self.env.x_range self.y_range = self.env.y_range self.obs_circle = self.env.obs_circle self.obs_rectangle = self.env.obs_rectangle self.obs_boundary = self.env.obs_boundary
def realtime_search(objects): """ Path finding with realtime Astar algorithm return command at each step and the original Astar path solution""" decider = Decider(False) # plot the original path jetbot_pos, jetbot_size = objects['Jetbot'][0], objects['Jetbot'][-4:] grab_pos = objects['Grabber'][0] decider.reinit(jetbot_pos, grab_pos) obstacle_ls = objects['Obstacle'] s_start = objects['Jetbot'][0] s_goal = objects['Target'][0] if type(obstacle_ls[0]) == type(()): # if there is only one obstacle: obstacle_ls = [obstacle_ls] global Ratio Path_Found = False while not Path_Found: # Error might take place when scale changes try: astar = Astar(s_start, s_goal, obstacle_ls, jetbot_size, Ratio) Original_path, visited = astar.searching() Path_Found = True except UnboundLocalError: Ratio -= 0.1 print('Error, try change the size, ratio = ', Ratio) plot = plotting.Plotting(s_start, s_goal, obstacle_ls) plot.animation(Original_path, visited, 'AStar') # define path and obstacle set path = Original_path obs_set = get_obs_set(obstacle_ls, jetbot_size) # start iteration while len(path) > decider.Horizon: decider.jetbot_step(path, obs_set) path = Astar_search(objects, decider) # get the result trajectory = decider.get_trajectory() print('Terminate, Total number of movements is: %d' % len(trajectory)) plot.plot_traj(Original_path, trajectory) return decider.cmd_record, Original_path
def __init__(self, x_start, x_goal): self.xI, self.xG = x_start, x_goal self.e = 0.001 # threshold for convergence self.gamma = 0.9 # discount factor self.env = env.Env(self.xI, self.xG) self.motion = motion_model.Motion_model(self.xI, self.xG) self.plotting = plotting.Plotting(self.xI, self.xG) self.u_set = self.env.motions # feasible input set self.stateSpace = self.env.stateSpace # state space self.obs = self.env.obs_map() # position of obstacles self.lose = self.env.lose_map() # position of lose states self.name1 = "policy_iteration, gamma=" + str(self.gamma) [self.value, self.policy] = self.iteration() self.path = self.extract_path(self.xI, self.xG, self.policy) self.plotting.animation(self.path, self.name1)
def __init__(self, step_len, goal_sample_rate, iter_max): self.step_len = step_len self.goal_sample_rate = goal_sample_rate self.iter_max = iter_max self.env = env.Env() self.plotting = plotting.Plotting("RRT_CONNECT") self.utils = utils.Utils() self.x_range = self.env.x_range self.y_range = self.env.y_range self.obs_circle = self.env.obs_circle self.obs_rectangle = self.env.obs_rectangle self.obs_boundary = self.env.obs_boundary self.s_start = Node((0, 0)) self.s_goal = Node((0, 0)) self.path = [] self.key_points = []
def run_custom_svm(kernel='linear', C=0, gamma=0.1, degree=3): #-------------------------------------------------------------- # Purpose: SVM hard margin estimation and plot. # Inputs: # run_type : What margin calculation to perform. # Accepted Inputs: 'hard','soft','kernel'. #-------------------------------------------------------------- print("Estimating kernel: " + kernel) # Initialise Classes: objData = datageneration.Data(); # Data object. objPlot = plotting.Plotting(); # Plotting object. # Generate Data: if kernel == 'linear': if C==None or C==0: # Soft margin X1, y1, X2, y2 = objData.generate_linearly_separable_data(seed=1) else: # Hard margin X1, y1, X2, y2 = objData.gen_lin_separable_overlap_data(seed=1) # Generate the examples. elif kernel=='polynomial' or kernel=='gaussian': X1, y1, X2, y2 = objData.gen_non_lin_separable_data(seed=1) else: return objFit = SVM(kernel=kernel, C=C, gamma=gamma, degree=degree) # Create model object. # Run Fit: percent=0.80 # The amount of data assigned to training. X_train, y_train, X_test, y_test = datageneration.Data.split_data(X1, y1, X2, y2,percent) # Break up examples into training and test data. objFit.fit(X_train, y_train) # Fit the training data. y_predict = objFit.predict(X_test) # Fit the out-of-sample (predicted data). correct_predictions = np.sum(y_predict == y_test) # Check how many examples were predicted correctly. objFit.correct_predictions=correct_predictions objFit.number_of_test_examples = len(X_test) objFit.number_of_train_examples = len(X_train) objFit.fit_type = 'custom' # Output: formattedOutput(objFit) objPlot.plot_margin(X_train[y_train == 1], X_train[y_train == -1], objFit); # Plot the margin and training data.
def __init__(self, env, x_start, x_goal, step_len, goal_sample_rate, search_radius, iter_max): self.s_start = Node(x_start) self.s_goal = Node(x_goal) self.step_len = step_len self.goal_sample_rate = goal_sample_rate self.search_radius = search_radius self.iter_max = iter_max self.vertex = [self.s_start] self.path = [] self.env = env self.plotting = plotting.Plotting(self.env, x_start, x_goal) self.utils = utils.Utils(self.env) self.x_range = self.env.x_range self.y_range = self.env.y_range self.obs_circle = self.env.obs_circle self.obs_rectangle = self.env.obs_rectangle self.obs_boundary = self.env.obs_boundary
def __init__(self, x_start, x_goal): self.xI, self.xG = x_start, x_goal self.M = 500 # iteration numbers self.gamma = 0.9 # discount factor self.alpha = 0.5 self.epsilon = 0.1 self.env = env.Env(self.xI, self.xG) self.motion = motion_model.Motion_model(self.xI, self.xG) self.plotting = plotting.Plotting(self.xI, self.xG) self.u_set = self.env.motions # feasible input set self.stateSpace = self.env.stateSpace # state space self.obs = self.env.obs_map() # position of obstacles self.lose = self.env.lose_map() # position of lose states self.name1 = "SARSA, M=" + str(self.M) [self.value, self.policy] = self.Monte_Carlo(self.xI, self.xG) self.path = self.extract_path(self.xI, self.xG, self.policy) self.plotting.animation(self.path, self.name1)
def initiate(self, param): if param['modelname'] == 'LES': self.model = model_les.LES(param, self.grid) elif param['modelname'] == 'linear': self.model = model_les.LES(param, self.grid, linear=True) elif param['modelname'] == 'advection': self.model = model_adv.Advection(param, self.grid) self.tend = param['tend'] self.auto_dt = param['auto_dt'] self.dt0 = param['dt'] self.cfl = param['cfl'] self.dt_max = param['dt_max'] # Load the plotting module if param["show"]: self.plotting = plotting.Plotting(param, self.model.state, self.grid) else: self.plotting = None # number of grid cell per subdomain self.gridcellpersubdom = param["nx"] * param["ny"] * param["nz"]
def __init__(self, x_start, x_goal, eta, iter_max): self.x_start = Node(x_start[0], x_start[1]) self.x_goal = Node(x_goal[0], x_goal[1]) self.eta = eta self.iter_max = iter_max self.env = env.Env() self.plotting = plotting.Plotting(x_start, x_goal) self.utils = utils.Utils() self.fig, self.ax = plt.subplots() self.delta = self.utils.delta self.x_range = self.env.x_range self.y_range = self.env.y_range self.obs_circle = self.env.obs_circle self.obs_rectangle = self.env.obs_rectangle self.obs_boundary = self.env.obs_boundary self.Tree = Tree(self.x_start, self.x_goal) self.X_sample = set() self.g_T = dict()
import simulation import plotting as plot import solar_system if __name__ == "__main__": solar = solar_system.Solar_System() sun_earth = solar.get_sun_and_earth() solar_system = solar.get_solar_system() inner_solar_system = solar.get_inner_solar_system() outer_solar_system = solar.get_outer_solar_system() number_timesteps = 365 * 1 delta_t = 1 * 24 * 60 * 60. sim = simulation.EulerLeapfrog(sun_earth, number_timesteps, delta_t) sim.run_simulation() print("Start Plotting") plot = plot.Plotting() plot.print_energy(sim.df) plot.print_position(sim.df, len(sim.bodies)) plot.print_energy_deviation(sim.df) # plot.print_EvE(sim.df[["timestep", "planet0_x", "planet0_y", "planet0_z", "planet1_x", "planet1_y", "planet1_z"]]) # plot.print_EvE(sim.df)
def umba(x,y,z,Vtot,Theta, Psi, SpinRate, TiltH, Tiltm, SpinE, Yang, Zang, LorR, i, seamsOn, FullRot): """ The inputs are: x, y, z, Initial Ball Speed, vertical release angle, horizontal release angle, Spin Rate, Tilt in Hours, Tilt in minutes, Spin Efficiency, Y seam orientation angle, Z seam orientation angle, Primay inputs are: initial position, x0, y0, and z0 with origin at the point of home plate, x to the rright of the catcher, y from the catcher towards the pitcher, and z straight up. Initial velocities u0, v0, and w0 which are the speeds of the ball in x, y, and z respectivley. And spin rates UMBA1.0: This code uses a constant Cd and rod cross's model for CL Predictions. Seam Orientation is not accounted for. Air Density is considered only at sea level at 60% relative humidity. but can be easily altered UMBA2.0 Adding seam positions and attempting to model CL from seams. """ Yang = (Yang) * np.pi/180 Zang = -Zang * np.pi/180 # seamsOn = True frameRate = 0.002 Tilt = TimeToTilt(TiltH, Tiltm) if LorR == 'l': Gyro = np.arcsin(SpinE/100) elif LorR =='r': Gyro = np.pi - np.arcsin(SpinE/100) else: while LorR != 'l' or LorR != 'r': if LorR == 'l': Gyro = np.arcsin(SpinE/100) elif LorR =='r': Gyro = np.pi - np.arcsin(SpinE/100) else: LorR = input('please type in an "l" or an "r" for which pole goes forward') positions,NGfinal = (PitchedBallTraj(x, y, z, Vtot, Theta, Psi, SpinRate, Tilt, Gyro, Yang, Zang, i, frameRate, seamsOn, FullRot)) plotting.Plotting(positions) pX = (positions[0]) pY = (positions[1]) pZ = (positions[2]) IX = (positions[3]) IY = (positions[4]) IZ = (positions[5]) DX = (positions[6]) DY = (positions[7]) DZ = (positions[8]) FX = (positions[9]) FY = (positions[10]) FZ = (positions[11]) TF = (positions[12]) aX = (positions[13]) aY = (positions[14]) aZ = (positions[15]) TiltDeg = np.arctan2((NGfinal[0] - x + ((60-y)*np.arctan(Psi*np.pi/180))), (NGfinal[2] - z - (60-z)*np.arctan(Theta*np.pi/180)))*180/np.pi TiltTime = TiltToTime(-TiltDeg) print('Apparent Tilt = ',TiltTime[0],':',TiltTime[1]) return(pX,pY,pZ,IX,IY,IZ,DX,DY,DZ,FX,FY,FZ,TF,aX,aY,aZ,TiltTime)
#If set to False, output will be save to a file rather than presented on screen verbose = True debug = False #sets constants FEFU = 10.**-15. FUVresel = 6. NUVresel = 3. # smoothing factor (wave - sm < x < wave + sm) for sensitivity plots smoothing = 5. g230lsm = 25. #25 #creates plotting and reading instances plot = P.Plotting('.pdf') log = L.Logger('Plotting.output', verbose) if referenceFiles or Chapter13: read = IO.COSHBIO(COSrefFiles, 'temp.tmp') if computedPhot: readcom = IO.COSHBIO(COScomFiles, 'tempcom.tmp') if local: readlocal = IO.COSHBIO(localFolder, 'templocal.tmp') if PSFs: readPSF = IO.COSHBIO(localFolder, 'tempPSF.tmp') #Begins plotting... if referenceFiles: log.write('Starting to create plots based on reference files...\n') ######################################################################################## #Dispersion solutions for FUV. #These are needed for effective areas FUVd = read.FITSTable(FUVdispersionReferenceFile, 1) G130Mdisp = [ x[5][1] for x in FUVd if x[0] == 'FUVA' and x[1] == 'G130M'
"""It is possible to compute the ship wake pattern directly, thanks to a beautiful mathematical trick found in a Pierre Gilles de Gennes paper (French 1991 Nobel Prize). See the fourier.py module. """ # to activate it, copy-paste this script in your Ipython window, after # you've run the main wave2d script import plotting as pt fig = pt.Plotting(param) p = model.fspace.compute_balanced_wake(model.hphi0, param.U) fig.init_figure(p)
def main(): x_range = 15 # size of background y_range = 15 s_start = (7, 7) highvalueGoal = (1, 13) lowvalueGoal = [(1, 1), (13, 1), (13, 13)] motions = [(-1, 0), (0, 1), (1, 0), (0, -1)] x_range = 15 # size of background y_range = 15 randomObsNum = 18 randomSampleMaze = RandomSampleMaze(x_range, y_range, randomObsNum, [s_start], [highvalueGoal], lowvalueGoal) maze = namedtuple( 'maze', 'initAgent highValueGoalPos highValueSteps fixedObstacles ') highValueSteps = 20 lowValueSteps = 13 numberOfMaze = 5 # Samples = 1000000 # for i in range(Samples): i = 0 selectedMazeList = [] visualize = True while i < numberOfMaze: proposalMaze = randomSampleMaze() proposalMazeWithWall = addWall(x_range, y_range, proposalMaze) astar = Astar.AStar(s_start, highvalueGoal, proposalMazeWithWall, motions, "manhattan") try: path = [] path, visited = astar.searching() except: pass else: pass if len(path) == highValueSteps: # print(len(path)) popOut = False for goal in lowvalueGoal: astar2 = Astar.AStar(s_start, goal, proposalMazeWithWall, motions, "manhattan") try: path2, visited2 = astar2.searching() except: popOut = True break else: # print(goal, len(path2)) if len(path2) != lowValueSteps: popOut = True break if popOut: continue minDistractDistance = [] for goal in lowvalueGoal: minDistance = np.min( [calculateGridDis(goal, node) for node in path]) # print(minDistance) minDistractDistance.append({goal: minDistance}) # currentMaze = maze(initAgent = s_start, highValueGoalPos = highvalueGoal, highValueSteps = len(path), fixedObstacles = proposalMaze) currentMaze = { 'initAgent': s_start, 'highValueGoalPos': highvalueGoal, 'highValueSteps': len(path), 'distractDistance': minDistractDistance, 'fixedObstacles': proposalMaze } # print(currentMaze,i) i = i + 1 print(currentMaze, i) selectedMazeList.append(currentMaze) if visualize: plot = plotting.Plotting(s_start, highvalueGoal, proposalMazeWithWall) plot.animation(path, visited, "A*") # animation # savePath = os.path.join( 'map', str(highValueSteps) + 'highValueSteps' + str(numberOfMaze) + 'maps' + '.pickle') saveToPickle(selectedMazeList, savePath)
def main(): plot = plotting.Plotting() plot.plot_grid("Map") adj_matrix = get_matrix(plot.ret_map())
def run(self, param, anim=True): if param.generation in ['wake', 'oscillator']: hphi = self.hphi0.copy() * 0 else: hphi = self.hphi0.copy() if anim: self.plot = plotting.Plotting(param) var = self.fspace.compute_all_variables(hphi) if param.plotvector == 'velocity': self.plot.init_figure(self.phi0, u=var['u'], v=var['v']) elif param.plotvector == 'energyflux': self.plot.init_figure(self.phi0, u=var['up'], v=var['vp']) else: self.plot.init_figure(self.phi0) tend = param.tend dt = param.dt nt = int(tend / dt) kxx, kyy = self.fspace.kxx, self.fspace.kyy omega = self.fspace.omega propagator = np.exp(-1j * omega * dt) sigma = param.sigma aspect_ratio = param.aspect_ratio x0, y0 = param.x0, param.y0 xx, yy = self.fspace.xx, self.fspace.yy time = 0. kplot = np.ceil(param.tplot / dt) xb, yb = param.x0 + param.Lx / 2, param.y0 + param.Ly / 2 xb, yb = 0, 0 # param.x0, param.y0 energy = np.zeros((nt, )) if param.netcdf: attrs = {"model": "wave2d", "wave": param.typewave} sizes = {"y": param.ny, "x": param.nx} variables = [{ "short": "time", "long": "time", "units": "s", "dims": ("time") }, { "short": "p", "long": "pressure anomaly", "units": "m^2 s^-2", "dims": ("time", "y", "x") }, { "short": "u", "long": "velocity x-component", "units": "m s^-1", "dims": ("time", "y", "x") }, { "short": "v", "long": "velocity y-component (or z-)", "units": "m s^-1", "dims": ("time", "y", "x") }, { "short": "up", "long": "up flux x-component", "units": "m^3 s^-3", "dims": ("time", "y", "x") }, { "short": "vp", "long": "vp flux y-component", "units": "m^3 s^-3", "dims": ("time", "y", "x") }] fid = nct.NcTools(variables, sizes, attrs, ncfilename=param.filename) fid.createhisfile() ktio = 0 for kt in range(nt): energy[kt] = 0.5 * np.mean(np.abs(hphi.ravel())**2) hphi = hphi * propagator if param.generation == 'wake': if hasattr(self, "traj"): xb, yb = self.traj.get_position(time) vx, vy = self.traj.get_velocity(time) kalpha = vx * kxx + vy * kyy # recompute self.boat (complex Fourier amplitude) # to account for the new heading heading = np.angle(vx + 1j * vy) self.set_wave_packet(param, heading) # shift the source at the boat location (xb,yb) shift = np.exp(-1j * (kxx * xb + kyy * yb)) # add the source term to hphi hphi -= 1j * dt * self.boat * kalpha * shift else: if kt == 0: kalpha = np.cos(param.alphaU)*kxx + \ np.sin(param.alphaU)*ky hphi += (1j*1e2*dt*self.boat*param.U*kalpha) * \ np.exp(-1j*(kxx*xb+kyy*yb)) xb += dt * param.U * np.cos(param.alphaU) yb += dt * param.U * np.sin(param.alphaU) elif param.generation == 'oscillator': hphi += (1e2 * dt * self.boat) * np.exp( -1j * time * param.omega0) kt += 1 time += dt if anim: if (kt % kplot == 0): var = self.fspace.compute_all_variables(hphi) z2d = var[param.varplot] self.var = var if param.plotvector == 'velocity': self.plot.update(kt, time, z2d, u=var['u'], v=var['v']) elif param.plotvector == 'energyflux': self.plot.update(kt, time, z2d, u=var['up'], v=var['vp']) else: self.plot.update(kt, time, z2d) if param.netcdf: with Dataset(param.filename, "r+") as nc: nc.variables["time"][ktio] = time nc.variables["p"][ktio, :, :] = z2d for v in ["u", "v", "up", "vp"]: nc.variables[v][ktio, :, :] = var[v] ktio += 1 else: print('\rkt=%i / %i' % (kt, nt), end='') var = self.fspace.compute_all_variables(hphi) self.energy = energy self.var = var
def main(): """ Primay inputs are: initial position, x0, y0, and z0 with origin at the point of home plate, x to the rright of the catcher, y from the catcher towards the pitcher, and z straight up. Initial velocities u0, v0, and w0 which are the speeds of the ball in x, y, and z respectivley. And spin rates UMBA1.0: This code uses a constant Cd and rod cross's model for CL Predictions. Seam Orientation is not accounted for. Air Density is considered only at sea level at 60% relative humidity. but can be easily altered UMBA2.0 Adding seam positions and attempting to model CL from seams. """ print("This baseball trajectory calculator models \ still air at sea level with about 60% humidity.\nThe ambient\ conditions are fixed can be adjusted in the code \ if needed or made into variable at a later time.\n\ \nAll initial ball state variables have default values that approximate\ a 90 mph ball with no spin.\nThe release point is only asked once\ and remains the same for subsequent pitches.\nAll other variables\ can be changed for comparison. To retain the current value, just press return") pX = [] pY = [] pZ = [] IX = [] IY = [] IZ = [] DX = [] DY = [] DZ = [] FX = [] FY = [] FZ = [] #x y and z here are typical of an approximately 6' tall rhp # these are the defualt initial values and can be changed here or as the code runs # as the code seamsOn = True frameRate = 0.002 #frame rate can change how quickly or slowly the code x = 0 y = 5.5 z = 6 Vtot = 90 Theta = 0 Psi = 0 SpinRate = 1200 TiltH = 12 Tiltm = 0 SpinE = 100 Yangle = 0 * np.pi / 180 Zangle = 0 * np.pi / 180 #will run if you are plotting the print('\n\n\ncurent release distance left to right is', x) Qx = (input( 'distance left from center of rubber (right haded pitchers should have negative numbers) (ft): ' )) if Qx == "": x = x else: x = float(x) print('\n\n\ncurent release distance from rubber', y) Qy = (input( 'release distance from rubber (should be approximatly the stride lenght)(ft): ' )) if Qy == "": y = y else: y = float(Qy) print('\n\n\ncurent release height is', z) Qz = (input('height of ball from field at release (ft): ')) if Qz == "": z = z else: z = float(Qz) i = 0 repeat = True while repeat == True: if i == 0: print( '\n\nIf you want to keep the current value simply hit return. Otherwise enter a new value.\n\n' ) print("\n\nCurrent initial speed set to ", Vtot) QVtot = (input('what is the ball\'s release speed (mph): ')) if QVtot == "": Vtot = Vtot else: Vtot = float(QVtot) print("\n\nCurrent vertical release angle set to ", Theta) QTheta = (input('what is the ball\'s vertical release angle (deg): ')) if QTheta == "": Theta = Theta else: Theta = float(QTheta) print("\n\nCurrent horizontal release angle set to ", Psi) QPsi = (input('what is the ball\'s horizontal release angle(deg): ')) if QPsi == "": Psi = Psi else: Psi = float(QPsi) print("\n\nCurrent initial Spin Rate set to ", SpinRate) QSpinRate = (input('what is the ball\'s initial spin rate (rpm): ')) if QSpinRate == "": SpinRate = SpinRate else: SpinRate = float(QSpinRate) print("\n\nCurrent initial tilt hours set to ", TiltH) QTiltH = (input('what is the ball\'s initial hours tilt (hrs): ')) if QTiltH == "": TiltH = TiltH else: TiltH = float(QTiltH) print("\n\nCurrent initial tilt minutes set to ", Tiltm) QTiltm = (input('what is the ball\'s initial minutes tilt (mins): ')) if QTiltm == "": Tiltm = Tiltm else: Tiltm = float(QTiltm) Tiltr = processing.TimeToTilt(TiltH, Tiltm) print("\n\nCurrent initial spin efficiency set to ", SpinE) QSpinE = (input('what is the ball\'s initial spin efficiency (%): ')) if QSpinE == "": SpinE = SpinE else: SpinE = float(QSpinE) if SpinE == 100: Gyro = np.arcsin(SpinE / 100) # Gyro = np.arccos(1 - (SpinE/100)) else: TiltHnewUp = TiltH + 3 if TiltHnewUp > 12: TiltHnewUp = int(TiltHnewUp - 12) else: TiltHnewUp = int(TiltHnewUp) TiltHnewDn = TiltH - 3 if TiltHnewDn < 1: TiltHnewDn = int(TiltHnewDn + 12) else: TiltHnewDn = int(TiltHnewDn) print('if', TiltHnewUp, ':', int(Tiltm), 'is forward enter " r "') print('if', TiltHnewDn, ':', int(Tiltm), 'is forward enter " l "') leftRightGyro = '' while leftRightGyro != 'l' and leftRightGyro != 'r': leftRightGyro = input("l/r") if leftRightGyro == 'l': Gyro = np.arcsin(SpinE / 100) # Gyro = np.arccos(1 - (SpinE/100)) elif leftRightGyro == 'r': # Gyro = np.pi - np.arccos(1- (SpinE/100)) Gyro = np.pi - np.arcsin(SpinE / 100) if seamsOn == True: QSeamsOn = input('keep seams on?') if QSeamsOn == 'y' or QSeamsOn == 'yes' or QSeamsOn == 'Y' or QSeamsOn == 'YES' or QSeamsOn == 'Yes' or QSeamsOn == '': seamsOn == True print("\n\nCurrent Y orientation angle set to ", Yangle * 180 / np.pi) QYangle = (input( 'what is the ball\'s initial Y orientation angle (degs): ') ) if QYangle == "": Yangle = Yangle #Zangle is still in radians else: Yangle = float(QYangle) Yangle = (np.pi / 180) * Yangle print("\n\nCurrent Z orientation angle set to ", Zangle * 180 / np.pi) QZangle = (input( 'what is the ball\'s initial Z orientation angle (degs): ') ) if QZangle == "": Zangle = Zangle #Zangle is still in radians else: Zangle = float(QZangle) Zangle = (np.pi / 180) * Zangle #converts to radians # consult https://scout.texasleaguers.com/spin for further understanding elif QSeamsOn == 'n' or QSeamsOn == 'no' or QSeamsOn == 'N' or QSeamsOn == 'NO' or QSeamsOn == 'No': seamsOn = False Zangle = 0 Yangle = 0 else: QSeamsOn = input('keep seams off?') if QSeamsOn == 'y' or QSeamsOn == 'yes' or QSeamsOn == 'Y' or QSeamsOn == 'YES' or QSeamsOn == 'Yes' or QSeamsOn == '': seamsOn = False Zangle = 0 Yangle = 0 elif QSeamsOn == 'n' or QSeamsOn == 'no' or QSeamsOn == 'N' or QSeamsOn == 'NO' or QSeamsOn == 'No': seamsOn = True print("\n\nCurrent Y orientation angle set to ", Yangle * 180 / np.pi) QYangle = (input( 'what is the ball\'s initial Y orientation angle (degs): ') ) if QYangle == "": Yangle = Yangle #Zangle is still in radians else: Yangle = float(QYangle) Yangle = (np.pi / 180) * Yangle print("\n\nCurrent Z orientation angle set to ", Zangle * 180 / np.pi) QZangle = (input( 'what is the ball\'s initial Z orientation angle (degs): ') ) if QZangle == "": Zangle = Zangle #Zangle is still in radians else: Zangle = float(QZangle) Zangle = (np.pi / 180) * Zangle #converts to radians # consult https://scout.texasleaguers.com/spin for further understanding positions = (processing.PitchedBallTraj(x, y, z, Vtot, Theta, Psi, SpinRate, Tiltr, Gyro, Yangle, Zangle, i, frameRate, seamsOn)) plotting.Plotting(positions) pX.append(positions[0]) pY.append(positions[1]) pZ.append(positions[2]) IX.append(positions[3]) IY.append(positions[4]) IZ.append(positions[5]) DX.append(positions[6]) DY.append(positions[7]) DZ.append(positions[8]) FX.append(positions[9]) FY.append(positions[10]) FZ.append(positions[11]) leave = False k = 0 while leave == False: k = k + 1 if k == 1: Again = input("Would you like to look at another pitch?\n") elif k > 6: Again = 'n' elif k > 5: Again = input( "Last Chance.Would you like to look at another pitch (y/n)?\n" ) else: Again = input( "Would you like to look at another pitch (y/n)?\n") if Again == 'y' or Again == 'yes' or Again == 'Y' or Again == 'YES' or Again == 'Yes': repeat = True leave = True elif Again == 'n' or Again == 'no' or Again == 'N' or Again == 'NO' or Again == 'No': repeat = False leave = True else: leave = False i = i + 1 plotting.plotSFinal(pX, pY, pZ, IX, IY, IZ, DX, DY, DZ, FX, FY, FZ, i)
:return: heuristic function value """ heuristic_type = self.heuristic_type goal = self.s_goal if heuristic_type == 'manhattan': return abs(goal[0] - s[0]) + abs(goal[1] - s[1]) else: return math.hypot(goal[0] - s[0], goal[1] - s[1]) if __name__ == '__main__': objects = { 'Jetbot': [(953, 461), 834, 1073, 636, 287], 'Obstacle': [(1100, 300), 1000, 1200, 800, 0], 'Target': [(1342, 170), 1308, 1377, 249, 92], 'Grabber': [(1054, 626), 1003, 1106, 728, 525] } obstacle_ls = objects['Obstacle'] s_start = objects['Jetbot'][0] s_goal = objects['Target'][0] if type(obstacle_ls[0]) == type(()): # if there is only one obstacle: obstacle_ls = [obstacle_ls] astar = Astar(s_start, s_goal, obstacle_ls) path, visited = astar.searching() plot = plotting.Plotting(s_start, s_goal, obstacle_ls) plot.animation(path, visited, 'AStar')