Simulation.py

from Computer import Computer
from Distribution import Distribution
from Distribution import calculate_uniform
from Event import Event
from Interface import Interface
from Message import Message
from Processor import Processor
from Results import Results

class Simulation:
    """
    Clase Simulación. En esta clase se controla la simulación basada en eventos.
    En esta clase se implementan los métodos que se debe realizar para cada evento en específico (LMC1, LMC2, LMC3, SMC1, SMC2P1, SMC2P2, SCM3)
    """
    # Constructor
    def __init__(self):
        self.clock = 0.0                # Reloj de la simulacion
        self.number_of_runs = 0         # Cantidad de veces a ejecutar la simulacion
        self.simulation_time = 0.0      # Tiempo de simulacion por corrida
        self.max = 0.0                  # Valor utilizado como infinito (se cambia a 4 * Tiempo de simulacion)
        self.x1_probability = 0.0       # Probabilidad de X1
        self.x2_probability = 0.0       # Probabilidad de X2
        self.x3_probability = 0.0       # Probabilidad de X3

        self.distribution_list = {}     # Contiene D1, D2, D3, D4, D5 y D6
        self.event_list = {}            # Contiene la lista de eventos para programar
        self.message_list = []          # Contiene todos los mensajes que se crean en una corrida
        self.processor_list = []        # Contiene todos los procesadores utilizados en la simulacion
        self.LMC1_list = []             # Lista ordenada de mensajes que deben llegar a la computadora 1
        self.LMC2_list = []             # Lista ordenada de mensajes que deben llegar a la computadora 2
        self.LMC3_list = []             # Lista ordenada de mensajes que deben llegar a la computadora 3
        
        self.results = Results()        # Objeto que contiene los resultados de cada corrida

        self.interface = Interface()    # Instancia para utilizar la interfaz de consola
        self.computer_1 = None          # Instancia de la Computadora 1 de la Simulación
        self.computer_2 = None          # Instancia de la Computadora 2 de la Simulación
        self.computer_3 = None          # Instancia de la Computadora 3 de la Simulación

    def run(self):
        """
        Método de clase
        En este método se hace el procesamiento general de la simulación
        """
        # Se solicitan y obtienen los datos de inicio al usuario
        self.get_user_input()
        # Se crean los eventos iniciales
        self.createEvents()
        # Se crean las computadoras y sus procesadores
        self.createComputers()
        # Comienza las iteraciones por las n simulaciones indicadas por el usuario
        for i in range(self.number_of_runs):
            # Se imprime el número de simulación
            self.interface.print_number_of_run(i)
            # Se ingresan los primeros mensajes de llegada en la computadora 2 y 3 y se programan los eventos
            self.message_list.append(Message(0))
            self.message_list.append(Message(1))
            self.event_list["LMC2"].id_message = 0
            self.event_list["LMC3"].id_message = 1
            self.LMC2_list.append((0, 0))
            self.LMC3_list.append((1, 0))
            # Se relizan de manera cíclica todos los eventos de la simulación
            self.do_events()

            # Guardar datos para calcular estadisticas
            self.results.add_processor_busy_time(self.processor_list)
            self.results.add_messages_results(self.message_list)
            self.results.add_last_clock_of_run(self.clock)
            
            # Imprimir estadisticas de la corrida
            self.print_statistics(i)
            # Se reinican los datos para una nueva corrida
            self.reset_run()
        # Imprimir estadisticas finales
        self.print_final_statistics()
        
    def get_user_input(self):
        """
        Método de clase
        Se obtienen cada uno de los datos del usuario necesarios para la simulación
        """
        # Se le solicita al usuario la cantidad de simulaciones
        self.number_of_runs = self.interface.ask_number_of_runs()
        # Se le solicita al usuario el tiempo que debe durar cada simulación
        self.simulation_time = self.interface.ask_simulation_time()
        # Se fija el valor de max o infinito en la simulación
        self.max = 4 * self.simulation_time  # Actualiza el valor de max
        # Se piden los datos de cada una de las distribuciones
        self.set_simulation_distributions()

        # Se asignan las probabilidades de retorno o rechazo de un mensaje por parte de los procesadores
        self.x1_probability = self.interface.ask_x_probability(1)
        self.x2_probability = self.interface.ask_x_probability(2)
        self.x3_probability = self.interface.ask_x_probability(3)

    def set_simulation_distributions(self):
        """
        Método de clase
        Se inicializan cada una de las simulaciones y sus respectivos parámetros
        """
        # Se crea un diccionario para manejar los identificadores de cada distribución
        distribution_dictionary = {1: "Direct",
                                   2: "TLC",
                                   3: "Uniform",
                                   4: "Exponential",
                                   5: "Density"}
        # Se realiza la solicitud de los datos de cada una de las 6 distribuciones
        for i in range(6):
            dist = Distribution()
            # Se pregunta cual distribución desa asignar a la distribución de la simulación: D_i 
            option = self.interface.ask_distribution("D" + str(i+1))
            # Según la distribución señalada entonces se asígna el identificador
            dist.id = distribution_dictionary[option]
            # Se piden los parámetros que necesita la distribución elegida
            self.set_dist_parameters(dist)
            # Agrega la distribución al diccionario de distribuciones en su ubicación asociada
            self.distribution_list["D"+str(i+1)] = dist

    def set_dist_parameters(self, dist):
        """
        Método de clase
        Se inicializan los respectivos parámetros de la distribución: dist
        """
        if (dist.id == "Direct"): # ¿Es una distribución normal directa?
            # Se inicializan los parámetros miu y sigma^2
            parameters = self.interface.ask_normal()
            dist.miu = parameters[0]
            dist.sigma2 = parameters[1]
        elif (dist.id == "TLC"): # ¿Es una distribución normal por el método de convolución?
            # Se inicializan los parámetros miu y sigma^2
            parameters = self.interface.ask_normal()
            dist.miu = parameters[0]
            dist.sigma2 = parameters[1]
        elif (dist.id == "Uniform"): # ¿Es una distribución uniforme?
            # Se inicializan los parámetros a y b
            parameters = self.interface.ask_uniform()
            dist.a = parameters[0]
            dist.b = parameters[1]
        elif (dist.id == "Exponential"): # ¿Es una distribución exponencial?
            # Se inicializa el parámetro lambda
            parameters = self.interface.ask_exponential()
            dist.lambd = parameters
        else: # ¿Es una distribución de función de densidad?
            # Se inicializan los parámetros k, a y b
            parameters = self.interface.ask_density()
            dist.k = parameters[0]
            dist.a = parameters[1]
            dist.b = parameters[2]

    def createEvents(self):
        """
        Método de clase
        Se inicializan cada unos de los eventos que son necesarios para la simulación, los que tienen max están desprogramados
        y los que tienen el valor de 0 están programados al momento 0 del reloj
        """
        self.event_list["LMC1"] = (Event("LMC1", self.max))
        self.event_list["LMC2"] = (Event("LMC2", 0))
        self.event_list["LMC3"] = (Event("LMC3", 0))
        self.event_list["SMC1"] = (Event("SMC1", self.max))
        self.event_list["SMC2P1"] = (Event("SMC2P1", self.max))
        self.event_list["SMC2P2"] = (Event("SMC2P2", self.max))
        self.event_list["SMC3"] = (Event("SMC3", self.max))

    def createComputers(self):
        """
        Método de clase
        Se crean las computadoras y sus respectivos procesadores
        """
        # Se crea la computadora 1 y se inicializa su distribución de arribos en None y su identificador en 1
        self.computer_1 = Computer(1, None)
        # Se crea el procesador con identificador 0 y distribución de salida D6
        self.computer_1.add_processor(0, self.distribution_list["D6"])
        # Se agrega el procesador a la lista de procesadores
        self.processor_list.append(self.computer_1.processors_list[0])

        # Se crea la computadora 2 y se inicializa su distribución de arribos en D1 y su identificador en 2
        self.computer_2 = Computer(2, self.distribution_list["D1"])
        # Se crea el procesador con identificador 1 y distribución de salida D2
        self.computer_2.add_processor(1, self.distribution_list["D2"])
        # Se crea el procesador con identificador 2 y distribución de salida D3
        self.computer_2.add_processor(2, self.distribution_list["D3"])
        # Se agrega el procesador a la lista de procesadores
        self.processor_list.append(self.computer_2.processors_list[0])
        # Se agrega el procesador a la lista de procesadores
        self.processor_list.append(self.computer_2.processors_list[1])

        # Se crea la computadora 3 y se inicializa su distribución de arribos en D4 y su identificador en 3
        self.computer_3 = Computer(3, self.distribution_list["D4"])
        # Se crea el procesador con identificador 3 y distribución de salida D5
        self.computer_3.add_processor(3, self.distribution_list["D5"])
        # Se agrega el procesador a la lista de procesadores
        self.processor_list.append(self.computer_3.processors_list[0])

    def print_statistics(self, run_number):
        """
        Método de clase
        Se realiza la impresión de las estádisticas correspondientes al número de corrida señalado
        """
        # Se imprime el porcentaje de tiempo que pasó el procesador ocupado en general y con mensajes rechazados
        self.interface.print_percentage_processor_busy(self.results.percentage_processor_busy_time(run_number))
        self.interface.print_percentage_processor_busy_rejected(self.results.percentage_processor_busy_rejected(run_number))
        # Se imprime el porcentaje de mensajes rechazados
        self.interface.print_percentage_rejected_messages(self.results.percentage_rejected_messages(run_number))

        # Se imprime el promedio de tiempo en el sistema de un mensaje
        self.interface.print_mean_system_time(self.results.message_mean_system(run_number))
        # Se imprime el promedio de la cantidad de veces que fue devuelto un mensaje
        self.interface.print_mean_amount_returned(self.results.message_mean_returned(run_number))
        # Se imprime el promedio de tiempo en cola en el sistema de un mensaje
        self.interface.print_mean_queue_time(self.results.message_mean_queue(run_number))
        # Se imprime el promedio de tiempo en transmisión en el sistema de un mensaje
        self.interface.print_mean_transmission_time(self.results.message_mean_transmission(run_number))
        # Se imprime el promedio de tiempo en procesamiento en el sistema de un mensaje
        self.interface.print_percentage_in_processing_time(self.results.percentage_message_processing(run_number))

    def print_final_statistics(self):
        """
        Método de clase
        Realiza la impresión de todas las estadísticas finales
        """
        print("---------------------ESTADÍSTICAS FINALES---------------------\n")
        # Se imprime el porcentaje de tiempo que pasó el procesador ocupado en general y con mensajes rechazados
        self.interface.print_percentage_processor_busy(self.results.finished_percentage_processor_busy_time())
        self.interface.print_percentage_processor_busy_rejected(self.results.finished_percentage_processor_busy_rejected())
        # Se imprime el porcentaje de mensajes rechazados
        self.interface.print_percentage_rejected_messages(self.results.finished_percentage_rejected_messages())

        # Se imprime el promedio de tiempo en el sistema de un mensaje
        self.interface.print_mean_system_time(self.results.finished_message_mean_system())
        # Se imprime el promedio de la cantidad de veces que fue devuelto un mensaje
        self.interface.print_mean_amount_returned(self.results.finished_message_mean_returned())
        # Se imprime el promedio de tiempo en cola en el sistema de un mensaje
        self.interface.print_mean_queue_time(self.results.finished_message_mean_queue())
        # Se imprime el promedio de tiempo en transmisión en el sistema de un mensaje
        self.interface.print_mean_transmission_time(self.results.finished_message_mean_transmission())
        # Se imprime el promedio de tiempo en procesamiento en el sistema de un mensaje
        self.interface.print_percentage_in_processing_time(self.results.finished_percentage_message_processing())
        
        # Se imprime el intervalo de confianza para el tiempo promedio en el sistema de los mensajes rechazados
        self.interface.print_confidence_interval_rejected(self.results.rejected_confidence_interval())
        # Se imprime el intervalo de confianza para el tiempo promedio en el sistema de los mensajes enviados
        self.interface.print_confidence_interval_sent(self.results.sent_confidence_interval())
        # Se imprime el intervalo de confianza para el tiempo promedio en el sistema de todos los mensajes
        self.interface.print_confidence_interval_total(self.results.total_confidence_interval())

    def reset_run(self):
        """
        Método de clase
        Reinicia todos los valores para poder iniciar la siguiente simulación
        """
        # Limpia la lista de mensajes
        del self.message_list[:]

        # Limpia las listas ordenadas de mensajes por llegar a la computadora 1, 2 y 3
        self.LMC1_list.clear()
        self.LMC2_list.clear()
        self.LMC3_list.clear()

        # Reinicia el valor inicial de todos los eventos
        self.event_list["LMC1"].event_time = self.max
        self.event_list["LMC2"].event_time = 0
        self.event_list["LMC3"].event_time = 0
        self.event_list["SMC1"].event_time = self.max
        self.event_list["SMC2P1"].event_time = self.max
        self.event_list["SMC2P2"].event_time = self.max
        self.event_list["SMC3"].event_time = self.max

        # Reinicia los valores de cada procesador
        for processor in self.processor_list:
            processor.busy_status = False
            processor.processing_time = 0.0
            processor.last_registered_clock = 0.0
        
        # Limpia las colas de mensajes
        self.computer_1.queued_messages.clear()
        self.computer_2.queued_messages.clear()
        self.computer_3.queued_messages.clear()

    def do_events(self):
        """
        Método de clase
        Se realiza la ejecución correspondiente a una simulación
        """
        # Se indica que no ha terminado la corrida de la simulación
        run_finished = False
        while(run_finished == False): # ¿No ha acabado la corrida de la simulación?
            # Obtenga el mínimo de los eventos
            min_ocurrence_event = min(self.event_list, key=lambda x: self.event_list[x].event_time)

            if (min_ocurrence_event == "LMC1"): # ¿Es el evento LMC1?
                # Realice el evento
                self.do_LMC1_event()
            elif(min_ocurrence_event == "LMC2"): # ¿Es el evento LMC2?
                # Realice el evento
                self.do_LMC2_event()
            elif(min_ocurrence_event == "LMC3"): # ¿Es el evento LMC3?
                # Realice el evento
                self.do_LMC3_event()
            elif(min_ocurrence_event == "SMC1"): # ¿Es el evento SMC1?
                # Realice el evento
                self.do_SMC1_event()
            elif(min_ocurrence_event == "SMC2P1"): # ¿Es el evento SMC2P1?
                # Realice el evento
                self.do_SMC2P1_event()
            elif(min_ocurrence_event == "SMC2P2"): # ¿Es el evento SMC2P2?
                # Realice el evento
                self.do_SMC2P2_event()
            elif(min_ocurrence_event == "SMC3"): # ¿Es el evento SMC3?
                # Realice el evento
                self.do_SMC3_event()

            if (self.clock >= self.simulation_time): # ¿Acabo el tiempo de simulación?
                # indique que la simulación ya acabó
                run_finished = True
        
        # Actualice el tiempo de procesamiento de los procesadores que no terminaron de procesar
        self.update_remaining_processing_times()
        
    def update_remaining_processing_times(self):
        """
        Método de clase
        Se actualizan los tiempos de procesamiento de cada uno de los procesadores que no terminaron de trabajar al final
        de la simulación
        """
        # Recorra cada uno de los procesadores
        for processor in self.processor_list:
            if processor.busy_status == True: # ¿El procesador estaba trabajando cuando terminó la simulación?
                # Actualice su tiempo de procesamiento
                processor.update_processing_time(self.clock)

    def do_LMC1_event(self):
        """
        Este es el método que ejecuta el evento llega mensaje a la computadora 1
        """
        # Se actualiza el reloj al tiempo del evento
        self.clock = self.event_list["LMC1"].event_time
        # Se obtiene el mensaje que está llegando a la computadora 1
        event_message = self.message_list[self.event_list["LMC1"].id_message]
        # Se suma el tiempo de transmisión al tiempo del mensaje en el sistema y en transmisión
        event_message.system_time += 20.0
        event_message.transmission_time += 20.0
        
        if (self.computer_1.processors_list[0].busy_status == False):  # ¿Está el procesador libre?
            # Se asigna el procesador
            assigned_processor = self.computer_1.processors_list[0]
            # Se programa el evento para que el procesador seleccionado procese el mensaje
            self.event_list["SMC1"].event_time = self.clock + assigned_processor.output_distribution.calculate()
            self.event_list["SMC1"].id_message = event_message.id
            # Se cambia el estado del procesador a ocupado
            assigned_processor.busy_status = True
            # Se guarda el momento en el que el mensaje empezó a ser procesado
            event_message.last_registered_clock = self.clock
            # Se guarda el momento en el que el procesador empezó a procesar el mensaje
            assigned_processor.last_registered_clock = self.clock
        else:
            # Se ingresa el mensaje a la cola de la computadora
            self.computer_1.add_queued_message(event_message.id)
            # Se guarda el momento en el que el mensaje empezó a esperar en cola
            event_message.last_registered_clock = self.clock
        
        # Se saca de la lista ordenada de mensajes que deben llegar a la computadora 1 el mensaje que ya se procesó o puso en cola
        self.LMC1_list.remove((event_message.id, self.clock))
        
        if (len(self.LMC1_list) != 0):
            # Se busca el próximo mensaje que tiene que llegar a la computadora 1
            next_event_parameters = min(self.LMC1_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
            # Se programa el siguiente Evento LMC1
            self.event_list["LMC1"].id_message = next_event_parameters[0]
            self.event_list["LMC1"].event_time = next_event_parameters[1]
        else:
            # Se desprograma el evento LMC1
            self.event_list["LMC1"].event_time = self.max

    def do_LMC2_event(self):
        """
        Este es el método que ejecuta el evento llega mensaje a la computadora 2
        """
        # Se actualiza el reloj al tiempo del evento
        self.clock = self.event_list["LMC2"].event_time
        # Se obtiene el mensaje que está llegando a la computadora 2
        event_message = self.message_list[self.event_list["LMC2"].id_message]
        
        if (event_message.last_computer == 0):  # ¿Es un mensaje nuevo?
            # Se asigna a la computadora 2 como la primera computadora del mensaje
            event_message.first_computer = 2
            # Se programa el próximo mensaje nuevo que debe llegar a la computadora 2
            new_message = Message(len(self.message_list))
            new_message_time = self.clock + self.computer_2.input_distribution.calculate()
            self.LMC2_list.append((new_message.id, new_message_time))
            self.message_list.append(new_message)
        else:  # ¿Es un mensaje devuelto desde la computadora 1?
            # Se suma el tiempo de transmisión al tiempo del mensaje en el sistema y en transmisión
            event_message.system_time += 3.0
            event_message.transmission_time += 3.0
            # Se incrementa en 1 la cantidad de veces que fue retornado el mensaje
            event_message.amount_returned += 1
        
        assigned_processor = None
        if (self.computer_2.processors_list[0].busy_status == False and self.computer_2.processors_list[1].busy_status == False):  # ¿Están los dos procesadores libres?
            # Se calcula con probalidad 50/50 a cual procesador se le asigna el mensaje para que lo procese
            random_number = calculate_uniform(0, 99) # Utiliza método propio de generación de aleatorios con distribución uniforme
            if(random_number < 50):
                assigned_processor = self.computer_2.processors_list[0]
            else:
                assigned_processor = self.computer_2.processors_list[1]
        elif (self.computer_2.processors_list[0].busy_status == False):  # ¿Está el procesador 1 libre?
            # Se asigna el procesador 1
            assigned_processor = self.computer_2.processors_list[0]
        elif (self.computer_2.processors_list[1].busy_status == False):  # ¿Está el procesador 2 libre?
            # Se asigna el procesador 2
            assigned_processor = self.computer_2.processors_list[1]
        # ¿Ninguno está libre?
        # Se mantiene: assigned_processor = None
        
        if(assigned_processor != None):  # ¿Existía un procesador libre?
            # Se programa el evento para que el procesador seleccionado procese el mensaje
            event_str = "SMC2P" + str(assigned_processor.id)
            self.event_list[event_str].event_time = self.clock + assigned_processor.output_distribution.calculate()
            self.event_list[event_str].id_message = event_message.id
            # Se cambia el estado del procesador a ocupado
            assigned_processor.busy_status = True
            # Se guarda el momento en el que el mensaje empezó a ser procesado
            event_message.last_registered_clock = self.clock
            # Se guarda el momento en el que el procesador empezó a procesar el mensaje
            assigned_processor.last_registered_clock = self.clock
        else:
            # Se ingresa el mensaje a la cola de la computadora
            self.computer_2.add_queued_message(event_message.id)
            # Se guarda el momento en el que el mensaje empezó a esperar en cola
            event_message.last_registered_clock = self.clock
        
        # Se saca de la lista ordenada de mensajes que deben llegar a la computadora 2 el mensaje que ya se procesó o puso en cola
        self.LMC2_list.remove((event_message.id, self.clock))
        
        # Se busca el próximo mensaje que tiene que llegar a la computadora 2
        next_event_parameters = min(self.LMC2_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
        # Se programa el siguiente Evento LMC2
        self.event_list["LMC2"].id_message = next_event_parameters[0]
        self.event_list["LMC2"].event_time = next_event_parameters[1]

    def do_LMC3_event(self):
        """
        Este es el método que ejecuta el evento llega mensaje a la computadora 3
        """
        # Se actualiza el reloj al tiempo del evento
        self.clock = self.event_list["LMC3"].event_time
        # Se obtiene el mensaje que está llegando a la computadora 3
        event_message = self.message_list[self.event_list["LMC3"].id_message]

        if (event_message.last_computer == 0):  # ¿Es un mensaje nuevo?
            # Se asigna a la computadora 3 como la primera computadora del mensaje
            event_message.first_computer = 3
            # Se programa el próximo mensaje nuevo que debe llegar a la computadora 3
            new_message = Message(len(self.message_list))
            new_message_time = self.clock + self.computer_3.input_distribution.calculate()
            self.LMC3_list.append((new_message.id, new_message_time))
            self.message_list.append(new_message)
        else:  # ¿Es un mensaje devuelto desde la computadora 1?
            # Se suma el tiempo de transmisión al tiempo del mensaje en el sistema y en transmisión
            event_message.system_time += 3.0
            event_message.transmission_time += 3.0
            # Se incrementa en 1 la cantidad de veces que fue retornado el mensaje
            event_message.amount_returned += 1
        
        if (self.computer_3.processors_list[0].busy_status == False):  # ¿Está el procesador libre?
            # Se asigna el procesador
            assigned_processor = self.computer_3.processors_list[0]
            # Se programa el evento para que el procesador seleccionado procese el mensaje
            self.event_list["SMC3"].event_time = self.clock + assigned_processor.output_distribution.calculate()
            self.event_list["SMC3"].id_message = event_message.id
            # Se cambia el estado del procesador a ocupado
            assigned_processor.busy_status = True
            # Se guarda el momento en el que el mensaje empezó a ser procesado
            event_message.last_registered_clock = self.clock
            # Se guarda el momento en el que el procesador empezó a procesar el mensaje
            assigned_processor.last_registered_clock = self.clock
        else:
            # Se ingresa el mensaje a la cola de la computadora
            self.computer_3.add_queued_message(event_message.id)
            # Se guarda el momento en el que el mensaje empezó a esperar en cola
            event_message.last_registered_clock = self.clock
        
        # Se saca de la lista ordenada de mensajes que deben llegar a la computadora 3 el mensaje que ya se procesó o puso en cola
        self.LMC3_list.remove((event_message.id, self.clock))
        
        # Se busca el próximo mensaje que tiene que llegar a la computadora 3
        next_event_parameters = min(self.LMC3_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
        # Se programa el siguiente Evento LMC2
        self.event_list["LMC3"].id_message = next_event_parameters[0]
        self.event_list["LMC3"].event_time = next_event_parameters[1]

        

    def do_SMC1_event(self):
        """
        Este es el método que ejecuta el evento sale mensaje de la computadora 1
        """
        # Se actualiza el reloj al tiempo del evento
        self.clock = self.event_list["SMC1"].event_time
        # Se obtiene el mensaje que debe salir de la computadora 1
        event_message = self.message_list[self.event_list["SMC1"].id_message]
        # Se actualiza el tiempo en el sistema del mensaje
        event_message.update_system_time(self.clock)
        # Se actualiza el tiempo que duró el mensaje procesándose en la computadora 1
        event_message.update_processing_time_1(self.clock)
        # Se actualiza el tiempo que duró procesando el mensaje la computadora 1
        self.computer_1.processors_list[0].update_processing_time(self.clock)
        
        # Se toma un aleatorio de 0 a 99 para calcular la probabilidad X1 y X3 de que se devuelva el mensaje a su respectiva computadora
        random_number = calculate_uniform(0,99)
        if (event_message.last_computer == 2):  # ¿El mensaje viene de la computadora 2? 
            if(random_number < self.x1_probability):  # ¿Se tiene que devolver el mensaje a la computadora 2?
                # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 2 el mensaje a devolver
                next_message_time = self.clock + 3.0
                self.LMC2_list.append((event_message.id, next_message_time))
                # Se busca el próximo mensaje que tiene que llegar a la computadora 2
                next_event_parameters = min(self.LMC2_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
                # Se programa el evento LMC2
                self.event_list["LMC2"].id_message = next_event_parameters[0]
                self.event_list["LMC2"].event_time = next_event_parameters[1]
            else:  # ¿El mensaje debe de enviarse?
                # Se realiza el envío del mensaje
                event_message.send()
        elif (event_message.last_computer == 3):  # ¿El mensaje viene de la computadora 3?
            if (random_number < self.x3_probability):  # ¿Se tiene que devolver el mensaje a la computadora 3?
                # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 3 el mensaje a devolver
                next_message_time = self.clock + 3.0
                self.LMC3_list.append((event_message.id, next_message_time))
                # Se busca el próximo mensaje que tiene que llegar a la computadora 3
                next_event_parameters = min(self.LMC3_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
                # Se programa el evento LMC3
                self.event_list["LMC3"].id_message = next_event_parameters[0]
                self.event_list["LMC3"].event_time = next_event_parameters[1]
            else:  # ¿El mensaje debe de enviarse?
                # Se realiza el envío del mensaje
                event_message.send()
        
        # Se asigna la computadora 1 como la última en la que ha estado el mensaje
        event_message.last_computer = 1
        
        if (len(self.computer_1.queued_messages) == 0):  # ¿La cola de la computadora 1 está vacía?
            # Se Se cambia el estado del procesador a libre y se desprograma el evento SMC1
            self.computer_1.processors_list[0].busy_status = False
            self.event_list["SMC1"].event_time = self.max
        else:  # ¿La cola de la computadora 1 tiene algún mensaje?
            #  Se toma el mensaje a ser procesado
            next_message_to_process_id = self.computer_1.pop_queued_message()
            next_message_to_process = self.message_list[next_message_to_process_id]
            # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar
            next_message_to_process.update_queue_time(self.clock)
            next_message_to_process.update_system_time(self.clock)
            # Se programa el evento SMC1
            self.event_list["SMC1"].event_time = self.clock + self.computer_1.processors_list[0].output_distribution.calculate()
            self.event_list["SMC1"].id_message = next_message_to_process_id
            # Se guarda el momento en el que el mensaje empezó a ser procesado
            next_message_to_process.last_registered_clock = self.clock
            # Se guarda el momento en el que el procesador empezó a procesar el mensaje
            self.computer_1.processors_list[0].last_registered_clock = self.clock

    def do_SMC2P1_event(self):
        """
        Este es el método que ejecuta el evento sale mensaje del procesador 1 computadora 2
        """    
        # Se actualiza el reloj al tiempo del evento
        self.clock = self.event_list["SMC2P1"].event_time
        # Se obtiene el mensaje que debe salir del procesador 1 de la computadora 2
        event_message = self.message_list[self.event_list["SMC2P1"].id_message]
        # Se actualiza el tiempo en el sistema del mensaje
        event_message.update_system_time(self.clock)
        # Se actualiza el tiempo que duró el mensaje procesándose en el procesador 1 de la computadora 2
        event_message.update_processing_time_2(self.clock)
        # Se actualiza el tiempo que duró procesando el mensaje el procesador 1 de la computadora 2
        self.computer_2.processors_list[0].update_processing_time(self.clock)
        # Se asigna la computadora 2 como la última en la que ha estado el mensaje
        event_message.last_computer = 2
        # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 1 el mensaje a enviar
        next_message_time = self.clock + 20.0
        self.LMC1_list.append((event_message.id, next_message_time))
        # Se busca el próximo mensaje que tiene que llegar a la computadora 1
        next_event_parameters = min(self.LMC1_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
        # Se programa el evento LMC1
        self.event_list["LMC1"].id_message = next_event_parameters[0]
        self.event_list["LMC1"].event_time = next_event_parameters[1]
        
        if (len(self.computer_2.queued_messages) == 0):  # ¿La cola de la computadora 2 está vacía?
            # Se cambia el estado del procesador a libre y se desprograma el evento SMC2P1
            self.computer_2.processors_list[0].busy_status = False
            self.event_list["SMC2P1"].event_time = self.max
        else:  # ¿La cola de la computadora 2 tiene algún mensaje?
            # Se toma el mensaje a ser procesado
            next_message_to_process_id = self.computer_2.pop_queued_message()
            next_message_to_process = self.message_list[next_message_to_process_id]
            # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar
            next_message_to_process.update_queue_time(self.clock)
            next_message_to_process.update_system_time(self.clock)
            # Se programa el evento SMC2P1
            self.event_list["SMC2P1"].event_time = self.clock + self.computer_2.processors_list[0].output_distribution.calculate()
            self.event_list["SMC2P1"].id_message = next_message_to_process_id
            # Se guarda el momento en el que el mensaje empezó a ser procesado
            next_message_to_process.last_registered_clock = self.clock
            # Se guarda el momento en el que el procesador empezó a procesar el mensaje
            self.computer_2.processors_list[0].last_registered_clock = self.clock

    def do_SMC2P2_event(self):
        """
        Este es el método que ejecuta el evento sale mensaje del procesador 2 computadora 2
        """ 
        # Se actualiza el reloj al tiempo del evento
        self.clock = self.event_list["SMC2P2"].event_time
        # Se obtiene el mensaje que debe salir del procesador 2 de la computadora 2
        event_message = self.message_list[self.event_list["SMC2P2"].id_message]
        # Se actualiza el tiempo en el sistema del mensaje
        event_message.update_system_time(self.clock)
        # Se actualiza el tiempo que duró el mensaje procesándose en el procesador 2 de la computadora 2
        event_message.update_processing_time_2(self.clock)
        # Se actualiza el tiempo que duró procesando el mensaje el procesador 2 de la computadora 2
        self.computer_2.processors_list[1].update_processing_time(self.clock)
        # Se asigna la computadora 2 como la última en la que ha estado el mensaje
        event_message.last_computer = 2
        # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 1 el mensaje a enviar
        next_message_time = self.clock + 20.0
        self.LMC1_list.append((event_message.id, next_message_time))
        # Se busca el próximo mensaje que tiene que llegar a la computadora 1
        next_event_parameters = min(self.LMC1_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
        # Se programa el evento LMC1
        self.event_list["LMC1"].id_message = next_event_parameters[0]
        self.event_list["LMC1"].event_time = next_event_parameters[1]
        
        if (len(self.computer_2.queued_messages) == 0):  # ¿La cola de la computadora 2 está vacía?
            # Se cambia el estado del procesador a libre y se desprograma el evento SMC2P2
            self.computer_2.processors_list[1].busy_status = False
            self.event_list["SMC2P2"].event_time = self.max
        else:  # ¿La cola de la computadora 2 tiene algún mensaje?
            # Se toma el mensaje a ser procesado
            next_message_to_process_id = self.computer_2.pop_queued_message()
            next_message_to_process = self.message_list[next_message_to_process_id]
            # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar
            next_message_to_process.update_queue_time(self.clock)
            next_message_to_process.update_system_time(self.clock)
            # Se programa el evento SMC2P2
            self.event_list["SMC2P2"].event_time = self.clock + self.computer_2.processors_list[1].output_distribution.calculate()
            self.event_list["SMC2P2"].id_message = next_message_to_process_id
            # Se guarda el momento en el que el mensaje empezó a ser procesado
            next_message_to_process.last_registered_clock = self.clock
            # Se guarda el momento en el que el procesador empezó a procesar el mensaje
            self.computer_2.processors_list[1].last_registered_clock = self.clock
    
    def do_SMC3_event(self):
        """
        Este es el método que ejecuta el evento sale mensaje de la computadora 3
        """
        # Se actualiza el reloj al tiempo del evento
        self.clock = self.event_list["SMC3"].event_time
        # Se obtiene el mensaje que debe salir de la computadora 3
        event_message = self.message_list[self.event_list["SMC3"].id_message]
        # Se actualiza el tiempo en el sistema del mensaje
        event_message.update_system_time(self.clock)
        # Se actualiza el tiempo que duró el mensaje procesándose en la computadora 3
        event_message.update_processing_time_3(self.clock)
        # Se actualiza el tiempo que duró procesando el mensaje el procesador de la computadora 3
        self.computer_3.processors_list[0].update_processing_time(self.clock)
        # Se asigna la computadora 3 como la última en la que ha estado el mensaje
        event_message.last_computer = 3

        # Se toma un aleatorio de 0 a 99 para calcular la probabilidad X2 de que se rechace un mensaje
        random_number = calculate_uniform(0,99)

        if(random_number < self.x2_probability): # ¿Se debe rechazar el mensaje?
            # Se rechaza el mensaje
            event_message.reject()
        else: # Se envía el mensaje a la computadora 1
            # Agrega en la Lista Ordenada de mensajes que deben de llegar a la computadora 1
            next_message_time = self.clock + 20.0
            self.LMC1_list.append((event_message.id, next_message_time))
            # Se busca el próximo mensaje que tiene que llegar a la computadora 1
            next_event_parameters = min(self.LMC1_list, key= lambda x: x[1]) # Devuelve (id_mensaje, tiempo_ocurrencia)
            # Se programa el evento LMC1
            self.event_list["LMC1"].id_message = next_event_parameters[0]
            self.event_list["LMC1"].event_time = next_event_parameters[1]
        
        if (len(self.computer_3.queued_messages) == 0):  # ¿La cola de la computadora 3 está vacía?
            # Se cambia el estado del procesador a libre y se desprograma el evento SMC3
            self.computer_3.processors_list[0].busy_status = False
            self.event_list["SMC3"].event_time = self.max
        else:  # ¿La cola de la computadora 3 tiene algún mensaje?
            # Se toma el mensaje a ser procesado
            next_message_to_process_id = self.computer_3.pop_queued_message()
            next_message_to_process = self.message_list[next_message_to_process_id]
            # Se le actualizan los tiempo en cola y en el sistema al mensaje por procesar
            next_message_to_process.update_queue_time(self.clock)
            next_message_to_process.update_system_time(self.clock)
            # Se programa el evento SMC3
            self.event_list["SMC3"].event_time = self.clock + self.computer_3.processors_list[0].output_distribution.calculate()
            self.event_list["SMC3"].id_message = next_message_to_process_id
            # Se guarda el momento en el que el mensaje empezó a ser procesado
            next_message_to_process.last_registered_clock = self.clock
            # Se guarda el momento en el que el procesador empezó a procesar el mensaje
            self.computer_3.processors_list[0].last_registered_clock = self.clock
            
            