MOPSO refactor (1/2)

mopso.py

@@ -2,7 +2,7 @@ import random as rd
 from .particle import Particle
 
 class MOPSO():
-    def __init__(self, f_weigths:list, A_max:float, price_mean:float, price_std:float, n:int, t:int, w:float, c1:float, c2:float, archive_size:int=10, nb_vehicles:int=10, delta_t:int=60, nb_of_ticks:int=72, x_min=-100, x_max=100, v_alpha=0.1, surrogate=False):
+    def __init__(self, f_weights:list, A_max:float, price_mean:float, price_std:float, capacities:list, n:int, t:int, w:float, c1:float, c2:float, archive_size:int=10, nb_vehicles:int=10, delta_t:int=60, nb_of_ticks:int=72, x_min=-100, x_max=100, v_alpha=0.1, surrogate=False):
         # Constants
         self.n = n # Number of particles
         self.t = t # Number of simulation iterations
@@ -10,7 +10,7 @@ class MOPSO():
         self.c1 = c1 # Individual trust
         self.c2 = c2 # Social trust
         self.archive_size = archive_size # Archive size
-        self.f_weigths = f_weigths # Weigths for aggregation of all function objective
+        self.f_weights = f_weights # Weigths for aggregation of all function objective
 
         self.surrogate = surrogate # Using AI calculation
 
@@ -19,26 +19,38 @@ class MOPSO():
         self.socs, self.socs_req = self.generate_state_of_charges(nb_vehicles,nb_of_ticks)
         self.times = self.generate_times(nb_vehicles, nb_of_ticks, delta_t)
         self.prices = self.generates_prices(price_mean,price_std) #TODO: Use RTE France prices for random prices generation according to number of ticks
+        self.capacities = capacities
 
         # Particles of the simulation
-        self.particles = [Particle(times=self.times,nb_vehicles=nb_vehicles, nb_of_ticks=nb_of_ticks, delta_t=delta_t, x_min=x_min, x_max=x_max, alpha=v_alpha) for _ in range(self.n)]
+        self.particles = [Particle(nb_vehicles=nb_vehicles, nb_of_ticks=nb_of_ticks, delta_t=delta_t, x_min=x_min, x_max=x_max, alpha=v_alpha) for _ in range(self.n)]
         self.archive = []
+        self.leader = self.particles[0] # it doesnt matter as the first thing done is choosing a new leader
+        
+        for i in range(self.n):
+            self.particles[i].evaluate(self.f_weights, self.prices, self.socs, self.socs_req, self.times)
+        self.update_archive()
     
     def iterate(self):
-        nb_iter = 0
         if not self.surrogate:
-            while nb_iter < self.t:
-                nb_iter += 1
-                # Selection of a leader
-                # Updating velocity and positions
-                # Checking boundaries
-                # Evaluating particles
+            for t in range(self.t):
+                self.select_leader() # Selection of a leader
+                for i in range(self.n):
+                    # Updating velocity and positions
+                    self.particles[i].update_velocity(leader_pos=self.leader.x, c1=self.c1, c2=self.c2, w=self.w)
+                    self.particles[i].update_position()
+
+                    # Checking boundaries + updating global state
+                    self.particles[i].keep_boudaries(self.A_max)
+                    self.particles[i].updating_socs(self.socs, self.capacities)
+
+                    # Evaluating particles
+                    self.particles[i].evaluate(self.f_weights, self.prices, self.socs, self.socs_req, self.times)
+
                 # Update the archive
-                # Checking for best positions
+                self.update_archive()
         else:
-            while nb_iter < self.t:
-                nb_iter += 1
-                # Selection of a leader
+            for t in range(self.t):
+                self.select_leader() # Selection of a leader
                 # Updating velocity and positions
                 # Checking boundaries
                 # Evaluating particles
@@ -50,8 +62,8 @@ class MOPSO():
         times = []
         for _ in range(nb_vehicles):
             # Minumun, we have one tick of charging/discharging during simulation
-            t_arrived = rd.randrange(0, (nb_of_ticks * delta_t - delta_t) +1, delta_t)
-            t_leaving = rd.randrange(t_arrived + delta_t, (nb_of_ticks * delta_t) +1, delta_t)
+            t_arrived = rd.randrange(0, nb_of_ticks-1, 1)
+            t_leaving = rd.randrange(t_arrived, nb_of_ticks, 1)
             times.append((t_arrived,t_leaving))
         return times
     
@@ -79,9 +91,37 @@ class MOPSO():
             # Adding the requested state of charge
             socs_req.append(soc_req/100)
         return socs, socs_req
+    
+    # True if a dominates b, else false
+    def dominates(a:Particle, b:Particle):
+        dominates = False
+
+
+    def update_archive(self):
+        candidates = self.archive + self.particles
+        length = len(candidates)
+
+        non_dominated = []
+        for i in range(length):
+            candidate_i = candidates[i]
+            dominates = True
+            for j in range(length):
+                if i!=j:
+                    candidate_j = candidates[j]
+                    dominates = dominates and self.dominates(candidate_i, candidate_j)
+            if dominates:
+                non_dominated.append(candidate_i)
+
+        # Keeping only a certain number of solutions depending on archive_size (to avoid overloading the number of potential directions for particles)
+        if len(non_dominated) > self.archive_size:
+            final_non_dominated = []
+            while len(final_non_dominated) < self.archive_size:
+                final_non_dominated.append(rd.choice(non_dominated))
+            self.archive = final_non_dominated
+        else:
+            self.archive = non_dominated
+
 
     # Random uniform selection for a leader
     def select_leader(self):
-        n = len(self.archive) # Archive length
-        rd_pos = rd.randrange(0, n, 1)
-        return self.archive[rd_pos]
+        return rd.choice(self.archive)