source: branches/jschiess/HeuristicLab.Algorithms.SimulatedAnnealing/3.4/SimulatedAnnealing.cs @ 15001

Last change on this file since 15001 was 15001, checked in by jschiess, 5 years ago

#1836 SA reheating strategies: Newest version of reheating

File size: 29.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Linq;
24using HeuristicLab.Analysis;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Data;
28using HeuristicLab.Operators;
29using HeuristicLab.Optimization;
30using HeuristicLab.Optimization.Operators;
31using HeuristicLab.Parameters;
32using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
33using HeuristicLab.PluginInfrastructure;
34using HeuristicLab.Random;
35
36namespace HeuristicLab.Algorithms.SimulatedAnnealing
37{
38    [Item("Simulated Annealing", "An advanced simulated annealing algorithm.")]
39    [Creatable("Algorithms")]
40    [StorableClass]
41    public sealed class SimulatedAnnealing : HeuristicOptimizationEngineAlgorithm, IStorableContent
42    {
43        #region Strings
44        private const string SeedName = "Seed";
45        private const string SetSeedRandomlyName = "SetSeedRandomly";
46        private const string MoveGeneratorName = "MoveGenerator";
47        private const string MoveEvaluatorName = "MoveEvaluator";
48        private const string MoveMakerName = "MoveMaker";
49        private const string AnnealingOperatorName = "AnnealingOperator";
50        private const string ReheatingOperatorName = "ReheatingOperator";
51        private const string MaximumIterationsName = "MaximumIterations";
52        private const string InitialTemperatureName = "InitialTemperature";
53        private const string InitialAcceptanceRateName = "InitialAcceptanceRate";
54        private const string LowerTemperatureName = "LowerTemperature";
55        private const string AnalyzerName = "Analyzer";
56        private const string RandomName = "Random";
57        private const string EvaluatedMovesName = "EvaluatedMoves";
58        private const string IterationsName = "Iterations";
59        private const string TemperatureStartIndexName = "TemperatureStartIndex";
60        private const string CoolingName = "Cooling";
61        private const string StartTemperatureName = "StartTemperature";
62        private const string EndTemperatureName = "EndTemperature";
63        private const string TemperatureName = "Temperature";
64        private const string ResultsName = "Results";
65        private const string TemperatureChartName = "Temperature Chart";
66        private const string TemperatureAnalyzerName = "Temperature Analyzer";
67        #endregion
68
69        public string Filename { get; set; }
70
71        #region Problem Properties
72        public override Type ProblemType
73        {
74            get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
75        }
76        public new ISingleObjectiveHeuristicOptimizationProblem Problem
77        {
78            get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
79            set { base.Problem = value; }
80        }
81        #endregion
82
83        #region Parameter Properties
84        private ValueParameter<IntValue> SeedParameter
85        {
86            get { return (ValueParameter<IntValue>)Parameters[SeedName]; }
87        }
88        private ValueParameter<BoolValue> SetSeedRandomlyParameter
89        {
90            get { return (ValueParameter<BoolValue>)Parameters[SetSeedRandomlyName]; }
91        }
92        public IConstrainedValueParameter<IMultiMoveGenerator> MoveGeneratorParameter
93        {
94            get { return (IConstrainedValueParameter<IMultiMoveGenerator>)Parameters[MoveGeneratorName]; }
95        }
96        public IConstrainedValueParameter<IMoveMaker> MoveMakerParameter
97        {
98            get { return (IConstrainedValueParameter<IMoveMaker>)Parameters[MoveMakerName]; }
99        }
100        public IConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter
101        {
102            get { return (IConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters[MoveEvaluatorName]; }
103        }
104        public IConstrainedValueParameter<IDiscreteDoubleValueModifier> AnnealingOperatorParameter
105        {
106            get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters[AnnealingOperatorName]; }
107        }
108
109        public IConstrainedValueParameter<IReheatingOperator> ReheatingOperatorParameter
110        {
111            get { return (IConstrainedValueParameter<IReheatingOperator>)Parameters[ReheatingOperatorName]; }
112        }
113
114        private ValueParameter<IntValue> MaximumIterationsParameter
115        {
116            get { return (ValueParameter<IntValue>)Parameters[MaximumIterationsName]; }
117        }
118        private ValueParameter<DoubleValue> InitialAcceptanceRateParameter
119        {
120            get { return (ValueParameter<DoubleValue>)Parameters[InitialAcceptanceRateName]; }
121        }
122        private ValueParameter<DoubleValue> LowerTemperatureParameter
123        {
124            get { return (ValueParameter<DoubleValue>)Parameters[LowerTemperatureName]; }
125        }
126        private ValueParameter<MultiAnalyzer> AnalyzerParameter
127        {
128            get { return (ValueParameter<MultiAnalyzer>)Parameters[AnalyzerName]; }
129        }
130        #endregion
131
132        #region Properties
133        public IntValue Seed
134        {
135            get { return SeedParameter.Value; }
136            set { SeedParameter.Value = value; }
137        }
138        public BoolValue SetSeedRandomly
139        {
140            get { return SetSeedRandomlyParameter.Value; }
141            set { SetSeedRandomlyParameter.Value = value; }
142        }
143        public IMultiMoveGenerator MoveGenerator
144        {
145            get { return MoveGeneratorParameter.Value; }
146            set { MoveGeneratorParameter.Value = value; }
147        }
148        public IMoveMaker MoveMaker
149        {
150            get { return MoveMakerParameter.Value; }
151            set { MoveMakerParameter.Value = value; }
152        }
153        public ISingleObjectiveMoveEvaluator MoveEvaluator
154        {
155            get { return MoveEvaluatorParameter.Value; }
156            set { MoveEvaluatorParameter.Value = value; }
157        }
158        public IDiscreteDoubleValueModifier AnnealingOperator
159        {
160            get { return AnnealingOperatorParameter.Value; }
161            set { AnnealingOperatorParameter.Value = value; }
162        }
163
164        public IReheatingOperator ReheatingOperator
165        {
166            get { return ReheatingOperatorParameter.Value; }
167            set { ReheatingOperatorParameter.Value = value; }
168        }
169
170        public IntValue MaximumIterations
171        {
172            get { return MaximumIterationsParameter.Value; }
173            set { MaximumIterationsParameter.Value = value; }
174        }
175        public DoubleValue InitialAcceptanceRate
176        {
177            get { return InitialAcceptanceRateParameter.Value; }
178            set { InitialAcceptanceRateParameter.Value = value; }
179        }
180        public DoubleValue LowerTemperature
181        {
182            get { return LowerTemperatureParameter.Value; }
183            set { LowerTemperatureParameter.Value = value; }
184        }
185        public MultiAnalyzer Analyzer
186        {
187            get { return AnalyzerParameter.Value; }
188            set { AnalyzerParameter.Value = value; }
189        }
190        private RandomCreator RandomCreator
191        {
192            get { return (RandomCreator)OperatorGraph.InitialOperator; }
193        }
194        private SolutionsCreator SolutionsCreator
195        {
196            get { return (SolutionsCreator)RandomCreator.Successor; }
197        }
198        private SimulatedAnnealingMainLoop MainLoop
199        {
200            get { return OperatorGraph.Iterate().OfType<SimulatedAnnealingMainLoop>().First(); }
201        }
202        #endregion
203
204        [StorableConstructor]
205        private SimulatedAnnealing(bool deserializing) : base(deserializing) { }
206        private SimulatedAnnealing(SimulatedAnnealing original, Cloner cloner)
207          : base(original, cloner)
208        {
209            RegisterEventHandlers();
210        }
211        public SimulatedAnnealing()
212          : base()
213        {
214            Parameters.Add(new ValueParameter<IntValue>(SeedName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
215            Parameters.Add(new ValueParameter<BoolValue>(SetSeedRandomlyName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
216            Parameters.Add(new ConstrainedValueParameter<IMultiMoveGenerator>(MoveGeneratorName, "The operator used to generate moves to the neighborhood of the current solution."));
217            Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>(MoveEvaluatorName, "The operator used to evaluate a move."));
218            Parameters.Add(new ConstrainedValueParameter<IMoveMaker>(MoveMakerName, "The operator used to perform a move."));
219            Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>(AnnealingOperatorName, "The operator used to cool the temperature."));
220            Parameters.Add(new ConstrainedValueParameter<IReheatingOperator>(ReheatingOperatorName, "The operator used to reheat the temperature, if necessary."));
221            Parameters.Add(new ValueParameter<IntValue>(MaximumIterationsName, "The maximum number of generations which should be processed.", new IntValue(10000)));
222            Parameters.Add(new ValueParameter<DoubleValue>(InitialAcceptanceRateName, "The initial acceptance rate of average-sized hills used to calculate the initial temperature", new DoubleValue(0.4)));
223            Parameters.Add(new ValueParameter<DoubleValue>(LowerTemperatureName, "The lower bound for the temperature.", new DoubleValue(1e-6)));
224            Parameters.Add(new ValueParameter<MultiAnalyzer>(AnalyzerName, "The operator used to analyze each iteration.", new MultiAnalyzer()));
225
226            var randomCreator = new RandomCreator();
227            var solutionsCreator = new SolutionsCreator();
228            var variableCreator = new VariableCreator();
229            var startTemperatureAssigner = new Assigner();
230            var endTemperatureAssigner = new Assigner();
231            var temperatureAssigner = new Assigner();
232            var resultsCollector = new ResultsCollector();
233            var mainLoop = new SimulatedAnnealingMainLoop();
234            OperatorGraph.InitialOperator = randomCreator;
235
236            randomCreator.RandomParameter.ActualName = RandomName;
237            randomCreator.SeedParameter.ActualName = SeedParameter.Name;
238            randomCreator.SeedParameter.Value = null;
239            randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
240            randomCreator.SetSeedRandomlyParameter.Value = null;
241            randomCreator.Successor = solutionsCreator;
242
243            solutionsCreator.NumberOfSolutions = new IntValue(1);
244            solutionsCreator.Successor = variableCreator;
245
246            variableCreator.Name = "Initialize Variables";
247            variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(InitialTemperatureName, new DoubleValue(Double.PositiveInfinity)));
248            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(EvaluatedMovesName, new IntValue()));
249            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(IterationsName, new IntValue(0)));
250            variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(TemperatureStartIndexName, new IntValue(0)));
251            variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>(CoolingName, new BoolValue(true)));
252
253            variableCreator.Successor = startTemperatureAssigner;
254
255            startTemperatureAssigner.Name = "Assign Start Temperature";
256            startTemperatureAssigner.LeftSideParameter.ActualName = StartTemperatureName;
257            startTemperatureAssigner.RightSideParameter.ActualName = InitialTemperatureName;
258            startTemperatureAssigner.Successor = endTemperatureAssigner;
259
260            endTemperatureAssigner.Name = "Assign End Temperature";
261            endTemperatureAssigner.LeftSideParameter.ActualName = EndTemperatureName;
262            endTemperatureAssigner.RightSideParameter.ActualName = LowerTemperatureParameter.Name;
263            endTemperatureAssigner.Successor = temperatureAssigner;
264
265            temperatureAssigner.Name = "Initialize Temperature";
266            temperatureAssigner.LeftSideParameter.ActualName = TemperatureName;
267            temperatureAssigner.RightSideParameter.ActualName = StartTemperatureName;
268            temperatureAssigner.Successor =  resultsCollector;
269
270            resultsCollector.CopyValue = new BoolValue(false);
271            resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(EvaluatedMovesName, null));
272            resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(IterationsName, null));
273            resultsCollector.ResultsParameter.ActualName = ResultsName;
274            resultsCollector.Successor = mainLoop;
275
276            mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
277            mainLoop.AnnealingOperatorParameter.ActualName = AnnealingOperatorParameter.Name;
278            mainLoop.CoolingParameter.ActualName = CoolingName;
279            mainLoop.EndTemperatureParameter.ActualName = EndTemperatureName;
280            mainLoop.EvaluatedMovesParameter.ActualName = EvaluatedMovesName;
281
282            mainLoop.IterationsParameter.ActualName = IterationsName;
283            mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
284            mainLoop.MoveEvaluatorParameter.ActualName = MoveEvaluatorParameter.Name;
285            mainLoop.MoveGeneratorParameter.ActualName = MoveGeneratorParameter.Name;
286            mainLoop.MoveMakerParameter.ActualName = MoveMakerParameter.Name;
287            mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
288            mainLoop.ResultsParameter.ActualName = ResultsName;
289            mainLoop.StartTemperatureParameter.ActualName = StartTemperatureName;
290            mainLoop.TemperatureStartIndexParameter.ActualName = TemperatureStartIndexName;
291            mainLoop.TemperatureParameter.ActualName = TemperatureName;
292
293            foreach (var op in ApplicationManager.Manager.GetInstances<IReheatingOperator>().OrderBy(x => x.Name))
294            {
295               
296                ReheatingOperatorParameter.ValidValues.Add(op);
297            }
298
299            foreach (var op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
300            {
301                AnnealingOperatorParameter.ValidValues.Add(op);
302            }
303
304            UpdateAnalyzers();
305
306            Parameterize();
307
308            RegisterEventHandlers();
309        }
310
311        public override IDeepCloneable Clone(Cloner cloner)
312        {
313            return new SimulatedAnnealing(this, cloner);
314        }
315
316        [StorableHook(HookType.AfterDeserialization)]
317        private void AfterDeserialization()
318        {
319            RegisterEventHandlers();
320        }
321
322        private void RegisterEventHandlers()
323        {
324            if (Problem != null)
325            {
326                Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
327                foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
328                {
329                    op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
330                }
331            }
332            MoveGeneratorParameter.ValueChanged += MoveGeneratorParameter_ValueChanged;
333            MoveEvaluatorParameter.ValueChanged += MoveEvaluatorParameter_ValueChanged;
334        }
335
336        public override void Prepare()
337        {
338            if (Problem != null && MoveGenerator != null && MoveMaker != null && MoveEvaluator != null)
339                base.Prepare();
340        }
341
342        #region Events
343        protected override void OnProblemChanged()
344        {
345            foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
346            {
347                op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
348            }
349            UpdateMoveGenerator();
350            UpdateMoveOperators();
351            UpdateAnalyzers();
352            Parameterize();
353            Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
354            base.OnProblemChanged();
355        }
356        protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e)
357        {
358            Parameterize();
359            base.Problem_SolutionCreatorChanged(sender, e);
360        }
361        protected override void Problem_EvaluatorChanged(object sender, EventArgs e)
362        {
363            Parameterize();
364            Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
365            base.Problem_EvaluatorChanged(sender, e);
366        }
367        protected override void Problem_OperatorsChanged(object sender, EventArgs e)
368        {
369            foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
370            {
371                op.MoveQualityParameter.ActualNameChanged -= MoveEvaluator_MoveQualityParameter_ActualNameChanged;
372                op.MoveQualityParameter.ActualNameChanged += MoveEvaluator_MoveQualityParameter_ActualNameChanged;
373            }
374            UpdateMoveGenerator();
375            UpdateMoveOperators();
376            UpdateAnalyzers();
377            Parameterize();
378            base.Problem_OperatorsChanged(sender, e);
379        }
380        private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e)
381        {
382            Parameterize();
383        }
384        private void MoveGeneratorParameter_ValueChanged(object sender, EventArgs e)
385        {
386            UpdateMoveOperators();
387        }
388        private void MoveEvaluatorParameter_ValueChanged(object sender, EventArgs e)
389        {
390            Parameterize();
391        }
392        private void MoveEvaluator_MoveQualityParameter_ActualNameChanged(object sender, EventArgs e)
393        {
394            if (sender == MoveEvaluator) Parameterize();
395        }
396        #endregion
397
398        #region Helpers
399
400        private void UpdateMoveGenerator()
401        {
402            var oldMoveGenerator = MoveGenerator;
403            var defaultMoveGenerator = Problem.Operators.OfType<IMultiMoveGenerator>().FirstOrDefault();
404
405            MoveGeneratorParameter.ValidValues.Clear();
406
407            if (Problem != null)
408            {
409                foreach (var generator in Problem.Operators.OfType<IMultiMoveGenerator>().OrderBy(x => x.Name))
410                    MoveGeneratorParameter.ValidValues.Add(generator);
411            }
412
413            if (oldMoveGenerator != null)
414            {
415                var newMoveGenerator = MoveGeneratorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveGenerator.GetType());
416                if (newMoveGenerator != null) MoveGenerator = newMoveGenerator;
417                else oldMoveGenerator = null;
418            }
419            if (oldMoveGenerator == null && defaultMoveGenerator != null)
420                MoveGenerator = defaultMoveGenerator;
421
422            UpdateMoveOperators();
423        }
424
425        private void UpdateMoveOperators()
426        {
427            var oldMoveMaker = MoveMaker;
428            var oldMoveEvaluator = MoveEvaluator;
429
430            MoveMakerParameter.ValidValues.Clear();
431            MoveEvaluatorParameter.ValidValues.Clear();
432
433            if (MoveGenerator != null)
434            {
435                var moveTypes = MoveGenerator.GetType().GetInterfaces().Where(x => typeof(IMoveOperator).IsAssignableFrom(x)).ToList();
436                foreach (var type in moveTypes.ToList())
437                {
438                    if (moveTypes.Any(t => t != type && type.IsAssignableFrom(t)))
439                        moveTypes.Remove(type);
440                }
441                var operators = Problem.Operators.Where(op => moveTypes.Any(m => m.IsInstanceOfType(op))).ToList();
442                var defaultMoveMaker = operators.OfType<IMoveMaker>().FirstOrDefault();
443                var defaultMoveEvaluator = operators.OfType<ISingleObjectiveMoveEvaluator>().FirstOrDefault();
444
445                foreach (var moveMaker in operators.OfType<IMoveMaker>().OrderBy(op => op.Name))
446                    MoveMakerParameter.ValidValues.Add(moveMaker);
447
448                foreach (var moveEvaluator in operators.OfType<ISingleObjectiveMoveEvaluator>().OrderBy(op => op.Name))
449                    MoveEvaluatorParameter.ValidValues.Add(moveEvaluator);
450
451                if (oldMoveMaker != null)
452                {
453                    var mm = MoveMakerParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveMaker.GetType());
454                    if (mm != null) MoveMaker = mm;
455                    else oldMoveMaker = null;
456                }
457                if (oldMoveMaker == null && defaultMoveMaker != null)
458                    MoveMaker = defaultMoveMaker;
459
460                if (oldMoveEvaluator != null)
461                {
462                    var me = MoveEvaluatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMoveEvaluator.GetType());
463                    if (me != null) MoveEvaluator = me;
464                    else oldMoveEvaluator = null;
465                }
466                if (oldMoveEvaluator == null & defaultMoveEvaluator != null)
467                    MoveEvaluator = defaultMoveEvaluator;
468            }
469        }
470
471        private void UpdateAnalyzers()
472        {
473            Analyzer.Operators.Clear();
474            if (Problem != null)
475            {
476                foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>())
477                {
478                    foreach (var param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
479                        param.Depth = 0;
480                    Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
481                }
482            }
483            var qualityAnalyzer = new QualityAnalyzer();
484            var temperatureAnalyzer = new SingleValueAnalyzer { Name = TemperatureAnalyzerName };
485            Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
486            Analyzer.Operators.Add(temperatureAnalyzer, temperatureAnalyzer.EnabledByDefault);
487        }
488
489        private void Parameterize()
490        {
491
492            #region IStochasticOperator
493            if (Problem != null)
494            {
495                foreach (var op in Problem.Operators.OfType<IStochasticOperator>())
496                {
497                    op.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
498                    op.RandomParameter.Hidden = true;
499                }
500            }
501            #endregion
502
503            #region IIterationBasedOperator
504            if (Problem != null)
505            {
506                foreach (var op in Problem.Operators.OfType<IIterationBasedOperator>())
507                {
508                    op.IterationsParameter.ActualName = IterationsName;
509                    op.IterationsParameter.Hidden = true;
510                    op.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
511                    op.MaximumIterationsParameter.Hidden = true;
512                }
513            }
514            #endregion
515
516            #region Analyzers
517
518            foreach (var qualityAnalyzer in Analyzer.Operators.OfType<QualityAnalyzer>())
519            {
520                qualityAnalyzer.ResultsParameter.ActualName = ResultsName;
521                if (Problem != null)
522                {
523                    qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
524                    qualityAnalyzer.MaximizationParameter.Hidden = true;
525                    qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
526                    qualityAnalyzer.QualityParameter.Depth = 0;
527                    qualityAnalyzer.QualityParameter.Hidden = true;
528                    qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
529                    qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
530                }
531                else
532                {
533                    qualityAnalyzer.MaximizationParameter.Hidden = false;
534                    qualityAnalyzer.QualityParameter.Hidden = false;
535                    qualityAnalyzer.BestKnownQualityParameter.Hidden = false;
536                }
537            }
538
539            var temperatureAnalyzer = Analyzer.Operators.OfType<SingleValueAnalyzer>().FirstOrDefault(x => x.Name == TemperatureAnalyzerName);
540            if (temperatureAnalyzer != null)
541            {
542                temperatureAnalyzer.ResultsParameter.ActualName = ResultsName;
543                temperatureAnalyzer.ResultsParameter.Hidden = true;
544                temperatureAnalyzer.ValueParameter.ActualName = TemperatureName;
545                temperatureAnalyzer.ValueParameter.Hidden = true;
546                temperatureAnalyzer.ValuesParameter.ActualName = TemperatureChartName;
547                temperatureAnalyzer.ValuesParameter.Hidden = true;
548            }
549
550            #endregion
551
552            #region SolutionCreator
553            if (Problem != null)
554            {
555                SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
556                SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
557            }
558            #endregion
559
560            #region Annealing/Reheating Operators
561            foreach (var op in AnnealingOperatorParameter.ValidValues)
562            {
563                op.IndexParameter.ActualName = IterationsName;
564                op.IndexParameter.Hidden = true;
565                op.StartIndexParameter.Value = null;
566                op.StartIndexParameter.ActualName = TemperatureStartIndexName;
567                op.EndIndexParameter.ActualName = MaximumIterationsParameter.Name;
568                op.ValueParameter.ActualName = TemperatureName;
569                op.ValueParameter.Hidden = true;
570                op.StartValueParameter.ActualName = StartTemperatureName;
571                op.StartValueParameter.Hidden = true;
572                op.EndValueParameter.ActualName = LowerTemperatureParameter.Name;
573                op.EndValueParameter.Hidden = true;
574            }
575            foreach (var op in ReheatingOperatorParameter.ValidValues)
576            {
577                op.Parameterize();
578            }
579            #endregion
580
581            #region Move Operators
582            if (Problem != null)
583            {
584                foreach (var op in Problem.Operators.OfType<IMultiMoveGenerator>())
585                {
586                    op.SampleSizeParameter.Value = new IntValue(1);
587                    op.SampleSizeParameter.Hidden = true;
588                }
589                foreach (var op in Problem.Operators.OfType<IMoveMaker>())
590                {
591                    op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
592                    op.QualityParameter.Hidden = true;
593                    if (MoveEvaluator != null)
594                    {
595                        op.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
596                        op.MoveQualityParameter.Hidden = true;
597                    }
598                    else
599                    {
600                        op.MoveQualityParameter.Hidden = false;
601                    }
602                }
603                foreach (var op in Problem.Operators.OfType<ISingleObjectiveMoveEvaluator>())
604                {
605                    op.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
606                    op.QualityParameter.Hidden = true;
607                }
608            }
609            #endregion
610
611            #region MainLoop
612            if (Problem != null)
613            {
614                MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
615                MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
616                MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
617                if (MoveEvaluator != null)
618                    MainLoop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
619            }
620            #endregion
621
622        }
623        #endregion
624    }
625}
Note: See TracBrowser for help on using the repository browser.