Example #1
0
 internal int CompararTramosSegunPosicion(InfoTramoParaOptimizacion t1, InfoTramoParaOptimizacion t2)
 {
     if (t1.IdTramo < t2.IdTramo)
     {
         return(-1);
     }
     else if (t1.IdTramo > t2.IdTramo)
     {
         return(1);
     }
     else
     {
         return(0);
     }
 }
Example #2
0
 internal int CompararTramosSegunReaccionario(InfoTramoParaOptimizacion t1, InfoTramoParaOptimizacion t2)
 {
     if (t1.ComparadorPrioridadOptimizacion > t2.ComparadorPrioridadOptimizacion)
     {
         return(1);
     }
     else if (t1.ComparadorPrioridadOptimizacion < t2.ComparadorPrioridadOptimizacion)
     {
         return(-1);
     }
     else
     {
         return(0);
     }
 }
        public InfoTramoParaOptimizacion(Tramo tramo, InfoTramoParaOptimizacion tramo_previo, int variacion_permitida, BuscarTramosConectadosEventHandler buscar_tramos)
        {
            this._explicacion_impuntualidad_base   = null;
            this._variacion_menos_maxima_comercial = variacion_permitida;
            this._variacion_mas_maxima_comercial   = variacion_permitida;
            this._variacion_aplicada = 0;
            this._tramo_abierto      = true;
            this._tramo_previo       = tramo_previo;
            this._tramo_original     = tramo;
            this._buscar_tramos      = buscar_tramos;

            if (tramo_previo != null)
            {
                tramo_previo.TramoSiguiente = this;
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="atraso_inicial">Atraso reaccionario inducido sobre el tramo</param>
        /// <param name="variacion_tramo_inicial">Variación evaluada sobre el tramo</param>
        /// <returns></returns>
        internal double EstimarAtrasoArbolPropagacion(double atraso_inicial, int variacion_tramo_inicial, int profundidad_evaluacion)
        {
            double atraso_propagado_arbol    = 0;
            InfoTramoParaOptimizacion actual = this;
            int variacion_original           = actual.VariacionAplicada;
            //Reaccionario corredido: considera atraso inicial, máxima holgura posible(considera itinerario programado con sus conexiones)
            double holgura_minima_atras  = ObtenerMinimaHolguraAtrasSimulada(variacion_tramo_inicial);
            double reaccionario_efectivo = Math.Max(0, atraso_inicial - holgura_minima_atras);
            double atrasoGenerado        = actual.ExplicacionImpuntualidadActual.AtrasoSinReaccionarios;
            double atrasoTotal           = reaccionario_efectivo + atrasoGenerado;

            atraso_propagado_arbol  += atrasoTotal;
            atraso_inicial           = atrasoTotal;
            actual.VariacionAplicada = variacion_tramo_inicial;
            if (profundidad_evaluacion > 0)
            {
                List <InfoConexionParaOptimizacion> tramos_con_conexiones_pairings  = this.InfoTramosPosterioresConectadosPairings;
                List <InfoConexionParaOptimizacion> tramos_con_conexiones_pasajeros = this.InfoTramosPosterioresConectadosPasajeros;
                foreach (InfoConexionParaOptimizacion tramo_conectado in tramos_con_conexiones_pairings)
                {
                    double atraso_propagado_rama = tramo_conectado._info_tramo.EstimarAtrasoArbolPropagacion(atraso_inicial, tramo_conectado._info_tramo.VariacionAplicada, profundidad_evaluacion - 1);
                    atraso_propagado_arbol += atraso_propagado_rama;
                }
                foreach (InfoConexionParaOptimizacion tramo_conectado in tramos_con_conexiones_pasajeros)
                {
                    int    minutos_proximo_vuelo    = tramo_conectado._info_tramo.TramoOriginal.GetMinutosProximoVuelo(tramo_conectado._info_tramo.TramoOriginal);
                    string estacion_actual          = tramo_conectado._info_tramo.TramoOriginal.TramoBase.Origen;
                    string matricula_actual         = tramo_conectado._info_tramo.TramoOriginal.TramoBase.Numero_Ac;
                    Avion  avion_actual             = tramo_conectado._info_tramo.TramoOriginal.GetAvion(matricula_actual);
                    int    turn_around_conexion_pax = avion_actual.GetAeropuerto(estacion_actual).Minutos_Conexion_Pax;
                    int    tiempo_programado_despegue_tramo_conexion = tramo_conectado._info_tramo.TramoOriginal.TInicialProg;
                    int    max_minutos_espera_aceptados = tramo_conectado._conexion.GetEspera(minutos_proximo_vuelo);
                    Tramo  tramo_previo_conex           = this.TramoOriginal;
                    double atraso_propagado             = atraso_inicial;
                    double atrasoEsperado  = Math.Max(0, tramo_previo_conex.TFinalProg + atraso_inicial + turn_around_conexion_pax - tiempo_programado_despegue_tramo_conexion);
                    bool   pierde_conexion = atrasoEsperado > max_minutos_espera_aceptados;

                    if (!pierde_conexion && atrasoEsperado > 0) //Propaga atraso
                    {
                        double atraso_propagado_rama = tramo_conectado._info_tramo.EstimarAtrasoArbolPropagacion(atrasoEsperado, tramo_conectado._info_tramo.VariacionAplicada, profundidad_evaluacion - 1);
                        atraso_propagado_arbol += atraso_propagado_rama;
                    }
                }
            }
            actual.VariacionAplicada = variacion_original;
            return(atraso_propagado_arbol);
        }
Example #5
0
 private void CargarTramos()
 {
     foreach (Avion a in ItinerarioBase.AvionesDictionary.Values)
     {
         _tramos_por_avion.Add(a.IdAvion, new List <InfoTramoParaOptimizacion>());
         Tramo aux = a.Tramo_Raiz;
         InfoTramoParaOptimizacion tramo_previo = null;
         while (aux != null)
         {
             InfoTramoParaOptimizacion tramo_new = new InfoTramoParaOptimizacion(aux, tramo_previo, _variacion_permitida, _buscar_tramos);
             tramo_previo = tramo_new;
             _tramos.Add(tramo_new.IdTramo, tramo_new);
             _tramos_por_avion[a.IdAvion].Add(tramo_new);
             aux = aux.Tramo_Siguiente;
         }
     }
 }
Example #6
0
        internal void DeshacerCambiosQueEmpeoranAtrasoPropagado(out int cambios, Dictionary <int, Dictionary <int, ExplicacionImpuntualidad> > historial, Dictionary <int, int> variacion_penultima, bool revisaPrimero)
        {
            //definir de manera flexible si hacer en análisis respecto a situación inicial o la inmediatamente anterior.
            cambios = 0;
            int index_ultimo    = historial.Count;
            int index_penultimo = historial.Count - 1;
            int index_ini       = revisaPrimero ? 1 : historial.Count - 1;

            //Estudiar forma de deshacer: mirando a tramo previo o no.
            foreach (string id_avion in _tramos_por_avion.Keys)
            {
                foreach (InfoTramoParaOptimizacion tramo in _tramos_por_avion[id_avion])
                {
                    int    id_tramo         = tramo.IdTramo;
                    double atraso_ultimo    = historial[index_ultimo][id_tramo].AtrasoTotal;
                    double atraso_penultimo = historial[index_penultimo][id_tramo].AtrasoTotal;
                    double atraso_inicial   = historial[index_ini][id_tramo].AtrasoTotal;
                    InfoTramoParaOptimizacion tramo_siguiente = tramo.TramoSiguiente;
                    while (tramo_siguiente != null && tramo_siguiente.VariacionAplicada == 0)
                    {
                        atraso_ultimo    += historial[index_ultimo][tramo_siguiente.IdTramo].AtrasoTotal;
                        atraso_penultimo += historial[index_penultimo][tramo_siguiente.IdTramo].AtrasoTotal;
                        atraso_inicial   += historial[index_ini][tramo_siguiente.IdTramo].AtrasoTotal;
                        tramo_siguiente   = tramo_siguiente.TramoSiguiente;
                    }
                    //Opcion: agregar rango de tolerancia
                    if (atraso_penultimo >= atraso_inicial && atraso_ultimo > atraso_inicial)
                    {
                        if (tramo.VariacionAplicada > 0)
                        {
                            cambios++;
                        }
                        tramo.VariacionAplicada = 0;
                    }
                    else if (atraso_penultimo <= atraso_inicial && atraso_penultimo < atraso_ultimo)
                    {
                        if (tramo.VariacionAplicada > 0)
                        {
                            cambios++;
                        }
                        tramo.VariacionAplicada = variacion_penultima[id_tramo];
                    }
                }
            }
        }
Example #7
0
 public int ObtenerMinimaVariacionAtrasTramo(InfoTramoParaOptimizacion info_tramo)
 {
     if (info_tramo.TramoPrevio != null)
     {
         Dictionary <int, int> holguras_tramos_anteriores = info_tramo.TramoOriginal.HolgurasAtrasParaCadaConexion;
         int ta_origen = info_tramo.TramoOriginal.TurnAroundMinimoOrigen;
         int minimo    = int.MaxValue;
         foreach (int id_tramo_destino in holguras_tramos_anteriores.Keys)
         {
             int aux_minima_variacion = holguras_tramos_anteriores[id_tramo_destino] - ta_origen - _tramos[id_tramo_destino].VariacionAplicada;
             if (aux_minima_variacion < minimo)
             {
                 minimo = aux_minima_variacion;
             }
         }
         return(minimo);
     }
     else
     {
         return(0);
     }
 }
        //Por ahora se evalúa solo el avión. Después será todo el sistema
        internal double EstimarAtrasoPropagadoAvion(double atraso_previo, int variacion_propuesta)
        {
            double atraso_propagado_global   = 0;
            InfoTramoParaOptimizacion actual = this;

            while (actual != null)
            {
                if (actual == this)
                {
                    double reaccionario   = Math.Max(0, atraso_previo - actual.TramoOriginal.MinutosMaximaVariacionAtras - (variacion_propuesta - actual.VariacionAplicadaTramoPrevio));
                    double atrasoGenerado = actual.ExplicacionImpuntualidadActual.AtrasoSinReaccionarios;
                    double atrasoTotal    = reaccionario + atrasoGenerado;
                    atraso_propagado_global += atrasoTotal;
                    atraso_previo            = atrasoTotal;
                }
                else if (actual == this.TramoSiguiente)
                {
                    double reaccionario   = Math.Max(0, atraso_previo - actual.TramoOriginal.MinutosMaximaVariacionAtras - (actual.VariacionAplicada - variacion_propuesta));
                    double atrasoGenerado = actual.ExplicacionImpuntualidadActual.AtrasoSinReaccionarios;
                    double atrasoTotal    = reaccionario + atrasoGenerado;
                    atraso_propagado_global += atrasoTotal;
                    atraso_previo            = atrasoTotal;
                }
                else
                {
                    double reaccionario   = Math.Max(0, atraso_previo - actual.TramoOriginal.MinutosMaximaVariacionAtras - (actual.VariacionAplicada - actual.VariacionAplicadaTramoPrevio));
                    double atrasoGenerado = actual.ExplicacionImpuntualidadActual.AtrasoSinReaccionarios;
                    double atrasoTotal    = reaccionario + atrasoGenerado;
                    atraso_propagado_global += atrasoTotal;
                    atraso_previo            = atrasoTotal;
                }
                actual = actual.TramoSiguiente;
            }

            return(atraso_propagado_global);
        }
 public InfoConexionParaOptimizacion(InfoTramoParaOptimizacion info_tramo, ConexionLegs conexion)
 {
     this._info_tramo = info_tramo;
     this._conexion   = conexion;
 }