public override bool Try(SimulatedAnnealingSolver solverInstance, ref SatConfiguration currentConfiguration)
{
SatConfiguration triedConfiguration;
double randomChoice = random.NextDouble();
if (randomChoice < randomNeighborProb)
{
triedConfiguration = GetRandomNeighbor(solverInstance, currentConfiguration);
}
else if (randomChoice < randomNeighborProb + randomNewProb)
{
triedConfiguration = SatConfiguration.RandomConfiguration(solverInstance.SatInstance, random);
}
else if (randomChoice < randomNeighborProb + randomNewProb + improveScoreProb)
{
triedConfiguration = GetBetterScoreNeighbor(solverInstance, currentConfiguration);
}
else
{
triedConfiguration = GetBetterSatisfiabilityNeighbor(solverInstance, currentConfiguration);
}
triedConfiguration.Score = solverInstance.Options.ScoreStrategy.CalculateScore(triedConfiguration, solverInstance);
if (Accept(triedConfiguration, currentConfiguration, solverInstance.CurrentTemperature))
{
currentConfiguration = triedConfiguration;
return(true);
}
return(false);
}
//Performs a random bit-flip
public bool Try(SimulatedAnnealingSolver solverInstance, ref KnapsackConfiguration currentConfiguration)
{
var bitToFlip = random.Next(0, solverInstance.Instance.ItemCount - 1);
var triedConfiguration = new KnapsackConfiguration(currentConfiguration);
triedConfiguration.ItemVector[bitToFlip] = !triedConfiguration.ItemVector[bitToFlip];
if (triedConfiguration.ItemVector[bitToFlip])
{
triedConfiguration.Price += solverInstance.Instance.Items[bitToFlip].Price;
triedConfiguration.Weight += solverInstance.Instance.Items[bitToFlip].Weight;
}
else
{
triedConfiguration.Price -= solverInstance.Instance.Items[bitToFlip].Price;
triedConfiguration.Weight -= solverInstance.Instance.Items[bitToFlip].Weight;
}
triedConfiguration.Cost = solverInstance.Options.ScoreStrategy.Cost(triedConfiguration, solverInstance);
if (triedConfiguration.Cost >= currentConfiguration.Cost)
{
currentConfiguration = triedConfiguration;
return(true);
}
var delta = triedConfiguration.Cost - currentConfiguration.Cost;
if (random.NextDouble() < Math.Exp(delta / solverInstance.CurrentTemperature))
{
currentConfiguration = triedConfiguration;
return(true);
}
return(false);
}
public bool Frozen(SimulatedAnnealingSolver solverInstance)
{
if (solverInstance.CurrentTemperature <= solverInstance.Options.MinimalTemperature)
{
return(true);
}
return(false);
}
public bool Frozen(SimulatedAnnealingSolver solverInstance)
{
if (solverInstance.CurrentTemperature <= solverInstance.ScaledMinTemperature)
{
return(true);
}
return(false);
}
private SatConfiguration GetRandomNeighbor(SimulatedAnnealingSolver solverInstance, SatConfiguration currentConfiguration)
{
var flipIndex = random.Next(0, solverInstance.SatInstance.Literals.Count);
var triedConfiguration = new SatConfiguration(currentConfiguration);
triedConfiguration.FlipValuation(flipIndex);
return(triedConfiguration);
}
public float CalculateScore(SatConfiguration configuration, SimulatedAnnealingSolver solver)
{
//Base score is the optimalization value
float score = configuration.GetOptimalizationValue();
//Penalize the score based on the number of unsatisfied clauses
score -= configuration.NumberOfUnsatisfiedClauses() * solver.Options.PenaltyMultiplier;
return(score);
}
public void run_szenario(int times, String sz, String s)
{
int render_every = 5120; //model evaluations
//n mal laufen lassen für empirische Auswertung
//(bei den direkten Heuristiken (greedy,insertion,savings nicht nötig, daher n = 1)
for (int i = 0; i < times; i++)
{
//solange ein Prozess läuft mache nichts!
while (optimizer_running)
{
Thread.Sleep(5000);
}
String problemInstance = File.ReadAllText(sz + ".json");
model = new MEPModel.MEP();
model.LoadModelString(problemInstance);
scenario = sz + "_" + s + "_" + i;
Console.WriteLine("Starting Szenario:" + scenario);
//setze Kontext
model.AllowTripContinuation = true;
model.PermutateOptions = false;
model.AllowUnprofitableRequests = true;
model.AvgTravelSpeed = 400;
model.HotelCostPerNight = -100;
model.HourlyWage = -60;
model.MilageAllowance = -0.1;
model.RevenuePerDayOnsite = 2000;
Solver.Solver so = null;
switch (s)
{
case "Greedy":
so = new GreedySolver(model);
break;
case "SA":
so = new SimulatedAnnealingSolver(model, 10000, 1600, render_every, 64); //somit maximal 10.000*16 = 160.000 modell evaluationen!
break;
case "GA":
so = new GeneticSolver(model, 19, 5120, 5, render_every); //somit maximal 100 * 1.600 = 160.000 modell evaluationen!
break;
case "Insertion":
so = new NearestInsertionSolver(model);
break;
case "Savings":
so = new SavingsSolver(model);
break;
}
start = DateTime.Now;
Start_Optimizer(so);
}
}
public override bool Equilibrium(SimulatedAnnealingSolver solverInstance)
{
if (loopCount >= solverInstance.Options.BaseEquilibriumSteps * solverInstance.Instance.ItemCount)
{
loopCount = 0;
return(false);
}
loopCount++;
return(true);
}
public int Cost(KnapsackConfiguration configuration, SimulatedAnnealingSolver solver)
{
int score = configuration.Price;
if (configuration.Weight > solver.Instance.KnapsackSize)
{
var weightOverrun = configuration.Weight - solver.Instance.KnapsackSize;
score -= (int)Math.Round(weightOverrun * solver.Options.PenaltyMultiplier);
}
return(score);
}
public override bool Equilibrium(SimulatedAnnealingSolver solverInstance)
{
var N = solverInstance.Options.BaseEquilibriumSteps * solverInstance.Instance.ItemCount;
if (loopCount >= N * 2 || solverInstance.AcceptedDuringEquilibrium >= N)
{
loopCount = 0;
return(false);
}
loopCount++;
return(true);
}
private void btnRunAsync_Click(object sender, RoutedEventArgs e)
{
output_to_file = false;
tokensource = new CancellationTokenSource();
if (model != null && model.Requests.Count > 0)
{
btnRunAsync.IsEnabled = false;
set_model_parameter();
//clear optimizer Output:
txtOptimizerOutput.Text = "";
Solver.Solver s = null;
if (rbGeneticAlgorithm.IsChecked == true)
{
s = new GeneticSolver(model, Convert.ToInt32(txtGenerations.Text), Convert.ToInt32(txtPopulationSize.Text), Convert.ToInt32(txtMutationProbability.Text), Convert.ToInt32(txtReportProgress.Text));
}
if (rbBruteForce.IsChecked == true)
{
if (model.GetNumberOfElements() > 11)
{
MessageBox.Show("I´m sorry Dave, I`m afraid I can`t do that!");
}
else
{
s = new BruteForceSolver(model);
}
}
if (rbSimulatedAnnealing.IsChecked == true)
{
s = new SimulatedAnnealingSolver(model, Convert.ToInt32(txtStartTemp.Text), Convert.ToInt32(txtSteps.Text), Convert.ToInt32(txtReportProgress.Text), Convert.ToInt32(txtParallelAnnealings.Text));
}
if (rbGreedy.IsChecked == true)
{
s = new GreedySolver(model);
}
if (rbInsertion.IsChecked == true)
{
s = new NearestInsertionSolver(model);
}
if (rbSavings.IsChecked == true)
{
s = new SavingsSolver(model);
}
if (s != null)
{
Start_Optimizer(s);
}
}
}
private static void RunSimulatedAnnealingForConfiguration(IInstanceProvider instanceProvider,
double initTemperature, double frozenTemperature, double coolingCoeficient, int equilibriumCoeficient)
{
Console.WriteLine($"Init temperature: {initTemperature}");
Console.WriteLine($"Cooling coeficient: {coolingCoeficient}");
Console.WriteLine($"Equilibrium coeficient: {equilibriumCoeficient}");
var exactSolver = new DynamicByPriceSolver();
var simulatedAnnealingSolver = new SimulatedAnnealingSolver(initTemperature, frozenTemperature, coolingCoeficient, equilibriumCoeficient);
var runner = new CompareRunner(instanceProvider, exactSolver, simulatedAnnealingSolver);
runner.Run();
Console.WriteLine();
}
public float CalculateScore(SatConfiguration configuration, SimulatedAnnealingSolver solver)
{
//Base score is the optimalization value
float score = configuration.GetOptimalizationValue();
//Make the score negative if it is unsatisfiable
if (!configuration.IsSatisfiable())
{
score -= configuration.Instance.GetSumOfWeights();
}
//Penalize the score further based on the number of unsatisfied clauses
score -= configuration.NumberOfUnsatisfiedClauses() * solver.Options.PenaltyMultiplier;
return(score);
}
private SatConfiguration GetBetterSatisfiabilityNeighbor(SimulatedAnnealingSolver solverInstance, SatConfiguration currentConfiguration)
{
var candidateIndex = currentConfiguration.IndexOfRandomToImproveSatisfiability(random);
if (candidateIndex > 0)
{
var triedConfiguration = new SatConfiguration(currentConfiguration);
triedConfiguration.FlipValuation(candidateIndex);
return(triedConfiguration);
}
else
{
return(GetBetterScoreNeighbor(solverInstance, currentConfiguration));
}
}
private static void Test1()
{
var generator = new RandomInstanceProvider();
var instance = generator.GetInstance(25);
Console.WriteLine(instance.Formula);
var brutteForceSolver = new BrutteForceSolver();
var simulatedAnnealingSolver = new SimulatedAnnealingSolver();
var solution1 = brutteForceSolver.Solve(instance);
var solution2 = simulatedAnnealingSolver.Solve(instance);
Console.WriteLine(solution1);
Console.WriteLine(solution2);
}
private SatConfiguration GetBetterScoreNeighbor(SimulatedAnnealingSolver solverInstance, SatConfiguration currentConfiguration)
{
var triedConfiguration = new SatConfiguration(currentConfiguration);
var flipIndex = currentConfiguration.IndexOfRandomToImproveScore(random);
//Nothing to improve (all valuations set to 1), reset the configuration entirely
if (flipIndex < 0)
{
triedConfiguration = SatConfiguration.RandomConfiguration(solverInstance.SatInstance, random);
}
else
{
triedConfiguration.FlipValuation(flipIndex);
}
return(triedConfiguration);
}
//Performs a random bit-flip
public override bool Try(SimulatedAnnealingSolver solverInstance, ref SatConfiguration currentConfiguration)
{
var bitToFlip = random.Next(0, solverInstance.SatInstance.Literals.Count - 1);
var triedConfiguration = new SatConfiguration(currentConfiguration);
triedConfiguration.Valuations[bitToFlip] = !triedConfiguration.Valuations[bitToFlip];
triedConfiguration.Score = solverInstance.Options.ScoreStrategy.CalculateScore(triedConfiguration, solverInstance);
if (Accept(triedConfiguration, currentConfiguration, solverInstance.CurrentTemperature))
{
currentConfiguration = triedConfiguration;
return(true);
}
return(false);
}
public void Run(Instance instance, string fileName)
{
var configurations = new List <EvaluatedConfiguration>();
var solver = new SimulatedAnnealingSolver(INIT_TEMPERATURE, FROZEN_TEMPERATURE, COOLING_COEFICIENT, EQUILIBRIUM_COEFICIENT);
solver.NewConfiguration += (sender, configuration) => configurations.Add(configuration);
solver.Solve(instance);
using (var sw = new StreamWriter(fileName))
{
foreach (var evaluatedConfiguration in configurations)
{
sw.WriteLine(evaluatedConfiguration.Weight);
}
sw.Close();
}
}
public IList <KnapsackResult> SolveWithPerformanceTest(IList <KnapsackInstance> instances, AnnealingOptions options)
{
PreparePerformanceTest(instances);
var stopWatch = new Stopwatch();
var results = new List <KnapsackResult>();
foreach (var instance in instances)
{
Console.WriteLine($"Processing instance no. {instance.Id}");
KnapsackResult result = null;
//The algorithm must run repeat at least the set amount of times;
for (int i = 0; i < REPEAT_COUNT; i++)
{
var solver = new SimulatedAnnealingSolver(instance, options);
GC.Collect();
GC.WaitForPendingFinalizers();
//GC.TryStartNoGCRegion(200000000);
stopWatch.Start();
result = solver.Solve();
stopWatch.Stop();
//GC.EndNoGCRegion();
}
var averageRuntime = stopWatch.Elapsed.TotalMilliseconds / REPEAT_COUNT;
//Save only the last result
if (result != null)
{
var optimalConfiguration = GetOptimalConfiguration(instance);
result.RunTimeMs = averageRuntime;
result.OptimalConfiguration = optimalConfiguration;
result.Epsilon = GetEpsilonOfSolution(result.Configuration.Price, optimalConfiguration.Price);
results.Add(result);
}
RaiseInstanceCalculationFinished();
stopWatch.Reset();
}
return(results);
}
public bool Frozen(SimulatedAnnealingSolver solverInstance)
{
float rejectedRatio;
if (solverInstance.EquilibriumSteps == 0)
{
rejectedRatio = 0.0f;
}
else
{
rejectedRatio = 1.0f - ((float)solverInstance.AcceptedDuringEquilibrium / solverInstance.EquilibriumSteps);
}
if (solverInstance.CurrentTemperature <= solverInstance.ScaledMinTemperature ||
rejectedRatio >= solverInstance.Options.MaxRejectedRatio)
{
return(true);
}
return(false);
}
public KnapsackConfiguration GetStartingPosition(SimulatedAnnealingSolver solverInstance)
{
var configuration = new KnapsackConfiguration {
Price = 0, Weight = 0
};
var itemVector = new List <bool>();
foreach (var item in solverInstance.Instance.Items)
{
var added = Convert.ToBoolean(random.Next(0, 1));
itemVector.Add(added);
if (added)
{
configuration.Price += item.Price;
configuration.Weight += item.Weight;
}
}
configuration.ItemVector = itemVector;
return(configuration);
}
public abstract bool Equilibrium(SimulatedAnnealingSolver solverInstance);
public abstract bool Try(SimulatedAnnealingSolver solverInstance, ref SatConfiguration currentConfiguration);
public float Cool(SimulatedAnnealingSolver solverInstance)
{
return(solverInstance.CurrentTemperature * solverInstance.Options.CoolingCoefficient);
}
public SatConfiguration GetStartingPosition(SimulatedAnnealingSolver solverInstance)
{
return(SatConfiguration.RandomConfiguration(solverInstance.SatInstance, random));
}
private void _run_Click(object sender, RoutedEventArgs e)
{
#region Validate simulates annealing parameters
int iterationCount = 0;
if (!int.TryParse(this._numberOfIterations.Text, out iterationCount))
{
this.invalidInput("Number of Iterations");
return;
}
if (iterationCount <= 0)
{
this.valueSmallerThanZero("Number of Iterations");
return;
}
this._iterationCount = iterationCount;
double minimumEnergy = 0;
if (!double.TryParse(this._minimumTemperature.Text, out minimumEnergy))
{
this.invalidInput("Minimum Temperature");
return;
}
if (minimumEnergy < 0)
{
MessageBox.Show("'Minimum Temperature' should not be smaller than zero!",
"Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
double maximumEnergy = 0;
if (!double.TryParse(this._maximumTemperature.Text, out maximumEnergy))
{
this.invalidInput("Maximum Temperature");
return;
}
if (maximumEnergy <= 0)
{
this.valueSmallerThanZero("Maximum Temperature");
return;
}
#endregion
#region validation of training subset
//double trainingRatio = 0;
//if (!double.TryParse(this._ratioOfTrainingSubset.Text, out trainingRatio))
//{
// MessageBox.Show("Invalied 'Ratio of Training Subset'", "Invalid Input",
// MessageBoxButton.OK, MessageBoxImage.Error);
// return;
//}
//else
//{
// if (trainingRatio <= 0 || trainingRatio > 1.0)
// {
// MessageBox.Show("'Ratio of Training Subset' must be larger than zero and smaller than or equal to 1",
// "Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
// return;
// }
//}
#endregion
#region Validate duration and timeStep parameters
double timeStep = 0;
if (!double.TryParse(this._timeStep.Text, out timeStep))
{
MessageBox.Show("Invalid input for 'Time Step'!",
"Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
else
{
if (timeStep <= 0)
{
MessageBox.Show("'Time Step' must be larger than zero!",
"Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
this._timeStepValue = timeStep;
this._durationValue = this._host.trailVisualization.AgentWalkingTrail.TimeIntervalBetweenInterpolatedStates;//convert seconds to hours
#endregion
#region Check to see if spatial data has been included
int spatialDataCount = 0;
foreach (Function function in this._host.cellularFloor.AllSpatialDataFields.Values)
{
SpatialDataField dataField = function as SpatialDataField;
if (dataField != null)
{
if (dataField.IncludeInActivityGeneration)
{
spatialDataCount++;
}
}
}
if (spatialDataCount == 0)
{
var res = MessageBox.Show("There is no a spatial data field included to calculate cost/desirability!");
return;
}
#endregion
#region extracting the ralated parameters and checking to see if number of parameter is not zero
this.AllParameters = new HashSet <Parameter>();
if (this._isoExternalDepth.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.OPT_IsovistExternalDepth.ToString()]);
}
if (this._numberOfDestinations.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.OPT_NumberOfDestinations.ToString()]);
}
if (this._velocityMagnetude.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_VelocityMagnitude.ToString()]);
}
if (this._angularVelocity.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_AngularVelocity.ToString()]);
}
if (this._bodySize.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_BodySize.ToString()]);
}
if (this._accelerationMagnitude.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_AccelerationMagnitude.ToString()]);
}
if (this._barrierRepulsionRange.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_BarrierRepulsionRange.ToString()]);
}
if (this._repulsionChangeRate.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_MaximumRepulsion.ToString()]);
}
if (this._barrierFriction.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_BarrierFriction.ToString()]);
}
if (this._bodyElasticity.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_AgentBodyElasticity.ToString()]);
}
if (this._visibilityAngle.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_VisibilityAngle.ToString()]);
}
if (this._decisionMakingPeriodLamdaFactor.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.OPT_DecisionMakingPeriodLambdaFactor.ToString()]);
}
if (this._angleDistributionLambdaFactor.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.OPT_AngleDistributionLambdaFactor.ToString()]);
}
if (this._desirabilityDistributionLambdaFactor.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.OPT_DesirabilityDistributionLambdaFactor.ToString()]);
}
foreach (var item in this._host.Parameters)
{
foreach (var function in item.Value.LinkedFunctions)
{
if (function.IncludeInActivityGeneration)
{
this.AllParameters.Add(item.Value);
break;
}
}
}
if (this.AllParameters.Count == 0)
{
MessageBox.Show("No parameter is included to account for the variability in the optimization process",
"Parameter Not Assigned", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
#endregion
//execute visibility changes in the interface
Dispatcher.Invoke(new Action(() =>
{
this._run_close.SetValue(Button.VisibilityProperty, System.Windows.Visibility.Collapsed);
this._run_close.SetValue(Button.ContentProperty, "Close");
this._mainInterface.SetValue(Grid.VisibilityProperty, System.Windows.Visibility.Collapsed);
this._progressPanel.SetValue(StackPanel.VisibilityProperty, System.Windows.Visibility.Visible);
}), DispatcherPriority.ContextIdle);
//unregister run button event
this._run_close.Click -= this._run_Click;
//create annealing
SimulatedAnnealingSolver solver = new SimulatedAnnealingSolver(this.AllParameters);
//register UI update event for best fitness changes
solver.BestFitnessUpdated += solver_BestFitnessUpdated;
//register UI update event for fitness changes
solver.FitnessUpdated += solver_FitnessUpdated;
//Setting the initial iteration to zero
this._counter = 0;
//initializing the trial visualization
this._host.trailVisualization.InitiateTrainingVisualization();
//running the annealing process
solver.Solve(minimumEnergy, maximumEnergy, iterationCount, this.measureFitnessWithInterfaceUpdate);
//unregister UI update event for fitness changes
solver.BestFitnessUpdated -= solver_BestFitnessUpdated;
//unregister UI update event for fitness changes
solver.FitnessUpdated -= solver_FitnessUpdated;
//showing the close btn. The close event is not registered yet
Dispatcher.Invoke(new Action(() =>
{
this._run_close.SetValue(Button.VisibilityProperty, System.Windows.Visibility.Visible);
}), DispatcherPriority.ContextIdle);
//updating the FreeNavigationAgentCharacters
this._host.FreeNavigationAgentCharacter = FreeNavigationAgent.Create(this._host.trailVisualization.AgentWalkingTrail.InterpolatedStates[0]);
//Show the last parameter setting on UI
this._sb.Clear();
foreach (var item in this.AllParameters)
{
this._sb.AppendLine(item.ToString());
}
this._updateMessage.SetValue(TextBlock.TextProperty, this._sb.ToString());
//set Window closing events
this._run_close.Click += (s, e1) =>
{
var result = MessageBox.Show("Do you want to clear the training data from screen?",
"", MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
if (result == MessageBoxResult.Yes)
{
this._host.trailVisualization.TerminateTrainingVisualization();
}
this.Close();
};
}
void _run_Click(object sender, RoutedEventArgs e)
{
#region Validate activity related input
if (this._applyFilter.IsChecked.Value)
{
int gr = 0;
if (!int.TryParse(this._gaussianRangeDefault.Text, out gr))
{
MessageBox.Show("Invalid input for Gaussian filter range");
return;
}
else
{
if (gr < 2)
{
MessageBox.Show("Gaussian filter range should be larger than 1!");
return;
}
else
{
this._gaussianRange = gr;
}
}
if (this._host.ViewBasedGaussianFilter.Range != gr)
{
this._host.ViewBasedGaussianFilter = new IsovistClippedGaussian(this._host.cellularFloor, gr);
}
}
int _r = 0;
if (!int.TryParse(this._neighborhoodRangePotential.Text, out _r))
{
MessageBox.Show("Invalid input for potential field calculation range!");
return;
}
else
{
if (_r < 1)
{
MessageBox.Show("Potential field calculation range should be larger than 0!");
return;
}
else
{
if (this._host.FieldGenerator.Range != _r)
{
this._host.FieldGenerator = new Data.Visualization.SpatialDataCalculator(this._host, _r, OSMDocument.AbsoluteTolerance);
}
}
}
#endregion
#region Validate simulates annealing parameters
int iterationCount = 0;
if (!int.TryParse(this._numberOfIterations.Text, out iterationCount))
{
this.invalidInput("Number of Iterations");
return;
}
if (iterationCount <= 0)
{
this.valueSmallerThanZero("Number of Iterations");
return;
}
this._iterationCount = iterationCount;
double minimumEnergy = 0;
if (!double.TryParse(this._minimumTemperature.Text, out minimumEnergy))
{
this.invalidInput("Minimum Temperature");
return;
}
if (minimumEnergy < 0)
{
MessageBox.Show("'Minimum Temperature' should not be smaller than zero!",
"Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
double maximumEnergy = 0;
if (!double.TryParse(this._maximumTemperature.Text, out maximumEnergy))
{
this.invalidInput("Maximum Temperature");
return;
}
if (maximumEnergy <= 0)
{
this.valueSmallerThanZero("Maximum Temperature");
return;
}
#endregion
#region validation of training subset
//double trainingRatio = 0;
//if(!double.TryParse(this._ratioOfTrainingSubset.Text, out trainingRatio))
//{
// MessageBox.Show("Invalied 'Ratio of Training Subset'", "Invalid Input",
// MessageBoxButton.OK, MessageBoxImage.Error);
// return;
//}
//else
//{
// if(trainingRatio<=0 || trainingRatio>1.0)
// {
// MessageBox.Show("'Ratio of Training Subset' must be larger than zero and smaller than or equal to 1",
// "Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
// return;
// }
//}
#endregion
#region Validate duration and timeStep parameters
double timeStep = 0;
if (!double.TryParse(this._timeStep.Text, out timeStep))
{
MessageBox.Show("Invalid input for 'Time Step'!",
"Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
else
{
if (timeStep <= 0)
{
MessageBox.Show("'Time Step' must be larger than zero!",
"Invalid Input", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
this._timeStepValue = timeStep;
this._durationValue = this._host.trailVisualization.AgentWalkingTrail.TimeIntervalBetweenInterpolatedStates;//convert seconds to hours
#endregion
#region Check to see if spatial data has been included
int spatialDataCount = 0;
foreach (Function function in this._host.cellularFloor.AllSpatialDataFields.Values)
{
SpatialDataField dataField = function as SpatialDataField;
if (dataField != null)
{
if (dataField.IncludeInActivityGeneration)
{
spatialDataCount++;
}
}
}
if (spatialDataCount == 0)
{
var res = MessageBox.Show("There is no a spatial data field included to calculate cost/desirability!");
return;
}
#endregion
#region extracting the ralated parameters and checking to see if number of parameter is not zero
this.AllParameters = new HashSet <Parameter>();
if (this._velocityMagnetude.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_VelocityMagnitude.ToString()]);
}
if (this._angularVelocity.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_AngularVelocity.ToString()]);
}
if (this._bodySize.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_BodySize.ToString()]);
}
if (this._accelerationMagnitude.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_AccelerationMagnitude.ToString()]);
}
if (this._barrierRepulsionRange.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_BarrierRepulsionRange.ToString()]);
}
if (this._repulsionChangeRate.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_MaximumRepulsion.ToString()]);
}
if (this._barrierFriction.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_BarrierFriction.ToString()]);
}
if (this._bodyElasticity.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.GEN_AgentBodyElasticity.ToString()]);
}
if (this._angularDeviationCost.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.MAN_AngularDeviationCost.ToString()]);
}
if (this._distanceCost.IsChecked.Value)
{
this.AllParameters.Add(this._host.Parameters[AgentParameters.MAN_DistanceCost.ToString()]);
}
foreach (var item in this._host.Parameters)
{
foreach (var function in item.Value.LinkedFunctions)
{
if (function.IncludeInActivityGeneration)
{
this.AllParameters.Add(item.Value);
break;
}
}
}
if (this.AllParameters.Count == 0)
{
MessageBox.Show("No parameter is included to account for the variability in the optimization process",
"Parameter Not Assigned", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
#endregion
#region Trail Related Stuff
this._trailIndices = new HashSet <Index>();
foreach (var item in this._host.trailVisualization.AgentWalkingTrail.ApproximatedPoints)
{
Index index = this._host.cellularFloor.FindIndex(item);
if (this._host.cellularFloor.Cells[index.I, index.J].FieldOverlapState != OverlapState.Inside)
{
MessageBox.Show("The training process cannot proceed with this trail. Parts of the trail are not included in the walkable field!", "Invalid Trail", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
else
{
this._trailIndices.Add(index);
}
}
this._trailIndices = CellUtility.ExpandInWalkableField(this._host.cellularFloor, this._trailIndices);
this._defaultState = this._host.trailVisualization.AgentWalkingTrail.InterpolatedStates[this._host.trailVisualization.AgentWalkingTrail.InterpolatedStates.Length - 1];
this._cellDestination = this._host.cellularFloor.FindCell(this._defaultState.Location);
UV p1 = this._cellDestination;
var p2 = p1 + UV.UBase * this._host.cellularFloor.CellSize;
var p3 = p1 + UV.UBase * this._host.cellularFloor.CellSize + UV.VBase * this._host.cellularFloor.CellSize;
var p4 = p1 + UV.VBase * this._host.cellularFloor.CellSize;
this._destination = new BarrierPolygon(new UV[] { p1, p2, p3, p4 });
#endregion
//execute visibility changes in the interface
Dispatcher.Invoke(new Action(() =>
{
this._run_close.SetValue(Button.VisibilityProperty, System.Windows.Visibility.Collapsed);
this._run_close.SetValue(Button.ContentProperty, "Close");
this._mainInterface.SetValue(Grid.VisibilityProperty, System.Windows.Visibility.Collapsed);
this._progressPanel.SetValue(StackPanel.VisibilityProperty, System.Windows.Visibility.Visible);
}), DispatcherPriority.ContextIdle);
//unregister run button event
this._run_close.Click -= this._run_Click;
//create annealing
SimulatedAnnealingSolver solver = new SimulatedAnnealingSolver(this.AllParameters);
//register UI update event for best fitness changes
solver.BestFitnessUpdated += solver_BestFitnessUpdated;
//register UI update event for fitness changes
solver.FitnessUpdated += solver_FitnessUpdated;
//Setting the initial iteration to zero
this._counter = 0;
//initializing the trial visualization
this._host.trailVisualization.InitiateTrainingVisualization();
//running the annealing process
solver.Solve(minimumEnergy, maximumEnergy, iterationCount, this.measureFitnessWithInterfaceUpdate);
//unregister UI update event for fitness changes
solver.BestFitnessUpdated -= solver_BestFitnessUpdated;
//unregister UI update event for fitness changes
solver.FitnessUpdated -= solver_FitnessUpdated;
//showing the close btn. The close event is not registered yet
Dispatcher.Invoke(new Action(() =>
{
this._run_close.SetValue(Button.VisibilityProperty, System.Windows.Visibility.Visible);
}), DispatcherPriority.ContextIdle);
//Show the last parameter setting on UI
this._sb.Clear();
foreach (var item in this.AllParameters)
{
this._sb.AppendLine(item.ToString());
}
this._updateMessage.SetValue(TextBlock.TextProperty, this._sb.ToString());
//set Window closing events
this._run_close.Click += (s, e1) =>
{
var result = MessageBox.Show("Do you want to clear the training data from screen?",
"", MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
if (result == MessageBoxResult.Yes)
{
this._host.trailVisualization.TerminateTrainingVisualization();
}
this.Close();
};
}
public KnapsackConfiguration GetStartingPosition(SimulatedAnnealingSolver solverInstance)
{
var greedyResult = new GreedyReduxSolver().Solve(solverInstance.Instance);
return(greedyResult.Configuration);
}
