def eval_genomes(genomes, config, episode):
"""" SOMETHING SMETHING"""
x = 0
# state_empty=np.zeros([feature_number,1])
for genome_id, genome in genomes:
x += 1
SUMO.step = 0
SUMO.Colliion = False
SUMO.RouteEnd = False
v_episode = []
a_episode = []
distance_episode = []
created = multiprocessing.Process()
sim = current._identity[1]
simulation = traci.getConnection('sim' + str(sim - 1))
SUMO.init_vars_episode()
"""Anmerkung: Hier werden einige Variationen des Verkehrsszenarios für meine Trainingsepisoden definiert, wenn 'training = True'
gesetzt ist. Im Fall 'training = False' oder 'evaluation = True' (Evaluierungsepisoden unter gleichen Randbedingungen) wird immer eine
Episode mit gleichen Randbedingungen (z.B. Geschwindigkeitsprofil vorausfahrendes Fahrzeug) gesetzt"""
if trafic.evaluation:
simulation.vehicle.add(trafic.vehicle_ego.ID,
trafic.vehicle_ego.RouteID,
departSpeed='0',
typeID='ego_vehicle') # Ego vehicle
simulation.trafficlight.setPhase(
'junction1', 0
) # set traffic light phase to 0 for evaluation (same conditions)
else:
traci.vehicle.add(trafic.vehicle_ego.ID,
trafic.vehicle_ego.RouteID,
departSpeed=np.array2string(
trafic.vehicle_ego.depart_speed[episode -
1]),
typeID='ego_vehicle') # Ego vehicle
if trafic.vehicle2_exist:
simulation.vehicle.add(
trafic.vehicle_2.ID,
trafic.vehicle_2.RouteID,
typeID='traffic_vehicle') # preceding vehicle 1
if trafic.vehicle3:
simulation.vehicle.add(
trafic.vehicle_3.ID,
trafic.vehicle_3.RouteID,
typeID='traffic_vehicle') # preceding vehicle 2
if trafic.training and not trafic.evaluation:
simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0',
trafic.episoden_variante)
else:
simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0', 0.)
simulation.simulationStep() # to spawn vehicles
# if controller != 'SUMO':
simulation.vehicle.setSpeedMode(
trafic.vehicle_ego.ID, 16
) # only emergency stopping at red traffic lights --> episode ends
if trafic.vehicle2_exist:
simulation.vehicle.setSpeedMode(trafic.vehicle_2.ID, 17)
if trafic.vehicle3:
simulation.vehicle.setSpeedMode(trafic.vehicle_3.ID, 17)
SUMO.currentvehiclelist = simulation.vehicle.getIDList()
# SUMO subscriptions
simulation.vehicle.subscribeLeader(trafic.vehicle_ego.ID, 10000)
simulation.vehicle.subscribe(trafic.vehicle_ego.ID, [
traci.constants.VAR_SPEED, traci.constants.VAR_BEST_LANES,
traci.constants.VAR_FUELCONSUMPTION, traci.constants.VAR_NEXT_TLS,
traci.constants.VAR_ALLOWED_SPEED, traci.constants.VAR_LANE_ID
])
dynamics_ego = Longitudinal_dynamics(tau=0.5)
net = neat.nn.FeedForwardNetwork.create(genome, config)
""""Run episode ======================================================================="""
while simulation.simulation.getMinExpectedNumber(
) > 0: # timestep loop
"""Get state for first iteration ==================================================================="""
if SUMO.step == 0:
calculate_features_firststep()
# if controller == 'DDPG_v' or controller == 'DDPG' or controller == 'DQN':
# nn_controller.state = get_state()
"""Controller ======================================================================================
Hier wird die Stellgröße des Reglers (z.B. Sollbeschleunigung) in Abhängigkeit der Reglereingänge (zusammengefasst in 'features'
für den ACC Controller bzw. 'nn_controller.state' für die Neuronalen Regler"""
# if controller == 'ACC':
# SUMO.a_set[SUMO.step] = acc_controller.calculate_a(features) # Calculate set acceleration with ACC controller
# # Save ACC mode to SUMO class
# SUMO.mode_ego[SUMO.step] = acc_controller.mode # ACC control modes (speed control, headway control, etc)
# elif controller == 'DQN':
# # Calculate Q-Values for all actions
# nn_controller.action_value = nn_controller.model.predict(nn_controller.state) # NN inputs: distance, delta_v
# # Choose Action according to epsilon-greedy policy
# nn_controller.index[SUMO.step] = nn_controller.choose_action(nn_controller.action_value, episode)
# # Calculate the set acceleration for the timestep
# nn_controller.a_set = nn_controller.actions[nn_controller.index[SUMO.step]]
# SUMO.a_set[SUMO.step] = nn_controller.a_set
# elif controller == 'DDPG':
# if training and not evaluation:
# if exploration_policy == 'ACC':
# SUMO.a_set[SUMO.step] = explo_policy.calculate_a(features)
# SUMO.a_set[SUMO.step] = nn_controller.add_noise(SUMO.a_set[SUMO.step])
# else:
# SUMO.a_set[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=True)
# else:
# SUMO.a_set[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=False)
# elif controller == 'hybrid_a':
# acc_controller.a_set = acc_controller.calculate_a(
# features) # Calculate set acceleration with ACC controller
# # Save ACC mode to SUMO class
# SUMO.mode_ego[SUMO.step] = acc_controller.mode # ACC control modes (speed control, headway control, etc)
# if SUMO.step == 0:
# nn_controller.state[0, 3] = acc_controller.a_set
# if training and not evaluation:
# nn_controller.a_set = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=True)
# else:
# nn_controller.a_set = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=False)
# SUMO.a_set[SUMO.step] = acc_controller.a_set + nn_controller.k_hybrid_a * nn_controller.a_set
# SUMO.a_hybrid_a[SUMO.step] = nn_controller.a_set
# elif controller == 'DDPG_v':
# if training and not evaluation:
# SUMO.v_set[SUMO.step], SUMO.v_set_nonoise[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', features=features, noise=True)
# else:
# SUMO.v_set[SUMO.step] = nn_controller.choose_action(copy(nn_controller.state), network='main', noise=False)
# SUMO.a_set[SUMO.step] = acc_controller.calc_a_P(features, SUMO.v_set[SUMO.step])
state = get_state(trafic.state_empty)
# print(state)
# net = neat.nn.FeedForwardNetwork.create(genome, config)
SUMO.a_set[SUMO.step] = net.activate(
state) #[0,0], state[0,1], state[0,2], state[0,3])
SUMO.a_set[SUMO.step] = 20 * SUMO.a_set[
SUMO.step] - 10 #[0,0], state[0,1], state[0,2], state[0,3])
# print(SUMO.a_set[SUMO.step], SUMO.step)
"""Longitudinal Dynamics ===========================================================================
Hier werden Längsdynamische Größen des Egofahrzeugs berechnet. beispielsweise die Realbeschleunigung aus den Stellgrößen des Reglers oder der
Kraftstoffverbrauch für ein definiertes Fahrzeug (aktuell konventionelles Verbrennerfahrzeug mit Mehrganggetriebe). Am Ende wird als
Schnittstelle zu SUMO eine neue Geschwindigkeit für das Egofahrzeug für den nächsten Zeitschritt gesetzt"""
dynamics_ego = Longitudinal_dynamics(tau=0.5)
# if controller == 'SUMO':
# dynamics_ego.a_real = traci.vehicle.getAcceleration(vehicle_ego.ID)
# dynamics_ego.wheel_demand(SUMO.v_ego[SUMO.step], vehicle_ego,
# SUMO.step) # Calculate the torque and speed wheel demand of this timestep
# dynamics_ego.operating_strategy(SUMO.sim['timestep'], vehicle_ego, s0=2, kp=10, step=SUMO.step)
# SUMO.a_real[SUMO.step] = dynamics_ego.a_real
# else:
dynamics_ego.low_lev_controller(
SUMO.a_set[SUMO.step], SUMO.sim['timestep']
) # Calculate a_real with a_set and a PT1 Transfer function
dynamics_ego.wheel_demand(
SUMO.v_ego[SUMO.step], trafic.vehicle_ego, SUMO.step
) # Calculate the torque and speed wheel demand of this timestep
dynamics_ego.operating_strategy(SUMO.sim['timestep'],
trafic.vehicle_ego,
s0=2,
kp=10,
step=SUMO.step)
dynamics_ego.v_real_next = SUMO.v_ego[
SUMO.step] + dynamics_ego.a_real * SUMO.sim['timestep']
dynamics_ego.v_real_next = np.clip(dynamics_ego.v_real_next, 0.,
None)
SUMO.a_real[SUMO.step] = dynamics_ego.a_real
simulation.vehicle.setSpeed(
trafic.vehicle_ego.ID, dynamics_ego.v_real_next
) # Set velocity of ego car for next time step
"""Control traffic ================================================================"""
if trafic.vehicle2_exist and trafic.vehicle_2.ID in SUMO.currentvehiclelist:
if trafic.vehicle_2.end == False:
if simulation.vehicle.getLaneID(
trafic.vehicle_2.ID
) == 'junction_out_0' and traci.vehicle.getLanePosition(
trafic.vehicle_2.ID) > 90:
simulation.vehicle.remove(trafic.vehicle_2.ID)
trafic.vehicle_2.end = True
else:
#traci.vehicle.setSpeed(vehicle_2.ID, SUMO.v_profile[SUMO.step]) # set velocity of preceding car 1
pass
if trafic.vehicle3 and trafic.vehicle_3.ID in SUMO.currentvehiclelist:
traci.vehicle.setSpeed(trafic.vehicle_3.ID, SUMO.v_profile[
SUMO.step]) # set velocity of preceding car 2
"""SUMO simulation step ============================================================================"""
simulation.simulationStep()
SUMO.currentvehiclelist = traci.vehicle.getIDList()
"""Check if any of the endstate conditions is true (e.g. collision) ==================================="""
if trafic.vehicle_ego.ID not in SUMO.currentvehiclelist:
SUMO.RouteEnd = True
SUMO.endstate = True
print([x, SUMO.step], ' Route finished!')
elif simulation.simulation.getCollidingVehiclesNumber() > 0:
SUMO.endstate = True
SUMO.Collision = True
print([x, SUMO.step], ' Collision!')
elif trafic.vehicle_ego.ID in simulation.simulation.getEmergencyStoppingVehiclesIDList(
): # Check for ego vehicle passing red traffic light
SUMO.Collision = True
SUMO.endstate = True
print([x, SUMO.step], ' Red lights passed!')
# Set a maximum time step limit for 1 episode
elif SUMO.step > 5000:
SUMO.RouteEnd = True
SUMO.endstate = True
print([x, SUMO.step], ' Maximum time reached!')
"""get new state ==================================================================================="""
calculate_features()
v_episode.append(features.v_ego)
a_episode.append(dynamics_ego.a_real)
distance_episode.append(features.distance)
# if controller == 'DDPG_v' or controller == 'DDPG' or controller == 'DQN':
# nn_controller.new_state = get_state()
"""Prepare next timestep ==========================================================================="""
if SUMO.Collision or SUMO.RouteEnd: # end episode when endstate conditions are true
break
dynamics_ego.a_previous = copy(
dynamics_ego.a_real
) # copy --> to create an independent copy of the variable, not a reference to it
# if controller == 'DQN' or controller == 'hybrid_a' or controller == 'DDPG' or controller == 'DDPG_v':
# nn_controller.state = copy(nn_controller.new_state)
if sample_generation:
sample_generator.state = copy(sample_generator.new_state)
trafic.vehicle_ego.ID_prec_previous = copy(
trafic.vehicle_ego.ID_prec)
# print(SUMO.step)
SUMO.step += 1
# print(v_episode)
"""Calculate Reward ================================================================================"""
fitness = len(v_episode) * np.sqrt(np.sum(
np.square(v_episode))) - np.sum(
0.5 * np.sign(features.v_allowed - np.asarray(v_episode)) +
1) - np.mean(np.square(a_episode)) - 1 / sum(
np.square(
np.asarray(v_episode) * 3.6 -
np.asarray(distance_episode))) - 100000 * int(
SUMO.Collision)
genome.fitness = fitness[0].item()
print(fitness)
# cum_reward[episode] += reward
"""End of episode - prepare next episode ======================================================================
Reset position of vehicles by removing and (later) adding them again, call running plots and export data """
if trafic.vehicle_ego.ID in SUMO.currentvehiclelist:
simulation.vehicle.remove(trafic.vehicle_ego.ID)
if trafic.vehicle2_exist and trafic.vehicle_2.ID in SUMO.currentvehiclelist:
simulation.vehicle.remove(trafic.vehicle_2.ID)
if trafic.vehicle3 and trafic.vehicle_3.ID in SUMO.currentvehiclelist:
simulation.vehicle.remove(trafic.vehicle_3.ID)
simulation.simulationStep()
dynamics_ego.reset_variables()
number_episodes) * 20 / 3.6 + 10 / 3.6
else:
SUMO.prec_train_amplitude = 25 / 3.6 # a=25/3.6
SUMO.prec_train_mean = 30 / 3.6 # c=30/3.6
SUMO.create_v_profile_prec(a=SUMO.prec_train_amplitude,
c=SUMO.prec_train_mean)
elif vehicle3_vprofile == 'emergstop':
SUMO.create_v_profile_emerg_stop()
else:
raise NameError('No valid velocity profile selected')
trafic.vehicle_ego = Vehicle(ego=True,
ID='ego',
RouteID='RouteID_ego',
Route=trafic.Route_Ego,
powertrain_concept='ICEV')
trafic.dynamics_ego = Longitudinal_dynamics(tau=0.5)
if trafic.vehicle2_exist:
trafic.vehicle_2 = Vehicle(ego=False,
ID='traffic.0',
RouteID='traci_route_traffic.0',
Route=trafic.Route_Traffic1)
if trafic.vehicle3_exist:
trafic.vehicle_3 = Vehicle(ego=False,
ID='traffic.1',
RouteID='traci_route_traffic.1',
Route=trafic.Route_Traffic2)
acc_controller = {}
# if controller == 'ACC' or controller == 'hybrid_a' or controller == 'DDPG_v':
# acc_controller = ACC_Controller(v_set=19.44, h_set=1, a_set_min=-10.) # instantiate ACC controller
# acc_controller.create_mode_map()
# if controller == 'DQN':
def SimInitializer(trafic, episode):
error = False
try:
timestep = 1
trafic.number_episodes = 100000
feature_number = 4
trafic.training = True
sample_generation = False
trafic.TLS_virt_vehicle = True # Red and Yellow traffic lights are considered as preceding vehicles with v=0
trafic.TLS_ID = ['0', '1', '2', '3', '4']
trafic.evaluation = False
trafic.vehicle2_exist = False # currently no meaningful trajectory / route - keep on False
trafic.vehicle3_exist = True
trafic.vehicle3_vprofile = 'sinus' # 'sinus', 'emergstop'
liveplot = False # memory leak problem on windows when turned on
trafic.Route_Ego = ['startedge', 'gneE01', 'gneE02', 'stopedge']
trafic.ego_depart_speed = np.ones(
(trafic.number_episodes,
)) * 0. # specific depart speed for ego vehicle when not training
trafic.Route_Traffic1 = ['gneE01', 'junction_out'] # for vehicle2
trafic.Route_Traffic2 = ['gneE01', 'gneE02',
'stopedge'] # for vehicle3
trafic.state_empty = np.zeros([feature_number, 1])
timestep = 2
np.random.seed(42 + episode)
SUMO2 = SUMO(trafic.Route_Ego,
trafic.Route_Traffic1,
trafic.Route_Traffic2,
timestep=0.2)
## create velocity profile of preceding vehicle ##
"""Hier werden bei 'training = True' unterschiedliche Geschwindigkeitsprofile für das vorausfahrende Fahrzeug definiert.
Für 'training = False' wird ein festes sinusförmiges Profil mit Mittelwert 30 km/h und Amplitude +- 25 km/h definiert."""
if trafic.vehicle3_exist:
if trafic.vehicle3_vprofile == 'sinus':
if trafic.training: # create random sinusodial velocity profiles for training
SUMO2.prec_train_amplitude = np.random.rand(
trafic.number_episodes) * 20 / 3.6
SUMO2.prec_train_mean = np.random.rand(
trafic.number_episodes) * 20 / 3.6 + 10 / 3.6
else:
SUMO2.prec_train_amplitude = 25 / 3.6 # a=25/3.6
SUMO2.prec_train_mean = 30 / 3.6 # c=30/3.6
SUMO2.create_v_profile_prec(a=SUMO.prec_train_amplitude,
c=SUMO.prec_train_mean)
elif vehicle3_vprofile == 'emergstop':
SUMO2.create_v_profile_emerg_stop()
else:
raise NameError('No valid velocity profile selected')
trafic.vehicle_ego = Vehicle(ego=True,
ID='ego',
RouteID='RouteID_ego',
Route=trafic.Route_Ego,
powertrain_concept='ICEV')
trafic.dynamics_ego = Longitudinal_dynamics(tau=0.5)
if trafic.vehicle2_exist:
trafic.vehicle_2 = Vehicle(ego=False,
ID='traffic.0',
RouteID='traci_route_traffic.0',
Route=trafic.Route_Traffic1)
if trafic.vehicle3_exist:
trafic.vehicle_3 = Vehicle(ego=False,
ID='traffic.1',
RouteID='traci_route_traffic.1',
Route=trafic.Route_Traffic2)
acc_controller = {}
timestep = 3
# if trafic.training and liveplot:
# fig_running, ax_running_1, ax_running_2, ax_running_3, ax_running_4 = plot_running_init(training)
process_param = multiprocessing.Process()
# print(process_param.name)
traci.start(['sumo', '-c', 'SUMO_config.sumocfg', '--no-warnings'],
label=str(process_param.name)) #, label=sim)
simulation = traci.getConnection(process_param.name)
simulation.route.add(trafic.vehicle_ego.RouteID,
trafic.vehicle_ego.Route)
if trafic.vehicle2_exist:
simulation.route.add(trafic.vehicle_2.RouteID,
trafic.vehicle_2.Route)
if trafic.vehicle3_exist:
simulation.route.add(trafic.vehicle_3.RouteID,
trafic.vehicle_3.Route)
simulation.vehicletype.setSpeedFactor(typeID='traffic_vehicle',
factor=5.0)
length_episode = np.zeros((trafic.number_episodes, 1))
restart_step = 0 # counter for calculating the reset timing when the simulation time gets close to 24 days
evaluation = False
if trafic.training:
trafic.vehicle_ego.depart_speed = np.random.randint(
0, 30, size=trafic.number_episodes)
else:
trafic.vehicle_ego.depart_speed = ego_depart_speed
simulation.trafficlight.setProgram(tlsID='junction1',
programID=np.random.choice(
trafic.TLS_ID))
timestep = 4 + episode
if not trafic.training:
simulation.trafficlight.setPhase('junction1', 0)
if trafic.training and not trafic.evaluation and trafic.vehicle3_exist:
trafic.vehicle3 = np.random.choice([True, False], p=[0.95, 0.05])
simulation.lane.setMaxSpeed(
'gneE01_0', np.random.choice([8.33, 13.89, 19.44, 25.]))
simulation.lane.setMaxSpeed(
'gneE02_0', np.random.choice([8.33, 13.89, 19.44, 25.]))
simulation.lane.setMaxSpeed(
'startedge_0', np.random.choice([8.33, 13.89, 19.44, 25.]))
SUMO2.create_v_profile_prec(a=SUMO2.prec_train_amplitude[episode -
1],
c=SUMO2.prec_train_mean[episode - 1])
else:
trafic.vehicle3 = vehicle3_exist
simulation.lane.setMaxSpeed('startedge_0', 13.89) # 13.89
simulation.lane.setMaxSpeed('gneE01_0', 19.44) # 19.44
simulation.lane.setMaxSpeed('gneE02_0', 13.89) # 13.89
simulation.lane.setMaxSpeed('stopedge_0', 8.33) # 8.33
trafic.episoden_variante = np.random.rand() * 240.
return process_param.name, SUMO2, error
except Exception as ex:
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
error = True
traci.close()
def eval_genomes(genome_id, genome, config, episode, trafic):
"""" SOMETHING SMETHING"""
error = False
error_return = 10000
timestep = 0
try:
[simname, SUMO, error] = SimInitializer(trafic, episode)
except Exception as ex:
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
if error == True:
return error_return
# fitness=timestep
# raise Exception('Error SimInitializer', message)
if error == True:
return error_return
try:
x = 0
# state_empty=np.zeros([feature_number,1])
# for genome_id, genome in genomes:
x += 1
SUMO.step = 0
SUMO.Colliion = False
SUMO.RouteEnd = False
v_episode = []
a_episode = []
distance_episode = []
timestep = 1
process_param = multiprocessing.Process()
sim = simname #process_param.name
timestep = [sim, simname]
simulation = traci.getConnection(simname)
timestep = 1.5
SUMO.init_vars_episode()
"""Anmerkung: Hier werden einige Variationen des Verkehrsszenarios für meine Trainingsepisoden definiert, wenn 'training = True'
gesetzt ist. Im Fall 'training = False' oder 'evaluation = True' (Evaluierungsepisoden unter gleichen Randbedingungen) wird immer eine
Episode mit gleichen Randbedingungen (z.B. Geschwindigkeitsprofil vorausfahrendes Fahrzeug) gesetzt"""
if trafic.evaluation:
simulation.vehicle.add(trafic.vehicle_ego.ID,
trafic.vehicle_ego.RouteID,
departSpeed='0',
typeID='ego_vehicle') # Ego vehicle
simulation.trafficlight.setPhase(
'junction1', 0
) # set traffic light phase to 0 for evaluation (same conditions)
else:
simulation.vehicle.add(
trafic.vehicle_ego.ID,
trafic.vehicle_ego.RouteID,
departSpeed=np.array2string(
trafic.vehicle_ego.depart_speed[episode - 1]),
typeID='ego_vehicle') # Ego vehicle
if trafic.vehicle2_exist:
simulation.vehicle.add(
trafic.vehicle_2.ID,
trafic.vehicle_2.RouteID,
typeID='traffic_vehicle') # preceding vehicle 1
timestep = 1.7
if trafic.vehicle3:
simulation.vehicle.add(
trafic.vehicle_3.ID,
trafic.vehicle_3.RouteID,
typeID='traffic_vehicle') # preceding vehicle 2
if trafic.training and not trafic.evaluation:
simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0',
trafic.episoden_variante)
else:
simulation.vehicle.moveTo(trafic.vehicle_3.ID, 'gneE01_0', 0.)
timestep = 2
simulation.simulationStep() # to spawn vehicles
# if controller != 'SUMO':
simulation.vehicle.setSpeedMode(
trafic.vehicle_ego.ID, 16
) # only emergency stopping at red traffic lights --> episode ends
if trafic.vehicle2_exist:
simulation.vehicle.setSpeedMode(trafic.vehicle_2.ID, 17)
if trafic.vehicle3:
simulation.vehicle.setSpeedMode(trafic.vehicle_3.ID, 17)
SUMO.currentvehiclelist = simulation.vehicle.getIDList()
# SUMO subscriptions
simulation.vehicle.subscribeLeader(trafic.vehicle_ego.ID, 10000)
simulation.vehicle.subscribe(trafic.vehicle_ego.ID, [
traci.constants.VAR_SPEED, traci.constants.VAR_BEST_LANES,
traci.constants.VAR_FUELCONSUMPTION, traci.constants.VAR_NEXT_TLS,
traci.constants.VAR_ALLOWED_SPEED, traci.constants.VAR_LANE_ID
])
timestep = 3
dynamics_ego = Longitudinal_dynamics(tau=0.5)
timestep = 3.1
net = neat.nn.FeedForwardNetwork.create(genome[1], config)
""""Run episode ======================================================================="""
while simulation.simulation.getMinExpectedNumber(
) > 0: # timestep loop
"""Get state for first iteration ==================================================================="""
if SUMO.step == 0:
calculate_features_firststep(sim, SUMO)
# if controller == 'DDPG_v' or controller == 'DDPG' or controller == 'DQN':
# nn_controller.state = get_state()
timestep = 3.3
"""Controller ======================================================================================
Hier wird die Stellgröße des Reglers (z.B. Sollbeschleunigung) in Abhängigkeit der Reglereingänge (zusammengefasst in 'features'
für den ACC Controller bzw. 'nn_controller.state' für die Neuronalen Regler"""
state = get_state(trafic.state_empty)
timestep = 4
# print(state)
# net = neat.nn.FeedForwardNetwork.create(genome, config)
SUMO.a_set[SUMO.step] = net.activate(
state) #[0,0], state[0,1], state[0,2], state[0,3])
SUMO.a_set[SUMO.step] = 10 * SUMO.a_set[
SUMO.step] #-10 #[0,0], state[0,1], state[0,2], state[0,3])
# print(SUMO.a_set[SUMO.step], SUMO.step)
timestep = 5
"""Longitudinal Dynamics ===========================================================================
Hier werden Längsdynamische Größen des Egofahrzeugs berechnet. beispielsweise die Realbeschleunigung aus den Stellgrößen des Reglers oder der
Kraftstoffverbrauch für ein definiertes Fahrzeug (aktuell konventionelles Verbrennerfahrzeug mit Mehrganggetriebe). Am Ende wird als
Schnittstelle zu SUMO eine neue Geschwindigkeit für das Egofahrzeug für den nächsten Zeitschritt gesetzt"""
dynamics_ego = Longitudinal_dynamics(tau=0.5)
dynamics_ego.low_lev_controller(
SUMO.a_set[SUMO.step], SUMO.sim['timestep']
) # Calculate a_real with a_set and a PT1 Transfer function
dynamics_ego.wheel_demand(
SUMO.v_ego[SUMO.step], trafic.vehicle_ego, SUMO.step
) # Calculate the torque and speed wheel demand of this timestep
dynamics_ego.operating_strategy(SUMO.sim['timestep'],
trafic.vehicle_ego,
s0=2,
kp=10,
step=SUMO.step)
dynamics_ego.v_real_next = SUMO.v_ego[
SUMO.step] + dynamics_ego.a_real * SUMO.sim['timestep']
dynamics_ego.v_real_next = np.clip(dynamics_ego.v_real_next, 0.,
None)
SUMO.a_real[SUMO.step] = dynamics_ego.a_real
simulation.vehicle.setSpeed(
trafic.vehicle_ego.ID, dynamics_ego.v_real_next
) # Set velocity of ego car for next time step
timestep = 6
"""Control traffic ================================================================"""
if trafic.vehicle2_exist and trafic.vehicle_2.ID in SUMO.currentvehiclelist:
if trafic.vehicle_2.end == False:
if simulation.vehicle.getLaneID(
trafic.vehicle_2.ID
) == 'junction_out_0' and simulation.vehicle.getLanePosition(
trafic.vehicle_2.ID) > 90:
simulation.vehicle.remove(trafic.vehicle_2.ID)
trafic.vehicle_2.end = True
else:
#traci.vehicle.setSpeed(vehicle_2.ID, SUMO.v_profile[SUMO.step]) # set velocity of preceding car 1
pass
if trafic.vehicle3 and trafic.vehicle_3.ID in SUMO.currentvehiclelist:
simulation.vehicle.setSpeed(
trafic.vehicle_3.ID, SUMO.v_profile[
SUMO.step]) # set velocity of preceding car 2
"""SUMO simulation step ============================================================================"""
simulation.simulationStep()
SUMO.currentvehiclelist = traci.vehicle.getIDList()
timestep = 7
"""Check if any of the endstate conditions is true (e.g. collision) ==================================="""
if trafic.vehicle_ego.ID not in SUMO.currentvehiclelist:
SUMO.RouteEnd = True
SUMO.endstate = True
# print([x, SUMO.step],' Route finished!')
elif simulation.simulation.getCollidingVehiclesNumber() > 0:
SUMO.endstate = True
SUMO.Collision = True
# print([x, SUMO.step],' Collision!')
elif trafic.vehicle_ego.ID in simulation.simulation.getEmergencyStoppingVehiclesIDList(
): # Check for ego vehicle passing red traffic light
SUMO.Collision = True
SUMO.endstate = True
# print([x, SUMO.step],' Red lights passed!')
# Set a maximum time step limit for 1 episode
elif SUMO.step > 5000:
SUMO.RouteEnd = True
SUMO.endstate = True
# print([x, SUMO.step],' Maximum time reached!')
timestep = 7.5
"""get new state ==================================================================================="""
calculate_features(sim, SUMO)
v_episode.append(features.v_ego)
a_episode.append(dynamics_ego.a_real)
distance_episode.append(features.distance)
#
"""Prepare next timestep ==========================================================================="""
if SUMO.Collision or SUMO.RouteEnd: # end episode when endstate conditions are true
timestep = 9
break
dynamics_ego.a_previous = copy(
dynamics_ego.a_real
) # copy --> to create an independent copy of the variable, not a reference to it
trafic.vehicle_ego.ID_prec_previous = copy(
trafic.vehicle_ego.ID_prec)
SUMO.step += 1
timestep = 8
"""Calculate Reward ================================================================================"""
# fitness = np.sqrt(len(v_episode))*np.sqrt(np.sum(np.square(np.asarray(v_episode)/250)))+np.sum(0.5*np.sign(features.v_allowed/250-np.asarray(v_episode)/250)+1) -0.0001*np.sum(np.square(a_episode))-1/sum(np.square(np.asarray(v_episode)/250*3.6-np.asarray(distance_episode)/250))-100000*int(SUMO.Collision) +100000*int(SUMO.RouteEnd)
verbrauch = (10 * (np.mean(trafic.vehicle_ego.fuel_cons) / 0.05) - 1
) #*50#*100
travelled_distance = sum([c * 0.2 for c in v_episode])
travelled_distance_divisor = 1 / 1800 if travelled_distance == 0 else travelled_distance
abstand = np.sum([
1 for ii in range(len(v_episode)) if distance_episode[ii] < 2 *
v_episode[ii] * 3.6 and distance_episode[ii] > v_episode[ii] * 3.6
])
crash = int(SUMO.Collision)
#route_ende=int(SUMO.RouteEnd and not SUMO.maxtime)
speed = np.mean(v_episode) / features.v_allowed if np.mean(
v_episode) / features.v_allowed < 1 else 0
over_speed_limit = sum([
1 for jj in range(len(v_episode))
if v_episode[jj] > features.v_allowed
])
evil_acc = sum([
1 for kk in range(len(a_episode)) if abs(a_episode[kk].item()) > 4
])
travelled_distance_divisor = evil_acc + 1 if travelled_distance == 0 else travelled_distance
fitness = travelled_distance / 1800 + abstand / SUMO.step - crash + speed - 10 * over_speed_limit / SUMO.step - evil_acc / travelled_distance_divisor - 0.5 * verbrauch
genome[1].fitness = fitness[0].item()
# print(fitness)
output = fitness[0].item()
# cum_reward[episode] += reward
"""End of episode - prepare next episode ======================================================================
Reset position of vehicles by removing and (later) adding them again, call running plots and export data """
traci.close()
except Exception as ex:
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
output = 10000
traci.close()
# raise Exception('My error eval genome!', timestep, message)
return output
def calculate_features():
state = np.zeros([1, feature_number])
dynamics_ego = Longitudinal_dynamics(tau=0.5)
sub_ego = traci.vehicle.getSubscriptionResults(trafic.vehicle_ego.ID)
if SUMO.Collision: # collision happened!
features.distance = 0 # set the distance of the cars after a collision to 0
features.v_prec = SUMO.v_prec[
SUMO.
step] # set the velocity of the preceding car after a collision to the value of the previous timestep
features.v_ego = SUMO.v_ego[
SUMO.
step] # set the velocity of the ego car after a collision to the value of the previous timestep
elif SUMO.RouteEnd:
features.distance = SUMO.distance[
SUMO.
step] # set the distance of the cars after preceding vehicle ends route to previous timestep
features.v_prec = SUMO.v_prec[
SUMO.
step] # set the velocity of the preceding car after preceding vehicle ends route to the value of the previous timestep
features.v_ego = SUMO.v_ego[
SUMO.
step] # set the velocity of the ego car after preceding vehicle ends route to the value of the previous timestep
else:
## TLS Distance
if traci.constants.VAR_NEXT_TLS in sub_ego and len(
sub_ego[traci.constants.VAR_NEXT_TLS]) > 0:
features.distance_TLS = sub_ego[traci.constants.VAR_NEXT_TLS][0][2]
features.TLS_state = sub_ego[traci.constants.VAR_NEXT_TLS][0][3]
else:
features.distance_TLS = 1000 # TODO: Handling when no TLS ahead
features.TLS_state = None
## v_ego
features.v_ego = sub_ego[traci.constants.VAR_SPEED]
# print(dynamics_ego.fuel_cons_per_100km)
## fuel_consumption
trafic.vehicle_ego.fuel_cons[SUMO.step + 1] = sub_ego[
traci.constants.VAR_FUELCONSUMPTION] # in ml/s
# trafic.vehicle_ego.fuel_cons_ECMS[SUMO.step + 1] = dynamics_ego.fuel_cons_per_100km
# trafic.vehicle_ego.fuel_cons_ECMS_per_s[SUMO.step + 1] = dynamics_ego.fuel_cons_per_s
## distance, v_prec
try:
if traci.constants.VAR_LEADER in sub_ego:
trafic.vehicle_ego.ID_prec, features.distance = sub_ego[
traci.constants.VAR_LEADER]
SUMO.distance[SUMO.step + 1] = features.distance
features.distance = np.clip(features.distance, None, 250.)
features.v_prec = traci.vehicle.getSpeed(
trafic.vehicle_ego.ID_prec)
SUMO.v_prec[SUMO.step + 1] = features.v_prec
else:
raise TypeError
except TypeError:
features.distance = 250
SUMO.distance[SUMO.step + 1] = features.distance
SUMO.v_prec[SUMO.step + 1] = features.v_ego
trafic.vehicle_ego.ID_prec = 'none'
if features.distance == 250:
features.v_prec = copy(
features.v_ego
) # when no preceding car detected OR distance > 250 (clipped), set a 'virtual velocity' = v_ego
## correct distance, v_prec with virtual TLS vehicle
if trafic.TLS_virt_vehicle:
if features.TLS_state == 'y' or features.TLS_state == 'r':
if features.distance_TLS < features.distance:
features.distance = copy(features.distance_TLS)
features.v_prec = 0
## headway
if features.v_ego < 0.1:
features.headway = 10000.
else:
features.headway = features.distance / features.v_ego
## v_allowed
if traci.constants.VAR_LANE_ID in sub_ego:
features.v_allowed = traci.lane.getMaxSpeed(
sub_ego[traci.constants.VAR_LANE_ID])
else:
features.v_allowed = 33.33 # tempo limit set to 120 km/h when no signal received, unlikely to happen
## plotting variables
SUMO.headway[SUMO.step + 1] = features.headway
SUMO.v_ego[SUMO.step + 1] = features.v_ego
number_episodes) * 20 / 3.6 + 10 / 3.6
else:
SUMO.prec_train_amplitude = 25 / 3.6 # a=25/3.6
SUMO.prec_train_mean = 30 / 3.6 # c=30/3.6
SUMO.create_v_profile_prec(a=SUMO.prec_train_amplitude,
c=SUMO.prec_train_mean)
elif vehicle3_vprofile == 'emergstop':
SUMO.create_v_profile_emerg_stop()
else:
raise NameError('No valid velocity profile selected')
trafic.vehicle_ego = Vehicle(ego=True,
ID='ego',
RouteID='RouteID_ego',
Route=trafic.Route_Ego,
powertrain_concept='ICEV')
trafic.dynamics_ego = Longitudinal_dynamics(tau=0.5)
if trafic.vehicle2_exist:
trafic.vehicle_2 = Vehicle(ego=False,
ID='traffic.0',
RouteID='traci_route_traffic.0',
Route=trafic.Route_Traffic1)
if trafic.vehicle3_exist:
trafic.vehicle_3 = Vehicle(ego=False,
ID='traffic.1',
RouteID='traci_route_traffic.1',
Route=trafic.Route_Traffic2)
acc_controller = {}
# if controller == 'ACC' or controller == 'hybrid_a' or controller == 'DDPG_v':
# acc_controller = ACC_Controller(v_set=19.44, h_set=1, a_set_min=-10.) # instantiate ACC controller
# acc_controller.create_mode_map()
# if controller == 'DQN':