diff --git a/coordination/task_assignment/ACO_1.png b/coordination/task_assignment/ACO_1.png
deleted file mode 100644
index a9bb77b..0000000
Binary files a/coordination/task_assignment/ACO_1.png and /dev/null differ
diff --git a/coordination/task_assignment/ACO_2.png b/coordination/task_assignment/ACO_2.png
deleted file mode 100644
index 32b2e35..0000000
Binary files a/coordination/task_assignment/ACO_2.png and /dev/null differ
diff --git a/coordination/task_assignment/GA_1.png b/coordination/task_assignment/GA_1.png
deleted file mode 100644
index a946ba1..0000000
Binary files a/coordination/task_assignment/GA_1.png and /dev/null differ
diff --git a/coordination/task_assignment/GA_2.png b/coordination/task_assignment/GA_2.png
deleted file mode 100644
index d5bc58f..0000000
Binary files a/coordination/task_assignment/GA_2.png and /dev/null differ
diff --git a/coordination/task_assignment/GA_3.png b/coordination/task_assignment/GA_3.png
deleted file mode 100644
index 7ad3c55..0000000
Binary files a/coordination/task_assignment/GA_3.png and /dev/null differ
diff --git a/coordination/task_assignment/PSO_1.png b/coordination/task_assignment/PSO_1.png
deleted file mode 100644
index 64bb707..0000000
Binary files a/coordination/task_assignment/PSO_1.png and /dev/null differ
diff --git a/coordination/task_assignment/PSO_2.png b/coordination/task_assignment/PSO_2.png
deleted file mode 100644
index bde6ee9..0000000
Binary files a/coordination/task_assignment/PSO_2.png and /dev/null differ
diff --git a/coordination/task_assignment/PSO_3.png b/coordination/task_assignment/PSO_3.png
deleted file mode 100644
index 76f8045..0000000
Binary files a/coordination/task_assignment/PSO_3.png and /dev/null differ
diff --git a/coordination/task_assignment/aco.py b/coordination/task_assignment/aco.py
deleted file mode 100644
index 1a07d62..0000000
--- a/coordination/task_assignment/aco.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import random
-import numpy as np
-import math
-import time
-import os
-
-class ACO():
-    def __init__(self, vehicle_num, target_num,vehicle_speed, target, time_lim):
-        self.num_type_ant = vehicle_num
-        self.num_city = target_num+1 #number of cities
-        self.group = 200
-        self.num_ant = self.group*self.num_type_ant #number of ants
-        self.ant_vel = vehicle_speed
-        self.cut_time = time_lim
-        self.oneee = np.zeros((4,1))
-        self.target = target
-        self.alpha = 1 #pheromone 
-        self.beta = 2  #qiwangyinzi
-        self.k1 = 0.03
-        self.iter_max = 150
-#matrix of the distances between cities 
-    def distance_matrix(self):
-        dis_mat = []
-        for i in range(self.num_city):
-            dis_mat_each = []
-            for j in range(self.num_city):
-                dis = math.sqrt(pow(self.target[i][0]-self.target[j][0],2)+pow(self.target[i][1]-self.target[j][1],2))
-                dis_mat_each.append(dis)
-            dis_mat.append(dis_mat_each)
-        return dis_mat
-    def run(self):
-        print("ACO start, pid: %s" % os.getpid())
-        start_time = time.time()
-        #distances of nodes
-        dis_list = self.distance_matrix()
-        dis_mat = np.array(dis_list)
-        value_init = self.target[:,2].transpose()
-        delay_init = self.target[:,3].transpose()        
-        pheromone_mat = np.ones((self.num_type_ant,self.num_city))
-        #velocity of ants
-        path_new = [[0]for i in range (self.num_type_ant)]
-        count_iter = 0
-        while count_iter < self.iter_max:
-            path_sum = np.zeros((self.num_ant,1))
-            time_sum = np.zeros((self.num_ant,1))
-            value_sum = np.zeros((self.num_ant,1))
-            path_mat=[[0]for i in range (self.num_ant)]
-            value = np.zeros((self.group,1))
-            atten = np.ones((self.num_type_ant,1)) * 0.2
-            for ant in range(self.num_ant):
-                ant_type = ant % self.num_type_ant
-                visit = 0
-                if ant_type == 0:
-                    unvisit_list=list(range(1,self.num_city))#have not visit
-                for j in range(1,self.num_city):
-            #choice of next city
-                    trans_list=[]
-                    tran_sum=0
-                    trans=0
-                    #if len(unvisit_list)==0:
-                        #print('len(unvisit_list)==0')
-                    for k in range(len(unvisit_list)):  # to decide which node to visit
-                #trans +=np.power(pheromone_mat[ant_type][visit][unvisit_list[k]],alpha)*np.power(k1*value_mat[visit][unvisit_list[k]],beta)
-                        trans +=np.power(pheromone_mat[ant_type][unvisit_list[k]],self.alpha)*np.power(0.05*value_init[unvisit_list[k]],self.beta)
-                        trans_list.append(trans)
-                    tran_sum = trans        
-                    rand = random.uniform(0,tran_sum)
-                    for t in range(len(trans_list)):
-                        if(rand <= trans_list[t]):
-                            visit_next = unvisit_list[t]
-                            break
-                        else:        
-                            continue
-                    path_mat[ant].append(visit_next)
-                    path_sum[ant] += dis_mat[path_mat[ant][j-1]][path_mat[ant][j]]
-                    time_sum[ant] += path_sum[ant] / self.ant_vel[ant_type] + delay_init[visit_next]
-                    if time_sum[ant] > self.cut_time:
-                        time_sum[ant]-=path_sum[ant] / self.ant_vel[ant_type] + delay_init[visit_next]                      
-                        path_mat[ant].pop()                
-                        break
-                    value_sum[ant] += value_init[visit_next]
-                    unvisit_list.remove(visit_next)#update
-                    visit = visit_next
-                if (ant_type) == self.num_type_ant-1:
-                    small_group = int(ant/self.num_type_ant)
-                    for k in range (self.num_type_ant):
-                        value[small_group]+= value_sum[ant-k]
-            #iteration
-
-            #print(max(value)) 
-            if count_iter == 0:
-                value_new = max(value)
-                value = value.tolist()
-                for k in range (0,self.num_type_ant):
-                    path_new[k] = path_mat[value.index(value_new)*self.num_type_ant+k]
-                    path_new[k].remove(0)
-                    #time[k] = time_sum[value.index(value_new)*self.num_type_ant+k]
-            else:
-                if max(value) > value_new:
-                    value_new = max(value)
-                    value = value.tolist()
-                    for k in range (0,self.num_type_ant):
-                        path_new[k] = path_mat[value.index(value_new)*self.num_type_ant+k]
-                        path_new[k].remove(0)
-                        #time[k] = time_sum[value.index(value_new)*self.num_type_ant+k]
-
-            #update pheromone
-            pheromone_change = np.zeros((self.num_type_ant,self.num_city))
-            for i in range(self.num_ant):
-                length = len(path_mat[i])
-                m = i%self.num_type_ant
-                n = int(i/self.num_type_ant)
-                for j in range(length-1):   
-                     #a=value_sum[i]/(np.power((value[n]-value_new),2)+1)
-                    pheromone_change[m][path_mat[i][j+1]]+= self.k1*value_init[path_mat[i][j+1]]
-                atten[m] += (value_sum[i]/(np.power((value_new-value[n]),4)+1))/self.group
-            #print(atten[m])
-            for k in range (self.num_type_ant):
-                #print('pheromone_change[m]:',pheromone_change[m])
-                pheromone_mat[k]=(1-atten[k])*pheromone_mat[k]+pheromone_change[k]
-            count_iter += 1
-            
-            #print('count_iter:',count_iter)
-        
-            #print('the largest value?',value_new)
-
-            #print('the best road?',path_new)
-        print("ACO result:", path_new)
-        #self.task_assignment = task_assignment
-        end_time = time.time()
-        #self.cal_time = end_time - start_time
-        print("ACO time:", end_time - start_time)
-        return path_new, end_time - start_time
-
-
-
diff --git a/coordination/task_assignment/customized.csv b/coordination/task_assignment/customized.csv
deleted file mode 100644
index a1ca870..0000000
--- a/coordination/task_assignment/customized.csv
+++ /dev/null
@@ -1,101 +0,0 @@
-,time,reward
-0,3.337860107421875e-06,0
-1,2.86102294921875e-06,0
-2,2.86102294921875e-06,0
-3,2.6226043701171875e-06,0
-4,2.6226043701171875e-06,0
-5,2.384185791015625e-06,0
-6,2.1457672119140625e-06,0
-7,2.1457672119140625e-06,0
-8,2.1457672119140625e-06,0
-9,2.1457672119140625e-06,0
-10,2.384185791015625e-06,0
-11,2.1457672119140625e-06,0
-12,2.384185791015625e-06,0
-13,2.6226043701171875e-06,0
-14,2.384185791015625e-06,0
-15,2.384185791015625e-06,0
-16,2.384185791015625e-06,0
-17,2.384185791015625e-06,0
-18,2.1457672119140625e-06,0
-19,2.6226043701171875e-06,0
-20,2.1457672119140625e-06,0
-21,2.1457672119140625e-06,0
-22,1.9073486328125e-06,0
-23,2.1457672119140625e-06,0
-24,2.384185791015625e-06,0
-25,2.384185791015625e-06,0
-26,1.9073486328125e-06,0
-27,1.9073486328125e-06,0
-28,1.9073486328125e-06,0
-29,2.1457672119140625e-06,0
-30,2.384185791015625e-06,0
-31,2.384185791015625e-06,0
-32,2.384185791015625e-06,0
-33,2.1457672119140625e-06,0
-34,2.1457672119140625e-06,0
-35,2.384185791015625e-06,0
-36,2.1457672119140625e-06,0
-37,1.9073486328125e-06,0
-38,1.9073486328125e-06,0
-39,2.1457672119140625e-06,0
-40,1.9073486328125e-06,0
-41,2.1457672119140625e-06,0
-42,2.1457672119140625e-06,0
-43,1.9073486328125e-06,0
-44,2.1457672119140625e-06,0
-45,2.384185791015625e-06,0
-46,1.9073486328125e-06,0
-47,1.9073486328125e-06,0
-48,2.1457672119140625e-06,0
-49,2.384185791015625e-06,0
-50,1.9073486328125e-06,0
-51,1.9073486328125e-06,0
-52,1.9073486328125e-06,0
-53,1.9073486328125e-06,0
-54,2.384185791015625e-06,0
-55,2.1457672119140625e-06,0
-56,2.1457672119140625e-06,0
-57,2.384185791015625e-06,0
-58,2.384185791015625e-06,0
-59,2.1457672119140625e-06,0
-60,2.1457672119140625e-06,0
-61,2.1457672119140625e-06,0
-62,2.384185791015625e-06,0
-63,2.1457672119140625e-06,0
-64,1.9073486328125e-06,0
-65,2.1457672119140625e-06,0
-66,1.9073486328125e-06,0
-67,2.1457672119140625e-06,0
-68,2.1457672119140625e-06,0
-69,2.1457672119140625e-06,0
-70,2.1457672119140625e-06,0
-71,2.1457672119140625e-06,0
-72,2.384185791015625e-06,0
-73,2.1457672119140625e-06,0
-74,2.1457672119140625e-06,0
-75,2.1457672119140625e-06,0
-76,2.1457672119140625e-06,0
-77,1.9073486328125e-06,0
-78,2.1457672119140625e-06,0
-79,2.1457672119140625e-06,0
-80,2.1457672119140625e-06,0
-81,2.1457672119140625e-06,0
-82,2.384185791015625e-06,0
-83,2.1457672119140625e-06,0
-84,2.1457672119140625e-06,0
-85,1.9073486328125e-06,0
-86,2.1457672119140625e-06,0
-87,2.1457672119140625e-06,0
-88,2.1457672119140625e-06,0
-89,1.9073486328125e-06,0
-90,2.384185791015625e-06,0
-91,2.1457672119140625e-06,0
-92,2.384185791015625e-06,0
-93,2.384185791015625e-06,0
-94,2.384185791015625e-06,0
-95,2.384185791015625e-06,0
-96,2.384185791015625e-06,0
-97,2.384185791015625e-06,0
-98,1.9073486328125e-06,0
-99,2.1457672119140625e-06,0
diff --git a/coordination/task_assignment/environment.py b/coordination/task_assignment/environment.py
deleted file mode 100644
index 6846356..0000000
--- a/coordination/task_assignment/environment.py
+++ /dev/null
@@ -1,209 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-import random
-import time
-import pandas as pd
-import copy
-from multiprocessing import Pool
-from ga import GA
-from aco import ACO
-from pso import PSO
-
-class Env():
-    def __init__(self, vehicle_num, target_num, map_size, visualized=True, time_cost=None, repeat_cost=None):
-        self.vehicles_position = np.zeros(vehicle_num,dtype=np.int32)
-        self.vehicles_speed = np.zeros(vehicle_num,dtype=np.int32)
-        self.targets = np.zeros(shape=(target_num+1,4),dtype=np.int32)
-        self.map_size = map_size
-        self.speed_range = [10, 15, 30]
-        #self.time_lim = 1e6
-        self.time_lim = self.map_size / self.speed_range[1]
-        self.vehicles_lefttime = np.ones(vehicle_num,dtype=np.float32) * self.time_lim
-        self.distant_mat = np.zeros((target_num+1,target_num+1),dtype=np.float32)
-        self.total_reward = 0
-        self.reward = 0
-        self.visualized = visualized
-        self.time = 0
-        self.time_cost = time_cost
-        self.repeat_cost = repeat_cost
-        self.end = False
-        self.assignment = [[] for i in range(vehicle_num)]
-        self.task_generator()
-        
-    def task_generator(self):
-        for i in range(self.vehicles_speed.shape[0]):
-            choose = random.randint(0,2)
-            self.vehicles_speed[i] = self.speed_range[choose]
-        for i in range(self.targets.shape[0]-1):
-            self.targets[i+1,0] = random.randint(1,self.map_size) - 0.5*self.map_size # x position
-            self.targets[i+1,1] = random.randint(1,self.map_size) - 0.5*self.map_size # y position
-            self.targets[i+1,2] = random.randint(1,10) # value
-            self.targets[i+1,3] = random.randint(5,30) # time to stay  
-        for i in range(self.targets.shape[0]):
-            for j in range(self.targets.shape[0]):
-                self.distant_mat[i,j] = np.linalg.norm(self.targets[i,:2]-self.targets[j,:2])
-        self.targets_value = copy.deepcopy((self.targets[:,2]))
-        
-    def step(self, action):
-        count = 0
-        for j in range(len(action)):
-            k = action[j]
-            delta_time = self.distant_mat[self.vehicles_position[j],k] / self.vehicles_speed[j] + self.targets[k,3]
-            self.vehicles_lefttime[j] = self.vehicles_lefttime[j] - delta_time
-            if self.vehicles_lefttime[j] < 0:
-                count = count + 1
-                continue
-            else:
-                if k == 0:
-                    self.reward = - self.repeat_cost
-                else:
-                    self.reward = self.targets[k,2] - delta_time * self.time_cost + self.targets[k,2]
-                    if self.targets[k,2] == 0:
-                        self.reward = self.reward - self.repeat_cost
-                    self.vehicles_position[j] = k
-                    self.targets[k,2] = 0
-                self.total_reward = self.total_reward + self.reward
-            self.assignment[j].append(action)
-        if count == len(action):
-            self.end = True
-        
-    def run(self, assignment, algorithm):
-        self.assignment = assignment
-        self.algorithm = algorithm
-        self.get_total_reward()
-        if self.visualized:
-            self.visualize()        
-            
-    def reset(self):
-        self.vehicles_position = np.zeros(self.vehicles_position.shape[0],dtype=np.int32)
-        self.vehicles_lefttime = np.ones(self.vehicles_position.shape[0],dtype=np.float32) * self.time_lim
-        self.targets[:,2] = self.targets_value
-        self.total_reward = 0
-        self.reward = 0
-        self.end = False
-        
-    def get_total_reward(self):
-        for i in range(len(self.assignment)):
-            speed = self.vehicles_speed[i]
-            for j in range(len(self.assignment[i])):
-                position = self.targets[self.assignment[i][j],:4]
-                self.total_reward = self.total_reward + position[2]
-                if j == 0:
-                    self.vehicles_lefttime[i] = self.vehicles_lefttime[i] - np.linalg.norm(position[:2]) / speed - position[3]
-                else:
-                    self.vehicles_lefttime[i] = self.vehicles_lefttime[i] - np.linalg.norm(position[:2]-position_last[:2]) / speed - position[3]
-                position_last = position
-                if self.vehicles_lefttime[i] > self.time_lim:
-                    self.end = True
-                    break
-            if self.end:
-                self.total_reward = 0
-                break
-            
-    def visualize(self):
-        if self.assignment == None:
-            plt.scatter(x=0,y=0,s=200,c='k')
-            plt.scatter(x=self.targets[1:,0],y=self.targets[1:,1],s=self.targets[1:,2]*10,c='r')
-            plt.title('Target distribution')
-            plt.show()
-        else:
-            plt.title('Task assignment by '+self.algorithm +', total reward : '+str(self.total_reward))     
-            plt.scatter(x=0,y=0,s=200,c='k')
-            plt.scatter(x=self.targets[1:,0],y=self.targets[1:,1],s=self.targets[1:,2]*10,c='r')
-            for i in range(len(self.assignment)):
-                trajectory = np.array([[0,0,20]])
-                for j in range(len(self.assignment[i])):
-                    position = self.targets[self.assignment[i][j],:3]
-                    trajectory = np.insert(trajectory,j+1,values=position,axis=0)  
-                plt.scatter(x=trajectory[1:,0],y=trajectory[1:,1],s=trajectory[1:,2]*10,c='b')
-                plt.plot(trajectory[:,0], trajectory[:,1]) 
-            plt.show() 
-            
-if __name__=='__main__':
-    # Test 1
-    p = Pool(2)
-    vehicle_num = 5
-    target_num = 30
-    map_size = 5e3
-    env = Env(vehicle_num,target_num,map_size,visualized=True)
-    ga = GA(vehicle_num,env.vehicles_speed,target_num,env.targets,env.time_lim)
-    aco = ACO(vehicle_num,target_num,env.vehicles_speed,env.targets,env.time_lim)
-    pso = PSO(vehicle_num,target_num ,env.targets,env.vehicles_speed,env.time_lim)
-    ga_result = p.apply_async(ga.run)
-    #aco_result = p.apply_async(aco.run)
-    pso_result = p.apply_async(pso.run)
-    p.close()
-    p.join()
-    ga_task_assignmet = ga_result.get()[0]
-    env.run(ga_task_assignmet,'GA')
-    #env.reset()
-    #aco_task_assignmet = aco_result.get()[0]
-    #env.run(aco_task_assignmet,'ACO')
-    env.reset()
-    pso_task_assignmet = pso_result.get()[0]
-    env.run(pso_task_assignmet,'PSO')
-
-    # Test 2
-    p = Pool(2)
-    vehicle_num = 10
-    target_num = 60
-    map_size = 1e4
-    env = Env(vehicle_num,target_num,map_size,visualized=True)
-    ga = GA(vehicle_num,env.vehicles_speed,target_num,env.targets,env.time_lim)
-    #aco = ACO(vehicle_num,target_num,env.vehicles_speed,env.targets,env.time_lim)
-    pso = PSO(vehicle_num,target_num ,env.targets,env.vehicles_speed,env.time_lim)
-    ga_result = p.apply_async(ga.run)
-    #aco_result = p.apply_async(aco.run)
-    pso_result = p.apply_async(pso.run)
-    p.close()
-    p.join()
-    ga_task_assignmet = ga_result.get()[0]
-    env.run(ga_task_assignmet,'GA')
-    #env.reset()
-    #aco_task_assignmet = ga_result.get()[0]
-    #env.run(aco_task_assignmet,'ACO')
-    env.reset()
-    pso_task_assignmet = pso_result.get()[0]
-    env.run(pso_task_assignmet,'PSO')
-        
-    # Test 3
-    p = Pool(2)
-    vehicle_num = 15
-    target_num = 90
-    map_size = 1.5e4
-    env = Env(vehicle_num,target_num,map_size,visualized=True)
-    ga = GA(vehicle_num,env.vehicles_speed,target_num,env.targets,env.time_lim)
-    #aco = ACO(vehicle_num,target_num,env.vehicles_speed,env.targets,env.time_lim)
-    pso = PSO(vehicle_num,target_num ,env.targets,env.vehicles_speed,env.time_lim)
-    ga_result = p.apply_async(ga.run)
-    #aco_result = p.apply_async(aco.run)
-    pso_result = p.apply_async(pso.run)
-    p.close()
-    p.join()
-    ga_task_assignmet = ga_result.get()[0]
-    env.run(ga_task_assignmet,'GA')
-    #env.reset()
-    #aco_task_assignmet = ga_result.get()[0]
-    #env.run(aco_task_assignmet,'ACO')
-    env.reset()
-    pso_task_assignmet = pso_result.get()[0]
-    env.run(pso_task_assignmet,'PSO')
-       
-    '''
-    time_record = []
-    reward_record = []
-    for i in range(100):
-        vehicle_num = random.randint(5,15)
-        target_num =  random.randint(30,100)
-        map_size = random.randint(5e3,2e4) # meter
-        env = Env(vehicle_num,target_num,map_size,visualized=True)
-        time_start = time.time()
-        task_assignment = [[i+1 for i in range(0,5)],[i+1 for i in range(5,20)],[i+1 for i in range(20,30)]]
-        time_end = time.time()
-        time_record.append(time_end-time_start) 
-        algorithm = 'customized'   
-        env.run(task_assignment,algorithm)
-        reward_record.append(env.total_reward)
-    dataframe = pd.DataFrame({'time':time_record,'reward':reward_record})
-    dataframe.to_csv(algorithm+'.csv',sep=',')
-    '''
\ No newline at end of file
diff --git a/coordination/task_assignment/ga.py b/coordination/task_assignment/ga.py
deleted file mode 100644
index 9ed5c73..0000000
--- a/coordination/task_assignment/ga.py
+++ /dev/null
@@ -1,179 +0,0 @@
-import numpy as np
-import random
-import time
-import os
-
-
-class GA():
-    def __init__(self, vehicle_num, vehicles_speed, target_num, targets, time_lim):
-        # vehicles_speed,targets in the type of narray
-        self.vehicle_num = vehicle_num
-        self.vehicles_speed = vehicles_speed
-        self.target_num = target_num
-        self.targets = targets
-        self.time_lim = time_lim
-        self.map = np.zeros(shape=(target_num+1, target_num+1), dtype=float)
-        self.pop_size = 50
-        self.p_cross = 0.6
-        self.p_mutate = 0.005
-        for i in range(target_num+1):
-            self.map[i, i] = 0
-            for j in range(i):
-                self.map[j, i] = self.map[i, j] = np.linalg.norm(
-                    targets[i, :2]-targets[j, :2])
-        self.pop = np.zeros(
-            shape=(self.pop_size, vehicle_num-1+target_num-1), dtype=np.int32)
-        self.ff = np.zeros(self.pop_size, dtype=float)
-        for i in range(self.pop_size):
-            for j in range(vehicle_num-1):
-                self.pop[i, j] = random.randint(0, target_num)
-            for j in range(target_num-1):
-                self.pop[i, vehicle_num+j -
-                         1] = random.randint(0, target_num-j-1)
-            self.ff[i] = self.fitness(self.pop[i, :])
-        self.tmp_pop = np.array([])
-        self.tmp_ff = np.array([])
-        self.tmp_size = 0
-
-    def fitness(self, gene):
-        ins = np.zeros(self.target_num+1, dtype=np.int32)
-        seq = np.zeros(self.target_num, dtype=np.int32)
-        ins[self.target_num] = 1
-        for i in range(self.vehicle_num-1):
-            ins[gene[i]] += 1
-        rest = np.array(range(1, self.target_num+1))
-        for i in range(self.target_num-1):
-            seq[i] = rest[gene[i+self.vehicle_num-1]]
-            rest = np.delete(rest, gene[i+self.vehicle_num-1])
-        seq[self.target_num-1] = rest[0]
-        i = 0  # index of vehicle
-        pre = 0  # index of last target
-        post = 0  # index of ins/seq
-        t = 0
-        reward = 0
-        while i < self.vehicle_num:
-            if ins[post] > 0:
-                i += 1
-                ins[post] -= 1
-                pre = 0
-                t = 0
-            else:
-                t += self.targets[pre, 3]
-                past = self.map[pre, seq[post]]/self.vehicles_speed[i]
-                t += past
-                if t < self.time_lim:
-                    reward += self.targets[seq[post], 2]
-                pre = seq[post]
-                post += 1
-        return reward
-
-    def selection(self):
-        roll = np.zeros(self.tmp_size, dtype=float)
-        roll[0] = self.tmp_ff[0]
-        for i in range(1, self.tmp_size):
-            roll[i] = roll[i-1]+self.tmp_ff[i]
-        for i in range(self.pop_size):
-            xx = random.uniform(0, roll[self.tmp_size-1])
-            j = 0
-            while xx > roll[j]:
-                j += 1
-            self.pop[i, :] = self.tmp_pop[j, :]
-            self.ff[i] = self.tmp_ff[j]
-
-    def mutation(self):
-        for i in range(self.tmp_size):
-            flag = False
-            for j in range(self.vehicle_num-1):
-                if random.random() < self.p_mutate:
-                    self.tmp_pop[i, j] = random.randint(0, self.target_num)
-                    flag = True
-            for j in range(self.target_num-1):
-                if random.random() < self.p_mutate:
-                    self.tmp_pop[i, self.vehicle_num+j -
-                                 1] = random.randint(0, self.target_num-j-1)
-                    flag = True
-            if flag:
-                self.tmp_ff[i] = self.fitness(self.tmp_pop[i, :])
-
-    def crossover(self):
-        new_pop = []
-        new_ff = []
-        new_size = 0
-        for i in range(0, self.pop_size, 2):
-            if random.random() < self.p_cross:
-                x1 = random.randint(0, self.vehicle_num-2)
-                x2 = random.randint(0, self.target_num-2)+self.vehicle_num
-                g1 = self.pop[i, :]
-                g2 = self.pop[i+1, :]
-                g1[x1:x2] = self.pop[i+1, x1:x2]
-                g2[x1:x2] = self.pop[i, x1:x2]
-                new_pop.append(g1)
-                new_pop.append(g2)
-                new_ff.append(self.fitness(g1))
-                new_ff.append(self.fitness(g2))
-                new_size += 2
-        self.tmp_size = self.pop_size+new_size
-        self.tmp_pop = np.zeros(
-            shape=(self.tmp_size, self.vehicle_num-1+self.target_num-1), dtype=np.int32)
-        self.tmp_pop[0:self.pop_size, :] = self.pop
-        self.tmp_pop[self.pop_size:self.tmp_size, :] = np.array(new_pop)
-        self.tmp_ff = np.zeros(self.tmp_size, dtype=float)
-        self.tmp_ff[0:self.pop_size] = self.ff
-        self.tmp_ff[self.pop_size:self.tmp_size] = np.array(new_ff)
-
-    def run(self):
-        print("GA start, pid: %s" % os.getpid())
-        start_time = time.time()
-        cut = 0
-        count = 0
-        while count < 500:
-            self.crossover()
-            self.mutation()
-            self.selection()
-            new_cut = self.tmp_ff.max()
-            if cut < new_cut:
-                cut = new_cut
-                count = 0
-                gene = self.tmp_pop[np.argmax(self.tmp_ff)]
-            else:
-                count += 1
-        #print(cut)
-
-        ins = np.zeros(self.target_num+1, dtype=np.int32)
-        seq = np.zeros(self.target_num, dtype=np.int32)
-        ins[self.target_num] = 1
-        for i in range(self.vehicle_num-1):
-            ins[gene[i]] += 1
-        rest = np.array(range(1, self.target_num+1))
-        for i in range(self.target_num-1):
-            seq[i] = rest[gene[i+self.vehicle_num-1]]
-            rest = np.delete(rest, gene[i+self.vehicle_num-1])
-        seq[self.target_num-1] = rest[0]
-        task_assignment = [[] for i in range(self.vehicle_num)]
-        i = 0  # index of vehicle
-        pre = 0  # index of last target
-        post = 0  # index of ins/seq
-        t = 0
-        reward = 0
-        while i < self.vehicle_num:
-            if ins[post] > 0:
-                i += 1
-                ins[post] -= 1
-                pre = 0
-                t = 0
-            else:
-                t += self.targets[pre, 3]
-                past = self.map[pre, seq[post]]/self.vehicles_speed[i]
-                t += past
-                if t < self.time_lim:
-                    task_assignment[i].append(seq[post])
-                    reward += self.targets[seq[post], 2]
-                pre = seq[post]
-                post += 1
-        #print(reward)
-        print("GA result:", task_assignment)
-        #self.task_assignment = task_assignment
-        end_time = time.time()
-        #self.cal_time = end_time - start_time
-        print("GA time:", end_time - start_time)
-        return task_assignment, end_time - start_time
diff --git a/coordination/task_assignment/pso.py b/coordination/task_assignment/pso.py
deleted file mode 100644
index e3e0806..0000000
--- a/coordination/task_assignment/pso.py
+++ /dev/null
@@ -1,387 +0,0 @@
-# coding: utf-8
-import numpy as np
-import random
-import math
-import cmath
-import time
-import os
-# ----------------------Optimization scheme----------------------------------
-# Optimization ideas：
-# 1. Increase the convergence factor k；
-# 2. Dynamic change of inertia factor W；
-# 3. Using PSO local search algorithm(Ring method)
-# 4. The probability of position variation is added
-# ----------------------Set PSO Parameter---------------------------------
-
-
-class PSO():
-    def __init__(self, uav_num, target_num, targets, vehicles_speed, time_lim):
-        self.uav_num = uav_num
-        self.dim = target_num
-        self.targets = targets
-        self.vehicles_speed = vehicles_speed
-        self.time_all = time_lim
-        self.pN = 2*(self.uav_num+self.dim)  # Number of particles
-        self.max_iter = 0  # Number of iterations
-        # Target distance list (dim+1）*（dim+1)
-        self.Distance = np.zeros((target_num+1, target_num+1))
-        self.Value = np.zeros(target_num+1)   # Value list of targets 1*dim+1
-        self.Stay_time = []
-        # UAV flight speed matrix
-        self.w = 0.8
-        self.c1 = 2
-        self.c2 = 2
-        self.r1 = 0.6
-        self.r2 = 0.3
-        self.k = 0   # Convergence factor
-        self.wini = 0.9
-        self.wend = 0.4
-
-        self.X = np.zeros((self.pN, self.dim+self.uav_num-1)
-                          )  # Position of all particles
-        self.V = np.zeros((self.pN, self.dim+self.uav_num-1)
-                          )  # Velocity of all particles
-        # The historical optimal position of each individual
-        self.pbest = np.zeros((self.pN, self.dim+self.uav_num-1))
-        self.gbest = np.zeros((1, self.dim+self.uav_num-1))
-        # Global optimal position
-        self.gbest_ring = np.zeros((self.pN, self.dim+self.uav_num-1))
-        # Historical optimal fitness of each individual
-        self.p_fit = np.zeros(self.pN)
-        self.fit = 0  # Global optimal fitness
-        self.ring = []
-        self.ring_fit = np.zeros(self.pN)
-        # variation parameter
-        self.p1 = 0.4  # Probability of mutation
-        self.p2 = 0.5  # Proportion of individuals with variation in population
-        self.p3 = 0.5  # Proportion of locations where variation occurs
-        self.TEST = []
-        self.test_num = 0
-        self.uav_best = []
-
-        self.time_out = np.zeros(self.uav_num)
-        
-        self.cal_time = 0
-    # ------------------Get Initial parameter------------------
-
-    def fun_get_initial_parameter(self):
-        # self.max_iter=1000
-        self.max_iter = 40*(self.uav_num+self.dim)
-        if self.max_iter > 4100:
-            self.max_iter = 4100
-
-        # self.test_num=10000
-        # Get Stay_time Arrary & Distance Arrary & Value Arrary
-        Targets = self.targets
-        self.Stay_time = Targets[:, 3]
-        self.Distance = np.zeros((self.dim+1, self.dim+1))
-        self.Value = np.zeros(self.dim+1)
-        for i in range(self.dim+1):
-            self.Value[i] = Targets[i, 2]
-            for j in range(i):
-                self.Distance[i][j] = (
-                    Targets[i, 0]-Targets[j, 0])*(Targets[i, 0]-Targets[j, 0])
-                self.Distance[i][j] = self.Distance[i][j] + \
-                    (Targets[i, 1]-Targets[j, 1])*(Targets[i, 1]-Targets[j, 1])
-                self.Distance[i][j] = math.sqrt(self.Distance[i][j])
-                self.Distance[j][i] = self.Distance[i][j]
-    # ------------------Transfer_Function---------------------
-
-    def fun_Transfer(self, X):
-        # Converting continuous sequence X into discrete sequence X_path
-        X1 = X[0:self.dim]
-        X_path = []
-        l1 = len(X1)
-        for i in range(l1):
-            m = X1[i]*(self.dim-i)
-            m = math.floor(m)
-            X_path.append(m)
-        # Converting the continuous interpolation sequence X into discrete interpolation sequence X_rank
-        X2 = X[self.dim:]
-        l1 = len(X2)
-        X_rank = []
-        for i in range(l1):
-
-            m = X2[i]*(self.dim+1)
-
-            m1 = math.floor(m)
-            X_rank.append(m1)
-        # Rank and Complement
-        c = sorted(X_rank)
-        l1 = len(c)
-        Rank = []
-        Rank.append(0)
-        for i in range(l1):
-            Rank.append(c[i])
-        Rank.append(self.dim)
-        # Get Separate_Arrary
-        Sep = []
-        for i in range(l1+1):
-            sep = Rank[i+1]-Rank[i]
-            Sep.append(sep)
-        return X_path, Sep
-
-    # -------------------Obtain the Real Flight Path Sequence of Particles--------------------------
-    def position(self, X):
-        Position_All = list(range(1, self.dim+1))
-        X2 = []
-        for i in range(self.dim):
-            m1 = X[i]
-            m1 = int(m1)
-            X2.append(Position_All[m1])
-            del Position_All[m1]
-        return X2
-    # ---------------------Fitness_Computing Function-----------------------------
-
-    def function(self, X):
-        X_path, Sep = self.fun_Transfer(X)
-
-        # Obtain the Real Flight Path Sequence of Particles
-        X = self.position(X_path)
-        # Get the search sequence of each UAV
-        UAV = []
-        l = 0
-        for i in range(self.uav_num):
-            UAV.append([])
-            k = Sep[i]
-            for j in range(k):
-                UAV[i].append(X[l])
-                l = l+1
-
-        # Calculate Fitness
-        fitness = 0
-        for i in range(self.uav_num):
-            k = Sep[i]
-            t = 0
-            for j in range(k):
-                m1 = UAV[i][j]
-
-                if j == 0:
-                    t = t+self.Distance[0, m1] / \
-                        self.vehicles_speed[i]+self.Stay_time[m1]
-                else:
-                    m1 = UAV[i][j]
-                    m2 = UAV[i][j-1]
-                    t = t+self.Distance[m1][m2] / \
-                        self.vehicles_speed[i]+self.Stay_time[m1]
-                if t <= self.time_all:
-                    fitness = fitness+self.Value[m1]
-        return fitness
-    # ----------------------------variation-------------------------------------------
-
-    def variation_fun(self):
-        p1 = np.random.uniform(0, 1)  # Probability of mutation
-        if p1 < self.p1:
-            for i in range(self.pN):
-                # Proportion of individuals with variation in population
-                p2 = np.random.uniform(0, 1)
-                if p2 < self.p2:
-                    # Numbers of locations where variation occurs
-                    m = int(self.p3*(self.dim+self.uav_num-1))
-                    for j in range(m):
-                        replace_position = math.floor(
-                            np.random.uniform(0, 1)*(self.dim+self.uav_num-1))
-                        replace_value = np.random.uniform(0, 1)
-                        self.X[i][replace_position] = replace_value
-            # Update pbest & gbest
-            for i in range(self.pN):
-                temp = self.function(self.X[i])
-                self.ring_fit[i] = temp
-                if temp > self.p_fit[i]:
-                    self.p_fit[i] = temp
-                    self.pbest[i] = self.X[i]
-                    # Update gbest
-                    if self.p_fit[i] > self.fit:
-                        self.gbest = self.X[i]
-                        self.fit = self.p_fit[i]
-
-    # ---------------------Population Initialization----------------------------------
-
-    def init_Population(self):
-        # Initialization of position(X), speed(V), history optimal(pbest) and global optimal(gbest)
-        for i in range(self.pN):
-            x = np.random.uniform(0, 1, self.dim+self.uav_num-1)
-            self.X[i, :] = x
-            v = np.random.uniform(0, 0.4, self.dim+self.uav_num-1)
-            self.V[i, :] = v
-            self.pbest[i] = self.X[i]
-
-            tmp = self.function(self.X[i])
-            self.p_fit[i] = tmp
-            if tmp > self.fit:
-                self.fit = tmp
-                self.gbest = self.X[i]
-        # Calculate the convergence factor k
-        phi = self.c1+self.c2
-        k = abs(phi*phi-4*phi)
-        k = cmath.sqrt(k)
-        k = abs(2-phi-k)
-        k = 2/k
-        self.k = k
-        # Initialize ring_matrix
-        for i in range(self.pN):
-            self.ring.append([])
-            self.ring[i].append(i)
-        # Initialize test_set
-        self.TEST = np.zeros((self.test_num, self.dim+self.uav_num-1))
-        for i in range(self.test_num):
-            test = np.random.uniform(0, 1, self.dim+self.uav_num-1)
-            self.TEST[i, :] = test
-
-    # ----------------------Update Particle Position----------------------------------
-
-    def iterator(self):
-        fitness = []
-        fitness_old = 0
-        k = 0
-        for t in range(self.max_iter):
-            w = (self.wini-self.wend)*(self.max_iter-t)/self.max_iter+self.wend
-            self.w = w
-            # Variation
-            self.variation_fun()
-            l1 = len(self.ring[0])
-            # Local PSO algorithm
-            # Update ring_arrary
-            if l1 < self.pN:
-                if not(t % 2):
-                    k = k+1
-                    for i in range(self.pN):
-                        m1 = i-k
-                        if m1 < 0:
-                            m1 = self.pN+m1
-                        m2 = i+k
-                        if m2 > self.pN-1:
-                            m2 = m2-self.pN
-                        self.ring[i].append(m1)
-                        self.ring[i].append(m2)
-                # Update gbest_ring
-                l_ring = len(self.ring[0])
-                for i in range(self.pN):
-                    fitness1 = 0
-                    for j in range(l_ring):
-                        m1 = self.ring[i][j]
-                        fitness2 = self.ring_fit[m1]
-                        if fitness2 > fitness1:
-                            self.gbest_ring[i] = self.X[m1]
-                            fitness1 = fitness2
-                # Update velocity
-                for i in range(self.pN):
-                    self.V[i] = self.k*(self.w * self.V[i] + self.c1 * self.r1 * (self.pbest[i] - self.X[i])) + \
-                        self.c2 * self.r2 * (self.gbest_ring[i] - self.X[i])
-                # Update position
-                    self.X[i] = self.X[i] + self.V[i]
-
-            # Global PSO algorithm
-            else:
-                # Update velocity
-                for i in range(self.pN):
-                    self.V[i] = self.k*(self.w * self.V[i] + self.c1 * self.r1 * (self.pbest[i] - self.X[i])) + \
-                        self.c2 * self.r2 * (self.gbest - self.X[i])
-                # Update position
-                    self.X[i] = self.X[i] + self.V[i]
-
-            # Set position boundary
-            for i in range(self.pN):
-                for j in range(self.dim+self.uav_num-1):
-                    if self.X[i][j] >= 1:
-                        self.X[i][j] = 0.999
-                    if self.X[i][j] < 0:
-                        self.X[i][j] = 0
-            # Update pbest & gbest
-            for i in range(self.pN):
-                temp = self.function(self.X[i])
-                self.ring_fit[i] = temp
-                if temp > self.p_fit[i]:
-                    self.p_fit[i] = temp
-                    self.pbest[i] = self.X[i]
-                    # Update gbest
-                    if self.p_fit[i] > self.fit:
-                        self.gbest = self.X[i]
-                        self.fit = self.p_fit[i]
-                        self.uav_best = self.fun_Data()
-
-            # print
-            fitness.append(self.fit)
-            if self.fit == fitness_old:
-                continue
-            else:
-                fitness_old = self.fit
-        return fitness
-
-    # ---------------------Data_Processing Function---------------------------
-    def fun_Data(self):
-        X_path, Sep = self.fun_Transfer(self.gbest)
-        # Obtain the Real Flight Path Sequence of Particles
-        X = self.position(X_path)
-        # Get the search sequence of each UAV
-        UAV = []
-        l = 0
-        for i in range(self.uav_num):
-            UAV.append([])
-            k = Sep[i]
-            for j in range(k):
-                UAV[i].append(X[l])
-                l = l+1
-        # Calculate UAV_Out
-        UAV_Out = []
-        for i in range(self.uav_num):
-            k = Sep[i]
-            t = 0
-            UAV_Out.append([])
-            for j in range(k):
-                m1 = UAV[i][j]
-                if j == 0:
-                    t = t+self.Distance[0, m1] / \
-                        self.vehicles_speed[i]+self.Stay_time[m1]
-                else:
-                    m2 = UAV[i][j-1]
-                    t = t+self.Distance[m2][m1] / \
-                        self.vehicles_speed[i]+self.Stay_time[m1]
-                if t <= self.time_all:
-                    UAV_Out[i].append(m1)
-                    self.time_out[i] = t
-        return UAV_Out
-    # ---------------------TEST Function------------------------------
-
-    def fun_TEST(self):
-        Test_Value = []
-        for i in range(self.test_num):
-            Test_Value.append(self.function(self.TEST[i]))
-        return Test_Value
-    # ---------------------Main----------------------------------------
-
-    def run(self):
-        print("PSO start, pid: %s" % os.getpid())
-        start_time = time.time()
-        self.fun_get_initial_parameter()
-        self.init_Population()
-        fitness = self.iterator()
-        end_time = time.time()
-        #self.cal_time  = end_time - start_time
-        #self.task_assignment = self.uav_best
-        print("PSO result:", self.uav_best)
-        print("PSO time:", end_time - start_time)
-        return self.uav_best, end_time - start_time
-        
-
-
-        # -------------Result-------------------------
-if __name__ == '__main__':
-    # ----------------------------------TEST--------------------------------
-    '''
-    Test_Value=my_pso.fun_TEST()
-    l1=len(fitness)
-    k=0
-    Test_Value_out=[]
-    for i in range(test_num):
-        if Test_Value[i]>fitness[l1-1]:
-            k=k+1
-            Test_Value_out.append(Test_Value[i])
-    print("测试结果超过优化后的目标值的个数是：",k,"个")
-    if k > 0:
-        print("这些测试结果分别是：",Test_Value_out)
-    #print("测试的适应值是",Test_Value)
-    env.run(my_pso.uav_best,'pso')
-    print(env.vehicles_time)
-    print('time_limit:',env.time_lim)
-    '''