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