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); } }
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); }
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; } } }
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]; } } } }
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; }