\\
def run_And_Update_States(self):

    #this method is responsible for running a one step iteration and updating the states
    #a one step iteration can be every X int amount of simulation steps, depending on how often this method is called





    #note: the way this works is by taking one action per dqn_agent per timestep, which is necessary
    #as I'm running multiple agents within the same environment, then executing the action and then updating
    #the reward through observe the next time step. To do so, it's important to distinguish between the first step and every other step. It isn't possible to return the
    #reward immediately from the environment for the current action before at least executing one simulation step, this is because we have to wait for the other agents to take
    #their actions as well

    reward = 0

    #update queues and variables
    self.update_TLS_Queues()


    if  self.previous_State is None and self.current_State is None:
        #first call of this method --> first step
        print("***First step***")
        self.current_State = self.Get_State()
        self.current_Action = self.choose_action(self.current_State)
        self.action_changed = True
        self.action_counter += 1
    else:
        #not the first time this method is called, i.e. we've already taken at least 1 action --> we can update memory + accumulate reward for previously taken action



        #update previous state and current state
        self.previous_State = self.current_State
        self.current_State = self.Get_State()
        self.previous_Action = self.current_Action #the previously taken action is now stored in its own varibale, so we can correlate between state, action, next state and reward



        #retrieve and save info about terminal state
        terminal = False
        if (traci.simulation.getMinExpectedNumber() == 0):
            terminal = True
            print("***Terminal state reached, ending episode for "+ self.TLS_ID)

        if(self.ack_Count != 0):
            # acknowledgements since last timestep

            avg_Travel_Time = float (avg_Travel_Time) / float(self.ack_Count)
            print("Avg travel time for %s is %d" %(self.TLS_ID,avg_Travel_Time ))
            reward = self.Evaluate_Reward(avg_Travel_Time, self.ack_Count)

        else:
            #no acknowledgements since last timestep

            reward = self.Evaluate_Reward(1,0)
            self.Total_reward += reward


        print("Action_Counter = %d & Observe_Counter = %d" %(self.action_counter, self.observe_counter))

        #pass info about terminal state to agent, 0 reward + true on terminal state
        update_bool = self._model.DQN_Agent.observe(reward = reward, terminal = terminal)
        self.observe_counter += 1

        if(update_bool):
            #print when an update occurs
            print("Model with TLS ID # "+ self.TLS_ID + "was updated at timestep = %d" + self.step )
        self.Total_reward += reward

    #take action
        if not(traci.simulation.getMinExpectedNumber() == 0):
            self.current_Action = self.choose_action(self.current_State) #action to take in this timestep
            self.action_counter += 1

    #the change in phase is set from inside the run() method so we can keep track of the number of steps spent in the yellow phase before switching
        if(self.current_Action == self.previous_Action):
            self.action_changed = False


        else:
            self.action_changed = True

    self._steps +=1
    print(self.TLS_ID)
    print("**Previous action:")
    print(self.previous_Action)
    print("**Current action:")
    print(self.current_Action)
    print("**Action changed bool:")
    print(self.action_changed)

\\