def testNumericReplicator2(self): """Replicator should yield the same results as QR if noise = 0.0""" for i in xrange(50): p = Dynamics.RandomDistribution(20) f = array([random.random() for k in xrange(20)]) r = Dynamics._numeric_QuickReplicator(p, f) r2 = Dynamics._numeric_Replicator(p, f, 0.0) self.failUnless(AlmostEqual(r, r2))
def testNumericReplicator4(self): """Little noise should only matter a little""" for i in xrange(50): p = Dynamics.RandomDistribution(100) f = array([random.random() for k in xrange(100)]) r = Dynamics._numeric_QuickReplicator(p, f) r2 = Dynamics._numeric_Replicator(p, f, 0.01) self.failUnless(AlmostEqual(r, r2, 0.0101))
def testFitnessCorrelation(self): """Correlation should make a difference""" G = ArrayWrapper.array(CorelatedGame) for k in range(20): p = Dynamics.RandomDistribution(8) compare = Dynamics._QuickFitness(p, G, 3) fitness = Dynamics._Fitness(p, G, 0.2, 3) self.failIf(AlmostEqual(fitness, compare))
def testNumericReplicator3(self): """Noise should matter""" for i in xrange(50): p = Dynamics.RandomDistribution(100) f = array([random.random() for k in xrange(100)]) r = Dynamics._numeric_QuickReplicator(p, f) r2 = Dynamics._numeric_Replicator(p, f, 0.5) self.failIf(AlmostEqual(r, r2))
def testFitness2ZeroCorrelation(self): """Fitness2 should return the same results QuickFitness2 if e=0.0.""" for i in range(20): G = array(GenRandomGame(2, 8)) for k in range(5): p = Dynamics.RandomDistribution(8) compare = Dynamics._QuickFitness2(p, G) fitness = Dynamics._Fitness2(p, G, 0.0) self.failUnless(AlmostEqual(fitness, compare))
def testFitnessZeroCorrelation(self): """Fitness should return the same results as QuickFitness if e=0.0.""" for i in range(5): G = array(GenRandomGame(4, 7)) for k in range(5): p = Dynamics.RandomDistribution(7) compare = Dynamics._QuickFitness(p, G, 4) fitness = Dynamics._Fitness(p, G, 0.0, 4) self.failUnless(AlmostEqual(fitness, compare))
def testNumericFitness2Players(self): """Fitness2 and numeric_Fitness2 should yield the same values""" for i in range(20): G = array(GenRandomGame(2, 8)) for k in range(5): p = Dynamics.RandomDistribution(8) compare = Dynamics._Fitness2(p, G, 0.2) fitness = Dynamics._numeric_Fitness2(p, G, 0.2) self.failUnless(AlmostEqual(fitness, compare))
def testFitness2Players(self): """Fitness should be the same as Fitness2 in the 2 player case""" for i in range(20): G = array(GenRandomGame(2, 8)) for k in range(5): p = Dynamics.RandomDistribution(8) compare = Dynamics._Fitness2(p, G, 0.2) fitness = Dynamics._Fitness(p, G, 0.2, 2) self.failUnless(AlmostEqual(fitness, compare))
def testQuickFitness2Players(self): """QuickFitness should not make a difference to QF2 in the 2 player case """ for i in range(20): G = array(GenRandomGame(2, 8)) for k in range(5): p = Dynamics.RandomDistribution(8) compare = Dynamics._QuickFitness2(p, G) fitness = Dynamics._QuickFitness(p, G, 2) self.failUnless(AlmostEqual(fitness, compare))
def testSampledFitness(self): """SampledFitness should yield roughly the same results as Fitness""" for i in range(5): G = array(GenRandomGame(3, 8)) p = Dynamics.RandomDistribution(8) fitness = Dynamics._Fitness(p, G, 0.2, 3) failures = 0 for k in range(5): sampled = Dynamics._SampledFitness(p, G, 0.2, 3, 5000) if not AlmostEqual(fitness, sampled, 0.15): failures += 1 self.failIf(failures > 1)
def testSampledQuickFitness(self): """SampledQuickFitness should yield similar results as QuickFitness""" for i in range(5): G = array(GenRandomGame(4, 7)) p = Dynamics.RandomDistribution(7) fitness = Dynamics._QuickFitness(p, G, 4) failures = 0 for k in range(5): sampled = Dynamics._SampledQuickFitness(p, G, 4, 5000) if not AlmostEqual(fitness, sampled, 0.1): failures += 1 self.failIf(failures > 1)
def newState(self, sample, prev_sens): if (self.checkCali(sample)): return # else: # # TODO does this make sense?? # return # state = [None]*sensor_no sample = np.subtract(sample, self.offset) sample[:][0] / self.g_weight # print("Sample: ", sample) prev_sens_pos = prev_sens.states[prev_sens.state_loc - 1][4] state = self.getState(sample, 0, prev_sens_pos) #saveState self.states.append(state.tolist()) self.state_loc += 1 # make quat self.currentQ = dyn.makequaternion(sample) self.quats.append(self.currentQ) if (self.state_loc % 100 == 0): self.printStates()
def update_typical_vals(networks, int_times, rtol = 1e-9, fraction=1.0, cutoff=1e-14): """ Update the typical var values for a group of networks. Find the maximum of each variable over the integrations. In each network the typical value is set to fraction of that maximum. If that maximum value is less than cutoff, the typical value is set to 1. networks List of networks to work with int_times List of corresponding integration endpoints (ie. [(0, 100), (0, 50)]) fraction Relative size of typical value, compared to max value over the integrations. rtol Relative tolerance for the integrations. cutoff Values below this are considered to be zero """ max_vals = {} for net, times in zip(networks, int_times): traj = Dynamics.integrate(net, times, rtol=rtol, fill_traj=True) for var_id in net.variables.keys(): curr_max = max(traj.get_var_traj(var_id)) max_vals[var_id] = max(curr_max, max_vals.get(var_id, 0)) for var_id, val in max_vals.items(): for net in networks: if net.variables.has_key(var_id): if val > cutoff: net.set_var_typical_val(var_id, val*fraction) else: net.set_var_typical_val(var_id, 1.0) return max_vals
def testQuickReplicator2(self): """Population should not change when fitnesses are equal""" f = [1.0]*10 for i in xrange(50): p = Dynamics.RandomDistribution(10) r = Dynamics._QuickReplicator(p, f) self.failIf(not AlmostEqual(p, r))
def simulate(self): self.t = self.start while self.t < self.end: self.t += self.t_step # Desired Trajectory [From Input or Trajectory] and State [From Dynamics] self.State_d = TR.trajectory(self.t, self.State_d) # Calculate Actions and Forces from Controller self.PhiC_last, Actions = C2D.control(self.PhiC_last, self.State, self.State_d, self.Gains, self.Params, self.t_step) # Use Dynamics to Simulate New State [Transform Axes, Estimate Derivatives self.State = DYN.dynamics(self.State, self.Params, Actions, self.t_step) ## Calculation time for above measured at around 0.5 milliseconds on average # Record trajectory against simulation time self.t_vec.append(self.t) self.y_vec.append(self.State[0]) self.z_vec.append(self.State[1]) self.phi_vec.append(self.State[4]) self.y_des_vec.append(self.State_d[0]) self.z_des_vec.append(self.State_d[1])
def mpcPlot(self): dy = Dynamics.VehicleDynamics() ref = dy.reference_trajectory( Numpy2Torch(self.state_history[:, -1], self.state_history[:, -1].shape)) self.state_r_history = self.state_r_history.reshape([-1, 5]) plt.figure(1) plt.plot(self.state_history[:, -1], self.state_history[:, 0], label="trajectory") # plt.plot(state_r_history[:,-1],state_r_history[:,0], label="$trajectory_r$") # plt.plot(self.state_history[:,-1],self.config.a_curve * np.sin(self.config.k_curve*self.state_history[:,-1]), label="reference") plt.plot(self.state_history[:, -1], ref[:, 0], label="reference") plt.legend(loc="upper right") plt.figure(2) plt.plot(self.state_history[:, -1], self.state_history[:, 2], label="trajectory") # plt.plot(state_r_history[:,-1],state_r_history[:,0], label="$trajectory_r$") # plt.plot(self.state_history[:,-1],self.config.a_curve * np.sin(self.config.k_curve*self.state_history[:,-1]), label="reference") plt.plot(self.state_history[:, -1], ref[:, 2], label="reference") plt.legend(loc="upper right") plt.figure(3) plt.plot(self.state_history[0:-1, -1], self.control_history) plt.show()
def testQuickFitnessFairGame(self): """Fitness should return equal fitnesses a 'totally fair' game""" G = ArrayWrapper.array(lambda a,b,c,d: 5.0) for i in range(10): r = Dynamics.RandomDistribution(7) f = Dynamics._QuickFitness(r, G, 4) for k in range(1,7): self.failIf(f[k] != f[0])
def testQuickFitness2FairGame(self): """QuickFitness2 should yield equal fitnesses in a totally fair game""" G = ArrayWrapper.array(lambda a,b: 0.3) for i in range(20): p = Dynamics.RandomDistribution(5) f = Dynamics._QuickFitness2(p, G) for k in range(1,5): self.failIf(f[k] != f[0])
def testQuickReplicator3(self): """Different fitness values ought to have an impact""" p = Dynamics.UniformDistribution(10) f = array([1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1]) for i in xrange(5): r = Dynamics._QuickReplicator(p, f) for k in range(len(r)-1): self.failIf(r[k+1]>=r[k]) p = r
def testNumericReplicator1(self): """Results of Replicator should be sound""" for i in xrange(50): p = Dynamics.RandomDistribution(50) f = array([random.random() for k in xrange(50)]) r = Dynamics._numeric_Replicator(p, f, random.random()) for x in r: self.failIf(x < 0.0 or x > 1.0) self.failUnless(AlmostEqual(sum(r), 1.0))
def discrete_data(net, params, pts, interval, vars=None, random=False, uncert_func=typ_val_uncert(0.1, 1e-14)): """ Return a set of data points for the given network generated at the given parameters. net Network to generate data for params Parameters for this evaluation of the network pts Number of data points to output interval Integration interval vars Variables to output data for, defaults to all species in net random If False data points are distributed evenly over interval If True they are spread randomly and uniformly over each variable uncert_func Function that takes in a trajectory and a variable id and returns what uncertainty should be assumed for that variable, either as a scalar or a list the same length as the trajectory. """ # Default for vars if vars is None: vars = net.species.keys() # Assign observed times to each variable var_times = {} for var in vars: if random: var_times[var] = scipy.rand(pts) * (interval[1]-interval[0]) + interval[0] else: var_times[var] = scipy.linspace(interval[0], interval[1], pts) # Create a sorted list of the unique times in the var_times dict int_times = sets.Set(scipy.ravel(var_times.values())) int_times.add(0) int_times = list(int_times) int_times.sort() # Get the trajectory traj = Dynamics.integrate(net, int_times, params=params, fill_traj=False) # Build up our data dictionary data = {} for var, times in var_times.items(): var_data = {} data[var] = var_data # Calculate our uncertainties var_uncerts = uncert_func(traj, var) for time in times: val = traj.get_var_val(var, time) if scipy.isscalar(var_uncerts): uncert = var_uncerts else: index = traj._get_time_index(time) uncert = var_uncerts[index] var_data[time] = (val, uncert) return data
def discrete_data(net, params, pts, interval, vars=None, random=False, uncert_func=typ_val_uncert(0.1, 1e-14)): """ Return a set of data points for the given network generated at the given parameters. net Network to generate data for params Parameters for this evaluation of the network pts Number of data points to output interval Integration interval vars Variables to output data for, defaults to all species in net random If False data points are distributed evenly over interval If True they are spread randomly and uniformly over each variable uncert_func Function that takes in a trajectory and a variable id and returns what uncertainty should be assumed for that variable, either as a scalar or a list the same length as the trajectory. """ # Default for vars if vars == None: vars = net.species.keys() # Assign observed times to each variable var_times = {} for var in vars: if random: var_times[var] = scipy.rand(pts) * (interval[1]-interval[0]) + interval[0] else: var_times[var] = scipy.linspace(interval[0], interval[1], pts) # Create a sorted list of the unique times in the var_times dict int_times = sets.Set(scipy.ravel(var_times.values())) int_times.add(0) int_times = list(int_times) int_times.sort() # Get the trajectory traj = Dynamics.integrate(net, int_times, params=params, fill_traj=False) # Build up our data dictionary data = {}; for var, times in var_times.items(): var_data = {} data[var] = var_data # Calculate our uncertainties var_uncerts = uncert_func(traj, var) for time in times: val = traj.get_var_val(var, time) if scipy.isscalar(var_uncerts): uncert = var_uncerts else: index = traj._get_time_index(time) uncert = var_uncerts[index] var_data[time] = (val, uncert) return data
def testQuickReplicator4(self): """Extinct species should stay extinct.""" for i in xrange(50): f = array([random.uniform(0.5, 1.5) for k in xrange(10)]) x = random.randint(1, 9) p = Dynamics.UniformDistribution(x, 0.5) p = concatenate((p, array([0.0] * (10-x)))) idx = [l for l in range(10) if p[l] == 0.0] r = Dynamics._QuickReplicator(p, f) for l in idx: self.failIf(r[l] != 0.0)
def adjustVelocitiesToConstraints(self, velocities=None, block=1): """Modifies the velocities to be compatible with the distance constraints, i.e. projects out the velocity components along the constrained distances. This operation is thread-safe; it blocks other threads that want to access the velocities while the data is being updated. If this is not desired (e.g. when calling from a routine that handles locking itself), the optional parameter |block| should be set to 0.""" import Dynamics if velocities is None: velocities = self.velocities() if velocities is not None: if block: self.acquireWriteStateLock() try: Dynamics.projectVelocities(self, velocities) finally: if block: self.releaseWriteStateLock()
def calculate_msd(): parameterFile = "parameters.json" parser = argparse.ArgumentParser() parser.add_argument("-d", "--directory", type=str, default="./", help="input directory") #parser.add_argument("-o", "--output", type=str, help="output directory") #parser.add_argument("-p", "--prefix", type=str, default="cornea",help="prefix for output file") parser.add_argument("-s", "--skip", type=int, default=1100, help="skip this many samples") parser.add_argument("-m", "--howmany", type=int, default=30, help="read this many samples") parser.add_argument("-t", "--step", type=int, default=4, help="step snapshots with this spacing in flow field") parser.add_argument("-a", "--average", type=int, default=5, help="average over these many samples in flow field") args = parser.parse_args() param = read_param_CAPMD.Param( p.paramsFromFile(capmd.Parameters(), parameterFile)) sheet = Dynamics(initype="fromCSV", param=param, datapath='output/', multiopt="many") skip = 0 step = 1 howmany = 500 sheet.readDataMany("CAPMD", skip, step, howmany, False, readtypes=[1]) sheet.validate_initialise() sheet.getMSD(False) plt.show() return 0
def calibrate(self, calSample): # print("cal_sample:\n", calSample) n = self.num_cal_samples sample = np.empty((3, 2), dtype=float) sample[0][0] = sum(calSample[:, 0]) / n sample[1][0] = sum(calSample[:, 1]) / n sample[2][0] = sum(calSample[:, 2]) / n sample[0][1] = sum(calSample[:, 3]) / n sample[1][1] = sum(calSample[:, 4]) / n sample[2][1] = sum(calSample[:, 5]) / n #print(sample) currentQ = dyn.makequaternion0(sample) a_body = np.quaternion(0, sample[0][0], sample[1][0], sample[2][0]) a_nav = dyn.rotatef(currentQ, a_body) # accel in nav frame v = quaternion.as_float_array(a_nav) u = abs(v) x = np.where(u == np.amax(u)) ######## TODO # x = np.where(v == np.amax(abs(v))) # print("vx0 ", v[x[0]]) # print(x) v[x[0]] = v[x[0]] + dyn.g # if v[x[0]] < 0: # print("vx < 0") # v[x[0]] = v[x[0]] + dyn.g # else: # print("vx >= 0") # v[x[0]] = v[x[0]] - dyn.g #print(v[x[0]]) qNav = quaternion.as_quat_array(v) qBody = dyn.rotateb(self.currentQ, qNav) #print(qBody) Q = quaternion.as_float_array(qBody) self.offset[:, 0] = Q[1:] self.offset[:, 1] = sample[:, 1] #print(offset) return sample
def get_update(self, i): start = time.time() self.t += self.t_step # Desired Trajectory [From Input or Trajectory] and State [From Dynamics] self.State_d = TR.trajectory(self.t, self.State_d) # Calculate Actions and Forces from Controller self.PhiC_last, Actions = C2D.control(self.PhiC_last, self.State, self.State_d, self.Gains, self.Params, self.t_step) # Use Dynamics to Simulate New State [Transform Axes, Estimate Derivatives self.State = DYN.dynamics(self.State, self.Params, Actions, self.t_step) ## Calculation time for above measured at around 0.5 milliseconds on average end = time.time() print("Simulation time") print(end - start) # Update Plot self.t_vec.append(self.t) self.p_vec.append(self.State[0]) self.p_des_vec.append(self.State_d[0]) start = time.time() self.line.set_data(self.t_vec, self.p_vec) #self.fig.canvas.draw() self.fig.canvas.blit(self.ax.bbox) end = time.time() print("Plotting time") print(end - start) if self.t > 10: self.terminate() return self.line,
def unitary_dynamics(self, pulse, tlist, wd, drive_qb=1, dynamics=None): ''' User may call this function after created solver object pulse: the pulse envelope of drive tlist: time array of drive wd: drive frequency drive_qb: drive qubit, start from 1, instead of 0 ''' if len(pulse) != len(tlist): raise ValueError( 'pulse array should have the same length with t array!') self.generate_drive_term(tlist, wd, drive_qb) #self.H = np.array([self.Hdiag for i in range(len(tlist))], dtype=qt.Qobj) self.H = self.H0_int + pulse * self.Hd if dynamics == None: dynamics = self.dynamics desolver = Dynamics.Sesolver() desolver.solve(self.H, tlist, dynamics=dynamics) self.U = desolver.U
def mpcSolution(self): # initialize state model statemodel_plt = Dynamics.VehicleDynamics() state = self.initial_state # state = torch.tensor([[0.0, 0.0, self.psi_init, 0.0, 0.0]]) state.requires_grad_(False) x_ref = statemodel_plt.reference_trajectory(state[:, -1]) state_r = state.detach().clone() # relative state state_r[:, 0:4] = state_r[:, 0:4] - x_ref self.state_history = state.detach().numpy() plot_length = self.config.SIMULATION_STEPS self.control_history = [] self.state_r_history = state_r cal_time = 0 plt.figure(0) for i in range(plot_length): x = state_r.tolist()[0] time_start = time.time() temp, control = self.solver.mpcSolver(x, self.config.NP) plt.plot(temp[:, -1], temp[:, 0]) cal_time += time.time() - time_start u = Numpy2Torch(control[0], (-1, self.config.ACTION_DIM)) state, state_r = step_relative(statemodel_plt, state, u) self.state_history = np.append(self.state_history, state.detach().numpy(), axis=0) self.control_history = np.append(self.control_history, u.detach().numpy()) self.state_r_history = np.append(self.state_history, state_r.detach().numpy()) print("MPC calculating time: {:.3f}".format(cal_time) + "s") self.mpcSaveTraj()
def newStateS0(self, sample): if (self.checkCali(sample)): return # state = [None]*sensor_no sample = np.subtract(sample, self.offset) sample[:][0] / self.g_weight # print("Sample: ", sample) # init state array state = self.getState(sample, 1, 0) # use old getState using accel #saveState self.states.append(state.tolist()) self.state_loc += 1 # use old quat method for s0 self.currentQ = dyn.orientation(self.currentQ, sample) self.quats.append(self.currentQ) if (self.state_loc % 100 == 0): self.printStates()
def getState(self, sample, using_a, prev_sens_pos): state = np.zeros((3, 5), dtype=float) if (using_a): a_body = np.quaternion(0, sample[0, 0], sample[1, 0], sample[2, 0]) a_nav = dyn.rotatef(self.currentQ, a_body) # accel in nav frame a_nav_subg = dyn.subtractg(a_nav) # Acceleration - body a_body = quaternion.as_float_array(a_body) state[:, 4] = a_body[1:] # position # Acceleration - nav a_nav_subg = quaternion.as_float_array(a_nav_subg) state[0, 2] = a_nav_subg[1] state[1, 2] = a_nav_subg[2] state[2, 2] = a_nav_subg[3] # Gyroscope state[0, 3] = sample[0, 1] state[1, 3] = sample[1, 1] state[2, 3] = sample[2, 1] # Velocity i = self.state_loc state[0, 1] = dyn.speed(self.states[i - 1][1][0], self.states[i - 1][2][0], dyn.w) #speed(v0 a t) state[1, 1] = dyn.speed(self.states[i - 1][1][1], self.states[i - 1][2][1], dyn.w) state[2, 1] = dyn.speed(self.states[i - 1][1][2], self.states[i - 1][2][2], dyn.w) # Position state[0, 0] = dyn.position(self.states[i - 1][0][0], self.states[i - 1][1][0], self.states[i - 1][2][0], dyn.w) #position(s0,v0,a,t) state[1, 0] = dyn.position(self.states[i - 1][0][1], self.states[i - 1][1][1], self.states[i - 1][2][1], dyn.w) state[2, 0] = dyn.position(self.states[i - 1][0][2], self.states[i - 1][1][2], self.states[i - 1][2][2], dyn.w) else: # not using accelerometer values # Gyroscope state[0, 3] = sample[0, 1] state[1, 3] = sample[1, 1] state[2, 3] = sample[2, 1] # rotate old pos about prev sensor old position last_pos = self.states[self.state_loc][4] p = dyn.orbit(np.asarray(last_pos), np.asarray(prev_sens_pos), self.currentQ) state[:, 4] = p # state[0,0] = p[0] # state[0,1] = p[1] # state[0,2] = p[2] # Velocity # i = self.state_loc # state[0,1] = dyn.speed(self.states[i-1][1][0], self.states[i-1][2][0], dyn.w) #speed(v0 a t) # state[1,1] = dyn.speed(self.states[i-1][1][1], self.states[i-1][2][1], dyn.w) # state[2,1] = dyn.speed(self.states[i-1][1][2], self.states[i-1][2][2], dyn.w) # # Position # state[0,0] = dyn.position(self.states[i-1][0][0], self.states[i-1][1][0], self.states[i-1][2][0], dyn.w) #position(s0,v0,a,t) # state[1,0] = dyn.position(self.states[i-1][0][1], self.states[i-1][1][1], self.states[i-1][2][1], dyn.w) # state[2,0] = dyn.position(self.states[i-1][0][2], self.states[i-1][1][2], self.states[i-1][2][2], dyn.w) return state.T
def testQuickFitness2DemandGame(self): """Test QuickFitness with the 'demand game'""" fitness = Dynamics._QuickFitness2(self.pop1, self.DemandGame) self.failUnless(fitness[2] > fitness[1] and fitness[2] >= fitness[0])
import Dynamics import Trajectory import MinimumTime import Shortcutting set_printoptions(precision=5) ################# Loading the environment ######################## env = Environment() # create openrave environment env.SetViewer('qtcoin') # attach viewer (optional) env.Load('/home/cuong/Dropbox/Code/mintime/robots/twodof.robot.xml') #env.Load('/home/cuong/Dropbox/Code/mintime/robots/arm.robot.xml') #env.Load('robots/wam4.robot.xml') robot = env.GetRobots()[0] env.GetPhysicsEngine().SetGravity([0, 0, 0]) params = Dynamics.GetParams(robot) robot.SetDOFValues(zeros(robot.GetDOF())) robot.SetDOFVelocities(zeros(robot.GetDOF())) robot.SetDOFValues(zeros(robot.GetDOF())) m = robot.GetLinks()[1].GetMass() #mass of the links l = robot.GetLinks()[1].GetGlobalCOM()[0] * 2 #length of the links coef = 1 / 2. * m * l * l theta1 = 0 theta2 = 1.1 ctheta2 = cos(theta2) robot.SetDOFValues([theta1, theta2]) M_ref = coef * array([[2 * (5 / 3. + ctheta2), 2 / 3. + ctheta2], [2 / 3. + ctheta2, 2 / 3.]])
def get_update(self, i): start = time.time() self.t += self.t_step # Calculate Actions and Forces from Controller self.PhiC_last, Actions = C2D.control(self.PhiC_last, self.State, self.State_d, self.Gains, self.Params, self.t_step) # Use Dynamics to Simulate New State [Transform Axes, Estimate Derivatives self.State = DYN.dynamics(self.State, self.Params, Actions, self.t_step) ## Calculation time for above measured at around 0.5 milliseconds on average # Update Plot self.t_vec.append(self.t) self.y_vec.append(self.State[0]) self.z_vec.append(self.State[1]) self.y_des_vec.append(self.State_d[0]) self.z_des_vec.append(self.State_d[1]) end = time.time() theta = self.State[4] attitude2D = np.array( ((math.cos(theta), -1 * math.sin(theta)), (math.sin(theta), math.cos(theta)))) self.body = attitude2D.dot(self.base_body.T) self.body = self.body + np.array([[self.State[0]], [self.State[1]]]) base = self.body[:, 0] top = self.body[:, 1] wingL = self.body[:, 2] wingR = self.body[:, 3] self.head.set_data([base[0], top[0]], [base[1], top[1]]) self.wing.set_data([wingL[0], wingR[0]], [wingL[1], wingR[1]]) print("simulation time") print(end - start) self.line_actual.set_data(self.y_vec, self.z_vec) if self.t > 20: self.terminate() return self.line_actual, self.head, self.wing
# control_history = np.empty([0, 1]) # time_init = time.time() # for i in range(config.NP_TOTAL): # state, control = solver.mpc_solver(x, 60) # x = state[1] # u = control[0] # state_history = np.append(state_history, x) # control_history = np.append(control_history, u) # x = x.tolist() # print("steps:{:3d}".format(i) + " | state: " + str(x)) # print("MPC calculating time: {:.3f}".format(time.time() - time_init) + "s") # state_history = state_history.reshape(-1,config.DYNAMICS_DIM) # # np.savetxt(os.path.join(log_dir, 'structured_MPC_state.txt'), state_history) # # np.savetxt(os.path.join(log_dir, 'structured_MPC_control.txt'), control_history) statemodel_plt = Dynamics.VehicleDynamics() if config.tire_model == 'Fiala': state = torch.tensor([[1.0, 0.0, config.psi_init, 0.0, config.u, 0.0]]) else: state = torch.tensor([[0.0, 0.0, config.psi_init, 0.0, 0.0]]) state.requires_grad_(False) x_ref = statemodel_plt.reference_trajectory(state[:, -1]) state_r = state.detach().clone() state_r[:, 0:4] = state_r[:, 0:4] - x_ref state_history = state.detach().numpy() x = np.array([0.]) plot_length = 300 control_history = [] state_r_history = state_r cal_time = 0 plt.figure()
def plot_comparison(simu_dir, methods): ''' Plot comparison figure among ADP, MPC & open-loop solution. Trajectory, tracking error and control signal plot Parameters ---------- picture_dir: string location of figure saved. ''' num_methods = len(methods) picture_dir = simu_dir + "/Figures" config = DynamicsConfig() trajectory_data = [] dy = Dynamics.VehicleDynamics() if os.path.exists(os.path.join(simu_dir, 'structured_MPC_state.txt')) == 0: print('No comparison state data!') else: if 'MPC' in methods: mpc_state = np.loadtxt( os.path.join(simu_dir, 'structured_MPC_state.txt')) mpc_trajectory = (mpc_state[:, 4], mpc_state[:, 0]) trajectory_data.append(mpc_trajectory) if 'ADP' in methods: adp_state = np.loadtxt(os.path.join(simu_dir, 'ADP_state.txt')) adp_trajectory = (adp_state[:, 4], adp_state[:, 0]) trajectory_data.append(adp_trajectory) if 'OP' in methods: open_loop_state = np.loadtxt( os.path.join(simu_dir, 'Open_loop_state.txt')) open_loop_trajectory = (open_loop_state[:, 4], open_loop_state[:, 0]) trajectory_data.append(open_loop_trajectory) myplot(trajectory_data, num_methods, "xy", fname=os.path.join(picture_dir, 'trajectory.png'), xlabel="longitudinal position [m]", ylabel="Lateral position [m]", legend=methods, legend_loc="lower left") heading_angle = [] if 'MPC' in methods: mpc_state = np.loadtxt( os.path.join(simu_dir, 'structured_MPC_state.txt')) mpc_trajectory = (mpc_state[:, 4], 180 / np.pi * mpc_state[:, 2]) heading_angle.append(mpc_trajectory) if 'ADP' in methods: adp_state = np.loadtxt(os.path.join(simu_dir, 'ADP_state.txt')) adp_trajectory = (adp_state[:, 4], 180 / np.pi * adp_state[:, 2]) heading_angle.append(adp_trajectory) if 'OP' in methods: open_loop_state = np.loadtxt( os.path.join(simu_dir, 'Open_loop_state.txt')) open_loop_trajectory = (open_loop_state[:, 4], open_loop_state[:, 2]) heading_angle.append(open_loop_trajectory) myplot(heading_angle, num_methods, "xy", fname=os.path.join(picture_dir, 'trajectory_heading_angle.png'), xlabel="longitudinal position [m]", ylabel="Heading angle [degree]", legend=methods, legend_loc="lower left") error_data = [] print('\nMAX TRACKING ERROR:') print(' MAX LATERAL POSITION ERROR:') if 'MPC' in methods: mpc_ref = dy.reference_trajectory( Numpy2Torch(mpc_state[:, 4], mpc_state[:, 4].shape)).numpy() mpc_error = (mpc_state[:, 4], mpc_state[:, 0] - mpc_ref[:, 0]) print(' Max MPC lateral error: {:0.3E}m'.format( float(max(abs(mpc_state[:, 0] - mpc_ref[:, 0]))))) error_data.append(mpc_error) if 'ADP' in methods: adp_ref = dy.reference_trajectory( Numpy2Torch(adp_state[:, 4], adp_state[:, 4].shape)).numpy() adp_error = (adp_state[:, 4], adp_state[:, 0] - adp_ref[:, 0]) print(' Max ADP lateral error: {:0.3E}m'.format( float(max(abs(adp_state[:, 0] - adp_ref[:, 0]))))) error_data.append(adp_error) if 'OP' in methods: open_loop_error = (open_loop_state[:, 4], open_loop_state[:, 0] - config.a_curve * np.sin(config.k_curve * open_loop_state[:, 4])) error_data.append(open_loop_error) myplot(error_data, num_methods, "xy", fname=os.path.join(picture_dir, 'trajectory_error.png'), xlabel="longitudinal position error [m]", ylabel="Lateral position [m]", legend=methods, legend_loc="upper left") # mpc_error = (mpc_state[:, 4], mpc_state[:, 0] - config.a_curve * np.sin(config.k_curve * mpc_state[:, 4])) # open_loop_error = (open_loop_state[:, 4], open_loop_state[:, 0] - config.a_curve * np.sin(config.k_curve * open_loop_state[:, 4])) # adp_error = (adp_state[:, 4], 1 * (adp_state[:, 0] - config.a_curve * np.sin(config.k_curve * adp_state[:, 4]))) # TODO: safe delete #error_data = [mpc_error, adp_error, open_loop_error] # myplot(error_data, 3, "xy", # fname=os.path.join(picture_dir,'trajectory_error.png'), # xlabel="longitudinal position [m]", # ylabel="Lateral position error [m]", # legend=["MPC", "ADP", "Open-loop"], # legend_loc="lower left" # ) psi_error_data = [] print(' MAX YAW ANGLE ERROR:') if 'MPC' in methods: mpc_psi_error = (mpc_state[:, 4], 180 / np.pi * (mpc_state[:, 2] - mpc_ref[:, 2])) print(' MPC: {:0.3E} degree'.format( float(max(abs(180 / np.pi * (mpc_state[:, 2] - mpc_ref[:, 2])))))) psi_error_data.append(mpc_psi_error) if 'ADP' in methods: adp_psi_error = (adp_state[:, 4], 180 / np.pi * (adp_state[:, 2] - adp_ref[:, 2])) print(' ADP: {:0.3E} degree'.format( float(max(abs(180 / np.pi * (adp_state[:, 2] - adp_ref[:, 2])))))) psi_error_data.append(adp_psi_error) if 'OP' in methods: open_loop_psi_error = ( open_loop_state[:, 4], 180 / np.pi * (open_loop_state[:, 2] - np.arctan(config.a_curve * config.k_curve * np.cos(config.k_curve * open_loop_state[:, 4])))) psi_error_data.append(open_loop_psi_error) myplot(psi_error_data, num_methods, "xy", fname=os.path.join(picture_dir, 'head_angle_error.png'), xlabel="longitudinal position [m]", ylabel="head angle error [degree]", legend=["MPC", "ADP", "Open-loop"], legend_loc="lower left") control_plot_data = [] if 'MPC' in methods: mpc_control = np.loadtxt( os.path.join(simu_dir, 'structured_MPC_control.txt')) mpc_control_tuple = (mpc_state[1:, 4], 180 / np.pi * mpc_control) control_plot_data.append(mpc_control_tuple) if 'ADP' in methods: adp_control = np.loadtxt(os.path.join(simu_dir, 'ADP_control.txt')) adp_control_tuple = (adp_state[1:, 4], 180 / np.pi * adp_control) control_plot_data.append(adp_control_tuple) if 'OP' in methods: open_loop_control = np.loadtxt( os.path.join(simu_dir, 'Open_loop_control.txt')) open_loop_control_tuple = (open_loop_state[1:, 4], 180 / np.pi * open_loop_control) control_plot_data.append(open_loop_control_tuple) myplot(control_plot_data, 3, "xy", fname=os.path.join(picture_dir, 'control.png'), xlabel="longitudinal position [m]", ylabel="steering angle [degree]", legend=["MPC", "ADP", "Open-loop"], legend_loc="upper left") if 'OP' in methods: y_avs_error = [] for [i, d] in enumerate(error_data): y_avs_error.append(np.mean(np.abs(d[1]))) print("Tracking error of lateral position:") print("MPC:{:.3e} | ".format(y_avs_error[0]) + "ADP:{:.3e} | ".format(y_avs_error[1]) + "Open-loop:{:.3e} | ".format(y_avs_error[2])) psi_avs_error = [] for [i, d] in enumerate(psi_error_data): psi_avs_error.append(np.mean(np.abs(d[1]))) print("Tracking error of heading angle:") print("MPC:{:.3e} | ".format(psi_avs_error[0]) + "ADP:{:.3e} | ".format(psi_avs_error[1]) + "Open-loop:{:.3e} | ".format(psi_avs_error[2])) mpc_control_error = mpc_control - open_loop_control adp_control_error = adp_control - open_loop_control print("Control error:") print("MPC:{:.3e} | ".format(np.mean(np.abs(mpc_control_error))) + "ADP:{:.3e} | ".format(np.mean(np.abs(adp_control_error))))
def enforceConstraints(self, configuration=None, velocities=None): """Enforces the previously defined distance constraints by modifying the configuration and velocities.""" import Dynamics Dynamics.enforceConstraints(self, configuration) self.adjustVelocitiesToConstraints(velocities)
def simulation(methods, log_dir, simu_dir): policy = Actor(S_DIM, A_DIM) value = Critic(S_DIM, A_DIM) config = DynamicsConfig() solver = Solver() load_dir = log_dir policy.load_parameters(load_dir) value.load_parameters(load_dir) statemodel_plt = Dynamics.VehicleDynamics() plot_length = config.SIMULATION_STEPS # initial_state = torch.tensor([[0.5, 0.0, config.psi_init, 0.0, 0.0]]) # baseline = Baseline(initial_state, simu_dir) # baseline.mpcSolution() # baseline.openLoopSolution() # Open-loop reference x_init = [0.0, 0.0, config.psi_init, 0.0, 0.0] op_state, op_control = solver.openLoopMpcSolver(x_init, config.NP_TOTAL) np.savetxt(os.path.join(simu_dir, 'Open_loop_control.txt'), op_control) for method in methods: cal_time = 0 state = torch.tensor([[0.0, 0.0, config.psi_init, 0.0, 0.0]]) # state = torch.tensor([[0.0, 0.0, 0.0, 0.0, 0.0]]) state.requires_grad_(False) # x_ref = statemodel_plt.reference_trajectory(state[:, -1]) x_ref = statemodel_plt.reference_trajectory(state[:, -1]) state_r = state.detach().clone() state_r[:, 0:4] = state_r[:, 0:4] - x_ref state_history = state.detach().numpy() control_history = [] print('\nCALCULATION TIME:') for i in range(plot_length): if method == 'ADP': time_start = time.time() u = policy.forward(state_r[:, 0:4]) cal_time += time.time() - time_start elif method == 'MPC': x = state_r.tolist()[0] time_start = time.time() _, control = solver.mpcSolver(x, config.NP) # todo:retreve cal_time += time.time() - time_start u = np.array(control[0], dtype='float32').reshape(-1, config.ACTION_DIM) u = torch.from_numpy(u) else: u = np.array(op_control[i], dtype='float32').reshape(-1, config.ACTION_DIM) u = torch.from_numpy(u) state, state_r = step_relative(statemodel_plt, state, u) # state_next, deri_state, utility, F_y1, F_y2, alpha_1, alpha_2 = statemodel_plt.step(state, u) # state_r_old, _, _, _, _, _, _ = statemodel_plt.step(state_r, u) # state_r = state_r_old.detach().clone() # state_r[:, [0, 2]] = state_next[:, [0, 2]] # x_ref = statemodel_plt.reference_trajectory(state_next[:, -1]) # state_r[:, 0:4] = state_r[:, 0:4] - x_ref # state = state_next.clone().detach() # s = state_next.detach().numpy() state_history = np.append(state_history, state.detach().numpy(), axis=0) control_history = np.append(control_history, u.detach().numpy()) if method == 'ADP': print(" ADP: {:.3f}".format(cal_time) + "s") np.savetxt(os.path.join(simu_dir, 'ADP_state.txt'), state_history) np.savetxt(os.path.join(simu_dir, 'ADP_control.txt'), control_history) elif method == 'MPC': print(" MPC: {:.3f}".format(cal_time) + "s") np.savetxt(os.path.join(simu_dir, 'structured_MPC_state.txt'), state_history) np.savetxt(os.path.join(simu_dir, 'structured_MPC_control.txt'), control_history) else: np.savetxt(os.path.join(simu_dir, 'Open_loop_state.txt'), state_history) adp_simulation_plot(simu_dir) plot_comparison(simu_dir, methods)
LR_V = 3e-3 # learning rate of value net # tasks TRAIN_FLAG = 1 LOAD_PARA_FLAG = 0 SIMULATION_FLAG = 1 # Set random seed np.random.seed(0) torch.manual_seed(0) # initialize policy and value net, model of vehicle dynamics config = GeneralConfig() policy = Actor(config.STATE_DIM, config.ACTION_DIM, lr=LR_P) value = Critic(config.STATE_DIM, 1, lr=LR_V) vehicleDynamics = Dynamics.VehicleDynamics() state_batch = vehicleDynamics.initialize_state() writer = SummaryWriter() # Training iteration_index = 0 if LOAD_PARA_FLAG == 1: print( "********************************* LOAD PARAMETERS *********************************" ) # load pre-trained parameters load_dir = "./Results_dir/2020-10-09-14-42-10000" policy.load_parameters(load_dir) value.load_parameters(load_dir) if TRAIN_FLAG == 1:
parser.add_argument("-c", "--conffile", type=str, default="plane_periodic.conf", help="configuration file") parser.add_argument("-d", "--directory", type=str, default="/home/sh18581/Documents/Dome/samos_check/periodic_test/data_phi_1/data_v0_0.01/data_nu_0.01/",help="input directory") parser.add_argument("-s", "--skip", type=int, default=300, help="skip this many samples") parser.add_argument("-m", "--howmany", type=int, default=500, help="read this many samples") parser.add_argument("-t", "--step", type=int, default=20, help="step snapshots with this spacing") parser.add_argument("-o", "--outfile", type=str, default="correlations.p", help="pickle file name") args = parser.parse_args() # Choose to show as plots as well: plotall = True # Use the Configuration constructor in its readCSV format to generate the topology # fromCSV(kwargs["parampath"],kwargs["datapath"],kwargs["multiopt"]) parampath0 = args.directory + args.conffile param = Param(parampath0) Cells = Dynamics(initype="fromCSV",param=param,datapath=args.directory,multiopt="many") # Now read in as desired # def readDataMany(self,skip=0,step=1,howmany='all',Nvariable=False,readtypes = 'all'): Cells.readDataMany("SAMoS",args.skip,1,args.howmany,False,readtypes = 'all') Cells.validate_initialise() # Start collecting all of this in data dictionary data={'configuration':args.directory,'skip':args.skip,'howmany':args.howmany,'step':args.step} # 1st basic set of analyses # Will save as pickle file regardless # A - Velocity distributions and mean velocity # vav, vdist,vdist2 = getVelDist(self,bins,bins2,usetype='all',verbose=True): # Bins are in normalised units (by mean velocity)
def main(): ctrl = Controller() dyn = Dynamics()
class VideoStreamHandler(socketserver.StreamRequestHandler): command = Dynamics() identify_features = features() print("Video Server Active") def handle(self): global command global distance global previous_distance stream_bytes = b'' AEB = 0 try: while True: stream_bytes += self.rfile.read(1024) first = stream_bytes.find(b'\xff\xd8') last = stream_bytes.find(b'\xff\xd9') if first != -1 and last != -1: jpg = stream_bytes[first:last + 2] stream_bytes = stream_bytes[last + 2:] #read images in stream img = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR) #Perspective Transform src = np.float32([[00, 100], [320, 100], [-10, 150], [330, 150]]) dst = np.float32([[0, 0], [320, 0], [0, 240], [320, 240]]) M = cv2.getPerspectiveTransform(src, dst) image = cv2.warpPerspective(img, M, (320, 240)) #Image Processing -Identify Features img, image, stop, average_heading, sigFlag, carFlag = self.identify_features.haar( img, image) #Display Processed Images and views cv2.imshow('Feild Of View', img) cv2.imshow('Birds Eye', image) #img #HC-SR04 distance data a = (previous_distance + distance) / 2 b = previous_distance - distance if distance < 25: #Object under threshold distance AEB = 1 #Emergency Brakes Flag else: AEB = 0 if cv2.waitKey(3) & 0xFF == ord('q'): break if sigFlag == 0: # Signal is Green #Set Lane Departure limits if ((average_heading < 150) and (stop == 0)) and AEB == 0: print("Turn left") self.command.fleft() elif ((average_heading > 170) and (stop == 0)) and AEB == 0: print("Turn right") self.command.fright() elif ((170 >= average_heading >= 150) and (stop == 0)) and AEB == 0: print("In lane") self.command.forward() elif stop == 1: print("BRAKES ACTIVE due to Stop sign") self.command.brake() elif AEB == 1: self.command.brake() if carFlag == 1: #If car spotted print("Car Ahead at " + str(distance) + " cm") else: print( "Obstacle Ahead!, Emergency Brakes Active") else: pass elif sigFlag == 1: # Signal is Red pass print("Signal Red, waiting to turn Green...") self.command.brake() finally: cv2.destroyAllWindows() self.command.halt() self.command.closeconn() sys.exit()
import sys import cStringIO set_printoptions(precision=5) save_stdout = sys.stdout ################# Loading the environment ######################## env = Environment() # create openrave environment env.SetViewer('qtcoin') # attach viewer (optional) env.Load('/home/cuong/Dropbox/Code/mintime/robots/twodof.robot.xml') robot=env.GetRobots()[0] params=Dynamics.GetParams(robot) grav=[0,9.8,0] ################# Initialize a trajectory ######################## P0=poly1d([-2.1]) P1=poly1d([1,-2.7]) pwp_traj=Trajectory.PieceWisePolyTrajectory([[P0,P1]],[1]) T=1 n_discr=100. t_step=T/n_discr a=time.clock()