public override Solution Run()
{
Log($"Assign a path for each train ... ", Utils.Logging.LogEventArgs.MessageType.Info, false);
if (CurrentSolution.AssignPaths())
{
Log($"done.", Utils.Logging.LogEventArgs.MessageType.Success);
}
else
{
Log($"failed.", Utils.Logging.LogEventArgs.MessageType.Error);
}
// Only one iteration for this solver
{
Log(HorizontalLine);
Log($"Loop on trains and assign entry-exit times ... ");
var usedResources = new UsedResourceCollection();
ScheduleTrains(CurrentProblem, CurrentSolution.TrainRunsDic.Values.OrderBy(tr => tr.Train.MinEntryEarliest), usedResources);
var validation = CurrentSolution.Validate();
if (CurrentSolution.IsAdmissible) // Only consider admissible solution
{
Log($"Compute objective function ... ");
CurrentSolution.ComputeObjectiveFunction();
CompareWithBest(CurrentSolution);
}
else
{
Log(validation);
}
}
return(BestSolution);
}
public override Solution Run()
{
do
{
BasicSchedule(OrderedTrainRuns);
int subIter = 0;
int nbConflicts;
do
{
nbConflicts = IterativeConflictSolver.ScheduleTrains(CurrentProblem, OrderedTrainRuns);
Log($"Iteration {Iteration}: {nbConflicts} conflicts.");
} while (++subIter < SubIteration && nbConflicts > 0);
CurrentSolution.ComputeObjectiveFunction();
Log($"Iteration {Iteration}, Objective value {CurrentSolution.ObjectiveValue}");
CurrentSolution.Validate();
if (CurrentSolution.IsAdmissible) // Only consider admissible solution
{
CompareWithBest(CurrentSolution);
}
// Reorder trains and start again (unless optimal has been reached)
OrderedTrainRuns = CurrentSolution.TrainRunsDic.Values.OrderByDescending(tr => tr.ObjectiveValue).ToArray();
// We need a way to identify that some ordering has been used already. Hash of the array ?
} while (++Iteration < MaxIteration && (BestSolution == null || !BestSolution.IsOptimal));
return(BestSolution ?? CurrentSolution);
}
public override Solution Run()
{
do
{
BasicSchedule(OrderedTrainRuns);
var conflicts = CurrentSolution.GetConflicts();
foreach (var kvp in conflicts)
{
CurrentSolution.TrainRunsDic[kvp.Key].Order = kvp.Value.Count;
if (CurrentSolution.TrainRunsDic[kvp.Key].Route.Graph.PossiblePathsOrderedByPenalty.Length > 1)
{
Log($"Train {kvp.Key} has {CurrentSolution.TrainRunsDic[kvp.Key].Route.Graph.PossiblePathsOrderedByPenalty.Length-1} alternative routes");
}
}
// Schedule all trains with simple algorithm
var subIter = 0;
var nbConflicts = 0;
do
{
nbConflicts = IterativeConflictSolver.ScheduleTrains(CurrentProblem, CurrentSolution.TrainRunsDic.Values.OrderByDescending(tr => tr.Order));
// Log($"Iteration {subIter}: {nbConflicts} conflicts.");
} while (++subIter < SubIteration && nbConflicts > 0);
if (nbConflicts == 0) // Only consider admissible solution
{
CurrentSolution.ComputeObjectiveFunction();
Log($"Iteration {Iteration}, Objective value {CurrentSolution.ObjectiveValue}");
CompareWithBest(CurrentSolution);
}
if (BestSolution == null || !BestSolution.IsOptimal)
{
// Is there some route alternative
foreach (var kvp in conflicts)
{
if (CurrentSolution.TrainRunsDic[kvp.Key].SelectNextPath())
{
Log($"Train {kvp.Key}, changing route");
break;
}
}
}
} while (++Iteration < MaxIteration && (BestSolution == null || !BestSolution.IsOptimal));
return(BestSolution ?? CurrentSolution);
}
public override Solution Run()
{
do
{
// Assign path randomly
CurrentSolution.AssignRandomPaths();
// Simple Schedule
BasicSchedule(CurrentSolution.TrainRuns.OrderBy(tr => tr.Train.MinEntryEarliest));
// Detect conflicts
var conflicts = CurrentSolution.GetConflicts();
foreach (var c in conflicts)
{
CurrentSolution.TrainRunsDic[c.Key].IsScheduled = false;
}
// Apply simple algorithm for trains with no conflicts
var usedResources = new UsedResourceCollection();
DummySolver.ScheduleTrains(CurrentProblem, CurrentSolution.TrainRuns.Where(tr => tr.IsScheduled).OrderBy(tr => tr.Train.MinEntryEarliest), usedResources);
// Schedule conflicted trains
DummySolver.ScheduleTrains(CurrentProblem, CurrentSolution.TrainRuns.Where(tr => !tr.IsScheduled).OrderBy(tr => tr.Train.MinEntryEarliest), usedResources);
var validation = CurrentSolution.Validate();
if (CurrentSolution.IsAdmissible) // Only consider admissible solution
{
Log($"Compute objective function ... ");
CurrentSolution.ComputeObjectiveFunction();
CompareWithBest(CurrentSolution);
}
else
{
Log(validation);
}
} while (++Iteration < MaxIteration && !BestSolution.IsOptimal);
return(BestSolution);
}
public override Solution Run()
{
int nbConflicts = 0;
// Only one iteration for this solver
do
{
nbConflicts = ScheduleTrains(CurrentProblem, CurrentSolution.TrainRunsDic.Values
.OrderBy(tr => tr.Train.MinEntryEarliest).ThenBy(tr => tr.Train.MaxDelayPenalty));
Log($"Iteration {Iteration}: {nbConflicts} conflicts.");
CurrentSolution.Validate();
if (CurrentSolution.IsAdmissible) // Only consider admissible solution
{
Log($"Compute objective function ... ");
CurrentSolution.ComputeObjectiveFunction();
CompareWithBest(CurrentSolution);
break;
}
} while (++Iteration < MaxIteration && nbConflicts > 0);
return(BestSolution);
}