/// <summary>
/// Calculates the transfers.
/// </summary>
/// <param name="timetable">The timetable.</param>
/// <param name="line">The line.</param>
/// <param name="startTime">The start time.</param>
/// <returns></returns>
private CurrentState calculateTransfers(Timetable timetable, TrainLineVariable line, Time startTime)
{
// Changes, in case we need to revert the state (it is worse than the current one).
List <Change> changes = new List <Change>();
//////SET SELECED LINES
// Set the start time for the given line.
changes.Add(new Change(line, line.StartTime));
line.StartTime = startTime;
///SET ALL CONNECTED LINES
// Set the appropriate start time for each connected variable.
foreach (TrainLineVariable connectedVariable in line.ConnectedLinesVariable)
{
// Set the start for variable.
changes.Add(new Change(line, line.StartTime));
connectedVariable.StartTime = startTime - connectedVariable.Line.ConnectedLineShift;
connectedVariable.StartTime = PeriodUtil.normalizeTime(connectedVariable.StartTime, connectedVariable.Period);
}
// Compute the factor.
int factor = Timetable.calculateTimetableRatingValue(timetable);
// Current state returned.
return(new CurrentState(changes, factor));
}
/// <summary>
/// Adds the variable line.
/// </summary>
/// <param name="line">The variable train line.</param>
public void addVariableLine(TrainLineVariable line)
{
if (!doesVariableLineExist(variableLines, line.LineNumber))
{
variableLines.Add(line);
}
}
/// <summary>
/// Creates the train line variables independent on solution.
/// </summary>
/// <param name="solution">The solution.</param>
/// <param name="trainLineMap">The train line map.</param>
/// <returns>Train line variables.</returns>
private static List <TrainLineVariable> createTrainLineVariablesIndependentOnSolution(Solution solution, List <TrainLine> trainLineMap)
{
// retreive all lines from train line cache
List <TrainLine> allLines = TrainLineCache.getInstance().getCacheContent();
// new train lines variable
List <TrainLineVariable> trainLineVariables = new List <TrainLineVariable>();
// if not all lines already contained, otherwise return
if (allLines.Count != trainLineMap.Count)
{
foreach (TrainLine line in allLines)
{
// if line is not contained in trian line map
if (!containsTrainLine(trainLineMap, line))
{
// create new line of timetable
TrainLineVariable tlv = new TrainLineVariable(line);
// set independent start time
tlv.StartTime = Time.MinValue;
// add
trainLineVariables.Add(tlv);
}
}
}
return(trainLineVariables);
}
/// <summary>
/// Creates the train line variables dependent on solution.
/// </summary>
/// <param name="solution">The solution.</param>
/// <param name="trainLineMap">The train line map.</param>
/// <returns>Train line variables.</returns>
private static List <TrainLineVariable> createTrainLineVariablesDependentOnSolution(Solution solution, List <TrainLine> trainLineMap)
{
// new train lines variable
List <TrainLineVariable> newTrainLineVariables = new List <TrainLineVariable>();
// loop index
int index = 0;
// for all mapped line at solution
foreach (TrainLine line in trainLineMap)
{
// create a trainLine
TrainLineVariable tlv = new TrainLineVariable(line);
//initialize fields
Time normalizeTime = PeriodUtil.normalizeTime(Time.ToTime(solution.SolutionVector[index].Minute), line.Period);
tlv.StartTime = normalizeTime;
//tlv.RatingValue = solution.SolutionFactor;
// add to the list
newTrainLineVariables.Add(tlv);
// increment index
index++;
}
return(newTrainLineVariables);
}
/// <summary>
/// Calculates the transfer.
/// </summary>
/// <param name="timetable">The timetable.</param>
/// <param name="transfer">The transfer.</param>
/// <returns></returns>
public static int calculateTransfer(Timetable timetable, Transfer transfer)
{
// result rating value
int ratingValue;
TrainLineVariable onLine = timetable.getVariableLineOnSelect(transfer.OnLine.LineNumber);
TrainLineVariable offLine = timetable.getVariableLineOnSelect(transfer.OffLine.LineNumber);
// varline startime, departure from start of line, connected line shif of line
Time arrivalTime = offLine.StartTime + offLine.arrivalToStopAtIndex(transfer.TrainStopIndexOffLine);
Time departureTime = onLine.StartTime + onLine.departureFromStopAtIndex(transfer.TrainStopIndexOnLine);
normalizeTransferTime(ref departureTime, ref arrivalTime, transfer.Station.MinimalTransferTime, (int)onLine.Period, (int)offLine.Period);
ratingValue = transfer.evaluateTransferFunction(departureTime - arrivalTime);
return(ratingValue);
}
/// <summary>
/// Finds the variable line from specified lines.
/// </summary>
/// <param name="lines">The lines.</param>
/// <param name="lineNumber">The line number.</param>
/// <returns>The variable train line.</returns>
public static TrainLineVariable findVariableLine(List <TrainLineVariable> lines, int lineNumber)
{
TrainLineVariable wantedLine = null;
// loop over all lines
foreach (TrainLineVariable line in lines)
{
// if lines' number are equal
if (line.LineNumber.Equals(lineNumber))
{
// we found the line
wantedLine = line;
// and escape the loop
break;
}
}
return(wantedLine);
}
private void updateConnectedLineShift(TrainLineVariable varLine)
{
// create choosen time window
Time timeWindowLowerBound = new Time(TimeWindowLowerBoundHour, 0);
// calculate in minutes
// normalize with respect to the choosen window
int shift = varLine.Line.OriginalDeparture.ToMinutes() - timeWindowLowerBound.ToMinutes();
// move it into that window
while (shift < 0)
{
shift += (int)varLine.Period;
}
while (shift >= (int)varLine.Period)
{
shift -= (int)varLine.Period;
}
// store the relative
varLine.Line.ConnectedLineShift = Time.ToTime(shift);
}
/// <summary>
/// Updates the connected train line variables.
/// </summary>
/// <param name="varLines">The variable lines.</param>
private void updateConnectedTrainLineVariables(List <TrainLineVariable> varLines)
{
// loop over all varLines
foreach (TrainLineVariable varLine in varLines)
{
// update (set) relative shift within equivalent group
updateConnectedLineShift(varLine);
// loop over all connected line for line related with varLine
foreach (TrainLine line in varLine.Line.getConnectedLines())
{
// update the connections
if (line.LineNumber < varLine.LineNumber)
{
// find appropriate varLine
TrainLineVariable connectedVariableLine = findVariableLine(varLines, line.LineNumber);
// add this var line into list of related var line
connectedVariableLine.ConnectedLinesVariable.Add(varLine);
varLine.ConnectedLinesVariable.Add(connectedVariableLine);
}
}
}
}
public Change(TrainLineVariable variable, Time oldTime)
: this()
{
this.changedVariable = variable;
this.oldStartTime = oldTime;
}
/// <summary>
/// Generates the timetable.
/// </summary>
/// <returns></returns>
public Timetable generateTimetable()
{
// generate randomizedTimetable
Timetable timetable = generateRandomizedTimetable();
// createConstraintSet temporary holder for AvailableLines during calculation
List <TrainLineVariable> availableLines = cloneVariableLines(timetable.getVariableLines());
// createConstraintSet temporary holder for AvailableLines during calculation
List <TrainLineVariable> stableLines = new List <TrainLineVariable>();
// random class for randomizing choice of trainlines
Random random = new Random();
// local variables
//int theBestTimetableRatingValue = int.MaxValue;
//int progressiveChanges = 0;
// Find the best new state.
CurrentState state = new CurrentState(new List <Change>(), int.MaxValue);
// loop until if availableLines are not empty AND stableLine are not complete
while (!availableLines.Count.Equals(0) &&
!stableLines.Count.Equals(timetable.TrainLines.Count))
{
Boolean improved = false;
// choose available line randomly
TrainLineVariable selectedLine = availableLines[random.Next(0, availableLines.Count - 1)];
// loop over whole interval of line
for (int i = 0; i < (int)selectedLine.Period; i++)
{
// calculate transfers
CurrentState newState = calculateTransfers(timetable, selectedLine, Time.ToTime(i));
if (newState.Factor > state.Factor)
{
// If the current one is better forget the computed one.
newState.Revert();
}
else if (newState.Factor != state.Factor)
{
// The computed one should be preserved.
state = newState;
improved = true;
}
}
// If the state was improved.
if (improved)
{
selectedLine.ProgressiveChanges += 1;
// clear stableLines queue
stableLines.Clear();
// reset availableLines
availableLines = cloneVariableLines(timetable.getVariableLines());
}
// add selected line into list of stableLines
stableLines.Add(selectedLine);
// add also all connected lines with selected line
stableLines.AddRange(selectedLine.ConnectedLinesVariable);
// remove line off availableLines
availableLines.Remove(selectedLine);
// remove all connected lines with selected line
foreach (TrainLineVariable connectedVar in selectedLine.ConnectedLinesVariable)
{
availableLines.Remove(connectedVar);
}
}
timetable.RatingValue = state.Factor;
//int ratingValue = Timetable.calculateTimetableRatingValue(timetable);
timetable.calculateProgressiveChanges();
//LogUtil.printTimetableTransfersEvaluation(timetable, FinalInput.getInstance().getCacheContent());
return(timetable);
}
