111 lines
4.5 KiB
Python
111 lines
4.5 KiB
Python
import random as rd
|
|
|
|
class Particle():
|
|
def __init__(self, nb_vehicles:int=10, delta_t:int=60, nb_of_ticks:int=72, a_min=-100, a_max=100, alpha=0.1):
|
|
# Problem specific attributes
|
|
self.nb_vehicles = nb_vehicles # Number of vehicles handles for the generations of position x
|
|
self.delta_t = delta_t # delta_t for update purposes
|
|
self.nb_of_ticks = nb_of_ticks # Accounting for time evolution of the solution (multiplied by delta_t)
|
|
|
|
self.socs= self.generate_state_of_charges() # States of charge (initial, requested)
|
|
|
|
#TODO: Move that to MOPSO (using one batch of times for multiples particles)
|
|
self.times = self.generate_times() # Times (arrived, leaving)
|
|
|
|
# Minima and maxima of a position value
|
|
self.a_min = a_min
|
|
self.a_max = a_max
|
|
|
|
# Limitation of the velocity
|
|
self.alpha = alpha
|
|
self.r1 = [rd.randrange(0,101,1)/100 for _ in range(self.nb_vehicles)] # Variable trust of oneself
|
|
self.r2 = [rd.randrange(0,101,1)/100 for _ in range(self.nb_vehicles)] # Variable trust of other particles
|
|
|
|
# Particle attributes
|
|
self.x = self.generate_position() # Position Vector (correspond to one solution for the problem)
|
|
self.v = self.generate_velocity() # Velocity
|
|
self.p_best = self.x # Best known position (starting with initial position x)
|
|
self.eval = 0 #TODO: self.evaluate()
|
|
|
|
def update_position(self):
|
|
for i in range(self.nb_vehicles):
|
|
new_pos_i = self.x[i] + self.v[i]
|
|
self.x[i] = new_pos_i
|
|
|
|
def update_velocity(self, leader, c1, c2, w=0.4):
|
|
for i in range(self.nb_vehicles):
|
|
new_vel_i = w * self.v[i] + (self.p_best - self.x[i]) * c1 * self.r1[i] + (leader - self.x[i]) * c2 * self.r2[i]
|
|
self.v[i] = new_vel_i
|
|
|
|
def generate_state_of_charges(self):
|
|
socs = []
|
|
# We ensure soc_req is greater than what the soc_init is (percentage transformed into floats)
|
|
for _ in range(self.nb_vehicles):
|
|
soc_init = rd.randrange(0,100,1)
|
|
soc_req = rd.randrange(soc_init+1, 101,1)
|
|
socs.append((soc_init/100, soc_req/100))
|
|
return socs
|
|
|
|
def generate_times(self):
|
|
times = []
|
|
for _ in range(self.nb_vehicles):
|
|
# Minumun, we have one tick of charging during simulation
|
|
t_arrived = rd.randrange(0, (self.nb_of_ticks * self.delta_t - self.delta_t) +1, self.delta_t)
|
|
t_leaving = rd.randrange(t_arrived + self.delta_t, (self.nb_of_ticks*self.delta_t)+1, self.delta_t)
|
|
times.append((t_arrived,t_leaving))
|
|
return times
|
|
|
|
#TODO: Modify for uses of ticks
|
|
def generate_position(self):
|
|
pos = []
|
|
for _ in range(self.nb_of_ticks):
|
|
x_tick = []
|
|
for _ in range(self.nb_vehicles):
|
|
x_tick.append(rd.randrange(self.a_min, self.a_max +1, 1))
|
|
pos.append(x_tick)
|
|
return pos
|
|
|
|
def generate_velocity(self):
|
|
vel = []
|
|
vel_coeff = self.a_max - self.a_min
|
|
for _ in range(self.nb_of_ticks):
|
|
v_tick = []
|
|
for _ in range(self.nb_vehicles):
|
|
v_tick.append(rd.randrange(-vel_coeff, vel_coeff +1, 1) * self.alpha)
|
|
vel.append(v_tick)
|
|
return vel
|
|
|
|
# Function objective
|
|
def evaluate(self, elec_prices, max_power):
|
|
pass
|
|
|
|
# Calculate the price of the electricity consumption in the grid SUM(1_to_T)(Epsilon_t * A_t * delta_t)
|
|
def f1(self, elec_prices):
|
|
result = 0
|
|
for tick in range(self.nb_of_ticks):
|
|
grid_stress_tick = self.get_current_grid_stress(tick)
|
|
result += elec_prices[tick] * grid_stress_tick * self.delta_t
|
|
return result
|
|
|
|
#TODO: Modify for uses of ticks
|
|
# User's insatisfaction
|
|
def f2(self):
|
|
result = 0
|
|
for i in range(self.nb_vehicles):
|
|
soc_req_i = self.socs[i][1]
|
|
result += max(0, )
|
|
|
|
# Network Stress
|
|
def f3(self):
|
|
current_max = 0
|
|
for tick in range(self.nb_of_ticks):
|
|
current_max = max(current_max, self.get_current_grid_stress(tick))
|
|
return current_max
|
|
|
|
#TODO: Modify for uses of ticks
|
|
def get_current_grid_stress(self, tick:int):
|
|
assert tick < self.nb_of_ticks # Make sure the tick exist in the position x
|
|
current_grid_stress = 0
|
|
for i in range(self.nb_vehicles):
|
|
current_grid_stress += self.x[tick][i]
|
|
return current_grid_stress |