public static void RunSelect <T>(string callerName, string sql, T values, Assigner <T> assigner)
{
MySqlCommand command = new MySqlCommand();
command.CommandText = sql;
RunSelect <T>(callerName, command, values, assigner);;
}
public async Task <IHttpActionResult> PutAssigner(int id, Assigner assigner)
{
logger.Info(DateTime.Now + ":" + "Inside the PutAssigner IHttpActionResult in the Assigners Controller");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != assigner.Id)
{
return(BadRequest());
}
_db.Entry(assigner).State = EntityState.Modified;
try
{
await _db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AssignerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static string[] EvaluateData(DataParser.ProblemSettings mode)
{
Video[] videos;
Endpoint[] endpoints;
CacheServer[] cacheServers;
RequestDescription[] requestsDescriptions;
var progress = new Progress <float>(ProgressHandler);
Console.WriteLine("\nParsing Files...\n");
DataParser.ParseFileLines
(DataParser.ReadFile(mode).ToArray(), out videos, out endpoints, out cacheServers, out requestsDescriptions, progress);
Console.WriteLine("\ndone");
//calculate Heuristik
Console.WriteLine("\nCalculate heuristics...\n");
GenerateHeuristic.GenerateHeuristicSteps(videos, cacheServers, progress);
Console.WriteLine("\ndone");
//start greedy assigning
//1 claculate matrix M VxC with every element beeing: sum_over_all_endpoints(benefit / cacheserver_heuristik / video_size)
Console.WriteLine("\nCalculate costs...\n");
GreedyAssign.GenerateHeuristicCosts(videos, cacheServers, progress);
Console.WriteLine("\ndone");
//2 while still space on any cache server: find biggest entry in M and assign V to C --> then set enty to 0. As soon as any cacheserver is full: delete column in M
Console.WriteLine("\nAssign\n");
Assigner.Assign(cacheServers);
return(GetOutput(cacheServers));
}
public TerminationOperator()
: base()
{
Parameters.Add(new LookupParameter <ITerminator>("Terminator", "The termination criteria which sould be checked."));
Parameters.Add(new LookupParameter <BoolValue>("Terminate", "The parameter which will be set to determine if execution should be terminated or schould continue."));
Parameters.Add(new OperatorParameter("ContinueBranch", "The operator which is executed if no termination criteria has met."));
Parameters.Add(new OperatorParameter("TerminateBranch", "The operator which is executed if any termination criteria has met."));
var assigner = new Assigner()
{
Name = "Terminate = false"
};
assigner.LeftSideParameter.ActualName = TerminateParameter.Name;
assigner.RightSideParameter.Value = new BoolValue(false);
var placeholder = new Placeholder()
{
Name = "Check termination criteria (Placeholder)"
};
placeholder.OperatorParameter.ActualName = TerminatorParameter.Name;
BeforeExecutionOperators.Add(assigner);
BeforeExecutionOperators.Add(placeholder);
}
public void Register_Should_Return_String_Of_AlphaNumeric_Characters()
{
AssignerImplementation assignerImplementation = new AssignerImplementation();
var mockAssigner = new Mock <IAssigner>();
var assigner = new Assigner {
};
mockAssigner.Setup(m => m.Register(assigner)).Returns(Task.FromResult <Assigner>(assigner));
Assert.That(assigner, Is.InstanceOf <Assigner>());
}
public async Task <IHttpActionResult> GetAssigner(int id)
{
logger.Info(DateTime.Now + ":" + "Inside the GetAssigner IHttpActionResult in the Assigners Controller");
Assigner assigner = await _db.Assigners.FindAsync(id);
if (assigner == null)
{
return(NotFound());
}
logger.Info("Response" + ":" + JsonConvert.SerializeObject(assigner));
return(Ok(assigner));
}
public async Task <IHttpActionResult> PostAssigner(Assigner assigner)
{
logger.Info(DateTime.Now + ":" + "Inside the PostAssigner IHttpActionResult in the Assigners Controller");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _assigner.Register(assigner);
logger.Info("Response" + ":" + JsonConvert.SerializeObject(assigner));
return(CreatedAtRoute("DefaultApi", new { id = assigner.Id }, assigner));
}
protected object ConvertValue(object value, Type toType, object obj, int index)
{
var(success, converted) = Assigner.Convert(value, toType);
if (!success)
{
throw new NotConvertibleException($"Cannot convert {value.GetType().Name} to {toType.Name}")
{
Object = obj,
Index = index
}
}
;
return(converted);
}
public async Task Register(Assigner assigner)
{
logger.Info("Inside the Register Method");
bool validateForm = (assigner.Name != null && assigner.Position != null && assigner.Username != null);
if (validateForm)
{
logger.Info("Inside the validateForm condition");
assigner.Password = GeneratePassword();
_consultantdb.Assigners.Add(assigner);
await _consultantdb.SaveChangesAsync();
logger.Info("Logged Details :" + JsonConvert.SerializeObject(assigner));
}
}
public void AddRow()
{
_randomIdx = Random.Range(0, rowTypes.Length);
_row = Instantiate(rowTypes[_randomIdx]);
Vector3 pos = _row.transform.position;
pos.z = _lastZ;
_row.transform.position = pos;
_row.transform.SetParent(transform);
Assigner asgn = _row.GetComponent <Assigner> ();
if (asgn != null)
{
asgn.Assign();
}
_lastZ++;
}
public SPSOParticleCreator()
: base()
{
Parameters.Add(new LookupParameter <IRandom>("Random", "The random number generator to use."));
Parameters.Add(new ValueLookupParameter <DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension."));
Parameters.Add(new LookupParameter <RealVector>("RealVector", "Particle's current solution"));
Parameters.Add(new LookupParameter <RealVector>("PersonalBest", "Particle's personal best solution."));
Parameters.Add(new LookupParameter <RealVector>("Velocity", "Particle's current velocity."));
Parameters.Add(new LookupParameter <ISolutionCreator>("SolutionCreator", "The operator that creates the initial position."));
Parameters.Add(new ConstrainedValueParameter <SPSOVelocityInitializer>("VelocityInitializer", "The initialization of the velocity vector."));
VelocityInitializerParameter.ValidValues.Add(new SPSO2011VelocityInitializer());
VelocityInitializerParameter.ValidValues.Add(new SPSO2007VelocityInitializer());
foreach (var init in VelocityInitializerParameter.ValidValues)
{
init.BoundsParameter.ActualName = BoundsParameter.Name;
init.BoundsParameter.Hidden = true;
init.RandomParameter.ActualName = RandomParameter.Name;
init.RealVectorParameter.ActualName = RealVectorParameter.Name;
init.VelocityParameter.ActualName = VelocityParameter.Name;
}
Placeholder realVectorCreater = new Placeholder();
Assigner personalBestPositionAssigner = new Assigner();
Placeholder velocityInitializer = new Placeholder();
OperatorGraph.InitialOperator = realVectorCreater;
realVectorCreater.OperatorParameter.ActualName = SolutionCreatorParameter.Name;
realVectorCreater.Successor = personalBestPositionAssigner;
personalBestPositionAssigner.LeftSideParameter.ActualName = PersonalBestParameter.Name;
personalBestPositionAssigner.RightSideParameter.ActualName = RealVectorParameter.Name;
personalBestPositionAssigner.Successor = velocityInitializer;
velocityInitializer.OperatorParameter.ActualName = VelocityInitializerParameter.Name;
velocityInitializer.Successor = null;
}
public RealVectorParticleCreator()
: base()
{
Parameters.Add(new LookupParameter <IntValue>("ProblemSize", "The dimension of the problem."));
Parameters.Add(new ValueLookupParameter <DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension."));
Parameters.Add(new LookupParameter <RealVector>("RealVector", "Particle's current solution"));
Parameters.Add(new LookupParameter <RealVector>("PersonalBest", "Particle's personal best solution."));
Parameters.Add(new LookupParameter <RealVector>("Velocity", "Particle's current velocity."));
UniformRandomRealVectorCreator realVectorCreater = new UniformRandomRealVectorCreator();
Assigner personalBestPositionAssigner = new Assigner();
OperatorGraph.InitialOperator = realVectorCreater;
realVectorCreater.RealVectorParameter.ActualName = RealVectorParameter.Name;
realVectorCreater.LengthParameter.ActualName = ProblemSizeParameter.Name;
realVectorCreater.BoundsParameter.ActualName = BoundsParameter.Name;
realVectorCreater.Successor = personalBestPositionAssigner;
personalBestPositionAssigner.LeftSideParameter.ActualName = PersonalBestParameter.Name;
personalBestPositionAssigner.RightSideParameter.ActualName = RealVectorParameter.Name;
personalBestPositionAssigner.Successor = null;
}
public void AssignerTest1()
{
var vcard = new VCard();
var textProp = new RelationTextProperty("Hallo");
IEnumerable <RelationProperty>?assignment = Assigner.GetAssignment(textProp, vcard.Relations);
Assert.AreSame(textProp, assignment);
vcard.Relations = assignment;
assignment = Assigner.GetAssignment(textProp, vcard.Relations);
Assert.AreNotSame(textProp, assignment);
Assert.IsInstanceOfType(assignment, typeof(List <RelationProperty>));
IEnumerable <RelationProperty>?list = assignment;
vcard.Relations = assignment;
assignment = Assigner.GetAssignment(textProp, vcard.Relations);
Assert.IsInstanceOfType(assignment, typeof(List <RelationProperty>));
Assert.AreSame(list, assignment);
Assert.AreEqual(3, assignment.Count());
}
public IslandGeneticAlgorithmMainLoop()
: base()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter <IntValue>("NumberOfIslands", "The number of islands."));
Parameters.Add(new ValueLookupParameter <IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
Parameters.Add(new ValueLookupParameter <PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
Parameters.Add(new ValueLookupParameter <IOperator>("Migrator", "The migration strategy."));
Parameters.Add(new ValueLookupParameter <IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
Parameters.Add(new ValueLookupParameter <IOperator>("ImmigrationReplacer", "Replaces some of the original population with the immigrants."));
Parameters.Add(new ValueLookupParameter <IntValue>("PopulationSize", "The size of the population of solutions."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumGenerations", "The maximum number of generations that the algorithm should process."));
Parameters.Add(new ValueLookupParameter <IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter <IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter <PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter <IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter <IOperator>("Evaluator", "The operator used to evaluate solutions."));
Parameters.Add(new ValueLookupParameter <IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter <BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter <ResultCollection>("Results", "The results collection to store the results."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to the analyze the islands."));
Parameters.Add(new ValueLookupParameter <IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
Parameters.Add(new LookupParameter <IntValue>("EvaluatedSolutions", "The number of times a solution has been evaluated."));
Parameters.Add(new LookupParameter <IntValue>("IslandGenerations", "The number of generations calculated on one island."));
Parameters.Add(new LookupParameter <IntValue>("IslandEvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Migrate", "Migrate the island?"));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
VariableCreator islandVariableCreator = new VariableCreator();
Placeholder islandAnalyzer1 = new Placeholder();
LocalRandomCreator localRandomCreator = new LocalRandomCreator();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
Assigner generationsAssigner = new Assigner();
Assigner evaluatedSolutionsAssigner = new Assigner();
Placeholder selector = new Placeholder();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder crossover = new Placeholder();
StochasticBranch stochasticBranch = new StochasticBranch();
Placeholder mutator = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
Placeholder evaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
MergingReducer mergingReducer = new MergingReducer();
IntCounter islandGenerationsCounter = new IntCounter();
Comparator checkIslandGenerationsReachedMaximum = new Comparator();
ConditionalBranch checkContinueEvolution = new ConditionalBranch();
DataReducer generationsReducer = new DataReducer();
DataReducer evaluatedSolutionsReducer = new DataReducer();
Placeholder islandAnalyzer2 = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor5 = new UniformSubScopesProcessor();
Placeholder emigrantsSelector = new Placeholder();
IntCounter migrationsCounter = new IntCounter();
Placeholder migrator = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor6 = new UniformSubScopesProcessor();
Placeholder immigrationReplacer = new Placeholder();
Comparator generationsComparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch generationsTerminationCondition = new ConditionalBranch();
ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Migrations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("GenerationsSinceLastMigration", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Generations", new IntValue(0))); // Class IslandGeneticAlgorithm expects this to be called Generations
islandVariableCreator.CollectedValues.Add(new ValueParameter <ResultCollection>("Results", new ResultCollection()));
islandVariableCreator.CollectedValues.Add(new ValueParameter <IntValue>("IslandGenerations", new IntValue(0)));
islandVariableCreator.CollectedValues.Add(new ValueParameter <IntValue>("IslandEvaluatedSolutions", new IntValue(0)));
islandAnalyzer1.Name = "Island Analyzer (placeholder)";
islandAnalyzer1.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>("Migrations"));
resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter <ResultCollection>("IslandResults", "Result set for each island", "Results"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
uniformSubScopesProcessor1.Parallel.Value = true;
generationsAssigner.Name = "Initialize Island Generations";
generationsAssigner.LeftSideParameter.ActualName = IslandGenerations.Name;
generationsAssigner.RightSideParameter.Value = new IntValue(0);
evaluatedSolutionsAssigner.Name = "Initialize Island evaluated solutions";
evaluatedSolutionsAssigner.LeftSideParameter.ActualName = IslandEvaluatedSolutions.Name;
evaluatedSolutionsAssigner.RightSideParameter.Value = new IntValue(0);
selector.Name = "Selector (placeholder)";
selector.OperatorParameter.ActualName = SelectorParameter.Name;
childrenCreator.ParentsPerChild = new IntValue(2);
crossover.Name = "Crossover (placeholder)";
crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
stochasticBranch.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
//set it to the random number generator of the island
stochasticBranch.RandomParameter.ActualName = "LocalRandom";
mutator.Name = "Mutator (placeholder)";
mutator.OperatorParameter.ActualName = MutatorParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
evaluator.Name = "Evaluator (placeholder)";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = IslandEvaluatedSolutions.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.ActualName = ElitesParameter.Name;
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
islandGenerationsCounter.Name = "Increment island generatrions";
islandGenerationsCounter.ValueParameter.ActualName = IslandGenerations.Name;
islandGenerationsCounter.Increment = new IntValue(1);
checkIslandGenerationsReachedMaximum.LeftSideParameter.ActualName = IslandGenerations.Name;
checkIslandGenerationsReachedMaximum.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
checkIslandGenerationsReachedMaximum.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
checkIslandGenerationsReachedMaximum.ResultParameter.ActualName = Migrate.Name;
checkContinueEvolution.Name = "Migrate?";
checkContinueEvolution.ConditionParameter.ActualName = Migrate.Name;
checkContinueEvolution.FalseBranch = selector;
islandAnalyzer2.Name = "Island Analyzer (placeholder)";
islandAnalyzer2.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
generationsReducer.Name = "Increment Generations";
generationsReducer.ParameterToReduce.ActualName = islandGenerationsCounter.ValueParameter.ActualName;
generationsReducer.TargetParameter.ActualName = "Generations";
generationsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Min);
generationsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.Name = "Increment Evaluated Solutions";
evaluatedSolutionsReducer.ParameterToReduce.ActualName = IslandEvaluatedSolutions.Name;
evaluatedSolutionsReducer.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
evaluatedSolutionsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
emigrantsSelector.Name = "Emigrants Selector (placeholder)";
emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
migrationsCounter.Name = "Increment number of Migrations";
migrationsCounter.ValueParameter.ActualName = "Migrations";
migrationsCounter.Increment = new IntValue(1);
migrator.Name = "Migrator (placeholder)";
migrator.OperatorParameter.ActualName = MigratorParameter.Name;
immigrationReplacer.Name = "Immigration Replacer (placeholder)";
immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
generationsComparator.Name = "Generations >= MaximumGenerations ?";
generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
generationsComparator.LeftSideParameter.ActualName = "Generations";
generationsComparator.ResultParameter.ActualName = "TerminateGenerations";
generationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
generationsTerminationCondition.Name = "Terminate?";
generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
reevaluateElitesBranch.Name = "Reevaluate elites ?";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = uniformSubScopesProcessor0;
uniformSubScopesProcessor0.Operator = islandVariableCreator;
uniformSubScopesProcessor0.Successor = analyzer1;
islandVariableCreator.Successor = islandAnalyzer1;
// BackwardsCompatibility3.3
//the local randoms are created by the island GA itself and are only here to ensure same algorithm results
#region Backwards compatible code, remove local random creator with 3.4 and rewire the operator graph
islandAnalyzer1.Successor = localRandomCreator;
localRandomCreator.Successor = null;
#endregion
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = generationsAssigner;
uniformSubScopesProcessor1.Successor = generationsReducer;
generationsReducer.Successor = evaluatedSolutionsReducer;
evaluatedSolutionsReducer.Successor = migrationsCounter;
migrationsCounter.Successor = uniformSubScopesProcessor5;
generationsAssigner.Successor = evaluatedSolutionsAssigner;
evaluatedSolutionsAssigner.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = subScopesProcessor2;
childrenCreator.Successor = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = crossover;
uniformSubScopesProcessor2.Successor = uniformSubScopesProcessor3;
crossover.Successor = stochasticBranch;
stochasticBranch.FirstBranch = mutator;
stochasticBranch.SecondBranch = null;
stochasticBranch.Successor = subScopesRemover;
mutator.Successor = null;
subScopesRemover.Successor = null;
uniformSubScopesProcessor3.Operator = evaluator;
uniformSubScopesProcessor3.Successor = subScopesCounter;
evaluator.Successor = null;
subScopesCounter.Successor = null;
subScopesProcessor2.Operators.Add(bestSelector);
subScopesProcessor2.Operators.Add(new EmptyOperator());
subScopesProcessor2.Successor = mergingReducer;
mergingReducer.Successor = islandAnalyzer2;
bestSelector.Successor = rightReducer;
rightReducer.Successor = reevaluateElitesBranch;
reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor3;
reevaluateElitesBranch.FalseBranch = null;
reevaluateElitesBranch.Successor = null;
islandAnalyzer2.Successor = islandGenerationsCounter;
islandGenerationsCounter.Successor = checkIslandGenerationsReachedMaximum;
checkIslandGenerationsReachedMaximum.Successor = checkContinueEvolution;
uniformSubScopesProcessor5.Operator = emigrantsSelector;
emigrantsSelector.Successor = null;
uniformSubScopesProcessor5.Successor = migrator;
migrator.Successor = uniformSubScopesProcessor6;
uniformSubScopesProcessor6.Operator = immigrationReplacer;
uniformSubScopesProcessor6.Successor = generationsComparator;
generationsComparator.Successor = analyzer2;
analyzer2.Successor = generationsTerminationCondition;
generationsTerminationCondition.TrueBranch = null;
generationsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
generationsTerminationCondition.Successor = null;
#endregion
}
private void Initialize()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter <IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter <IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter <PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter <IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter <IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter <IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter <BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter <IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter <IntValue>("PopulationSize", "The size of the population."));
Parameters.Add(new ValueLookupParameter <IntValue>("MinimumPopulationSize", "The minimum size of the population of solutions."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumPopulationSize", "The maximum size of the population of solutions."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("ComparisonFactor", "The comparison factor."));
Parameters.Add(new ValueLookupParameter <IntValue>("Effort", "The maximum number of offspring created in each generation."));
Parameters.Add(new ValueLookupParameter <IntValue>("BatchSize", "The number of children that should be created during one iteration of the offspring creation process."));
Parameters.Add(new ValueLookupParameter <ISolutionSimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the genetic algorithm should be applied."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
Assigner assigner1 = new Assigner();
ResultsCollector resultsCollector = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
Placeholder selector = new Placeholder();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor = new UniformSubScopesProcessor();
Placeholder crossover = new Placeholder();
StochasticBranch stochasticBranch = new StochasticBranch();
Placeholder mutator = new Placeholder();
Placeholder evaluator = new Placeholder();
WeightedParentsQualityComparator weightedParentsQualityComparator = new WeightedParentsQualityComparator();
SubScopesRemover subScopesRemover = new SubScopesRemover();
IntCounter intCounter1 = new IntCounter();
IntCounter intCounter2 = new IntCounter();
ConditionalSelector conditionalSelector = new ConditionalSelector();
RightReducer rightReducer1 = new RightReducer();
DuplicatesSelector duplicateSelector = new DuplicatesSelector();
LeftReducer leftReducer1 = new LeftReducer();
ProgressiveOffspringPreserver progressiveOffspringSelector = new ProgressiveOffspringPreserver();
SubScopesCounter subScopesCounter2 = new SubScopesCounter();
ExpressionCalculator calculator1 = new ExpressionCalculator();
ConditionalBranch conditionalBranch1 = new ConditionalBranch();
Comparator comparator1 = new Comparator();
ConditionalBranch conditionalBranch2 = new ConditionalBranch();
LeftReducer leftReducer2 = new LeftReducer();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer2 = new RightReducer();
ScopeCleaner scopeCleaner = new ScopeCleaner();
ScopeRestorer scopeRestorer = new ScopeRestorer();
MergingReducer mergingReducer = new MergingReducer();
IntCounter intCounter3 = new IntCounter();
SubScopesCounter subScopesCounter3 = new SubScopesCounter();
ExpressionCalculator calculator2 = new ExpressionCalculator();
Comparator comparator2 = new Comparator();
ConditionalBranch conditionalBranch3 = new ConditionalBranch();
Placeholder analyzer2 = new Placeholder();
Comparator comparator3 = new Comparator();
ConditionalBranch conditionalBranch4 = new ConditionalBranch();
Comparator comparator4 = new Comparator();
ConditionalBranch conditionalBranch5 = new ConditionalBranch();
Assigner assigner3 = new Assigner();
Assigner assigner4 = new Assigner();
Assigner assigner5 = new Assigner();
ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder evaluator2 = new Placeholder();
SubScopesCounter subScopesCounter4 = new SubScopesCounter();
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Generations", new IntValue(0))); // Class RAPGA expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("CurrentPopulationSize", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("NumberOfCreatedOffspring", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("NumberOfSuccessfulOffspring", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <ScopeList>("OffspringList", new ScopeList()));
assigner1.Name = "Initialize CurrentPopulationSize";
assigner1.LeftSideParameter.ActualName = "CurrentPopulationSize";
assigner1.RightSideParameter.ActualName = PopulationSizeParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("Generations"));
resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("CurrentPopulationSize"));
resultsCollector.ResultsParameter.ActualName = "Results";
analyzer1.Name = "Analyzer";
analyzer1.OperatorParameter.ActualName = "Analyzer";
selector.Name = "Selector";
selector.OperatorParameter.ActualName = "Selector";
childrenCreator.ParentsPerChild = new IntValue(2);
uniformSubScopesProcessor.Parallel.Value = true;
crossover.Name = "Crossover";
crossover.OperatorParameter.ActualName = "Crossover";
stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
stochasticBranch.RandomParameter.ActualName = "Random";
mutator.Name = "Mutator";
mutator.OperatorParameter.ActualName = "Mutator";
evaluator.Name = "Evaluator";
evaluator.OperatorParameter.ActualName = "Evaluator";
weightedParentsQualityComparator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
weightedParentsQualityComparator.LeftSideParameter.ActualName = QualityParameter.Name;
weightedParentsQualityComparator.MaximizationParameter.ActualName = MaximizationParameter.Name;
weightedParentsQualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
weightedParentsQualityComparator.ResultParameter.ActualName = "SuccessfulOffspring";
subScopesRemover.RemoveAllSubScopes = true;
intCounter1.Name = "Increment NumberOfCreatedOffspring";
intCounter1.ValueParameter.ActualName = "NumberOfCreatedOffspring";
intCounter1.Increment = null;
intCounter1.IncrementParameter.ActualName = BatchSizeParameter.Name;
intCounter2.Name = "Increment EvaluatedSolutions";
intCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
intCounter2.Increment = null;
intCounter2.IncrementParameter.ActualName = BatchSizeParameter.Name;
conditionalSelector.ConditionParameter.ActualName = "SuccessfulOffspring";
conditionalSelector.ConditionParameter.Depth = 1;
conditionalSelector.CopySelected.Value = false;
duplicateSelector.CopySelected.Value = false;
progressiveOffspringSelector.OffspringListParameter.ActualName = "OffspringList";
progressiveOffspringSelector.ElitesParameter.ActualName = ElitesParameter.Name;
progressiveOffspringSelector.MaximumPopulationSizeParameter.ActualName = MaximumPopulationSizeParameter.Name;
subScopesCounter2.Name = "Count Successful Offspring";
subScopesCounter2.ValueParameter.ActualName = "NumberOfSuccessfulOffspring";
calculator1.Name = "NumberOfSuccessfulOffspring == MaximumPopulationSize - Elites";
calculator1.CollectedValues.Add(new ValueLookupParameter <IntValue>("NumberOfSuccessfulOffspring"));
calculator1.CollectedValues.Add(new ValueLookupParameter <IntValue>("MaximumPopulationSize"));
calculator1.CollectedValues.Add(new ValueLookupParameter <IntValue>("Elites"));
calculator1.ExpressionParameter.Value = new StringValue("NumberOfSuccessfulOffspring MaximumPopulationSize Elites - ==");
calculator1.ExpressionResultParameter.ActualName = "Break";
conditionalBranch1.Name = "Break?";
conditionalBranch1.ConditionParameter.ActualName = "Break";
comparator1.Name = "NumberOfCreatedOffspring >= Effort";
comparator1.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
comparator1.LeftSideParameter.ActualName = "NumberOfCreatedOffspring";
comparator1.RightSideParameter.ActualName = EffortParameter.Name;
comparator1.ResultParameter.ActualName = "Break";
conditionalBranch2.Name = "Break?";
conditionalBranch2.ConditionParameter.ActualName = "Break";
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
intCounter3.Name = "Increment Generations";
intCounter3.Increment = new IntValue(1);
intCounter3.ValueParameter.ActualName = "Generations";
subScopesCounter3.Name = "Update CurrentPopulationSize";
subScopesCounter3.ValueParameter.ActualName = "CurrentPopulationSize";
subScopesCounter3.AccumulateParameter.Value = new BoolValue(false);
calculator2.Name = "Evaluate ActualSelectionPressure";
calculator2.CollectedValues.Add(new ValueLookupParameter <IntValue>("NumberOfCreatedOffspring"));
calculator2.CollectedValues.Add(new ValueLookupParameter <IntValue>("Elites"));
calculator2.CollectedValues.Add(new ValueLookupParameter <IntValue>("CurrentPopulationSize"));
calculator2.ExpressionParameter.Value = new StringValue("NumberOfCreatedOffspring Elites + CurrentPopulationSize /");
calculator2.ExpressionResultParameter.ActualName = "ActualSelectionPressure";
comparator2.Name = "CurrentPopulationSize < 1";
comparator2.Comparison = new Comparison(ComparisonType.Less);
comparator2.LeftSideParameter.ActualName = "CurrentPopulationSize";
comparator2.RightSideParameter.Value = new IntValue(1);
comparator2.ResultParameter.ActualName = "Terminate";
conditionalBranch3.Name = "Terminate?";
conditionalBranch3.ConditionParameter.ActualName = "Terminate";
analyzer2.Name = "Analyzer";
analyzer2.OperatorParameter.ActualName = "Analyzer";
comparator3.Name = "Generations >= MaximumGenerations";
comparator3.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
comparator3.LeftSideParameter.ActualName = "Generations";
comparator3.ResultParameter.ActualName = "Terminate";
comparator3.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
conditionalBranch4.Name = "Terminate?";
conditionalBranch4.ConditionParameter.ActualName = "Terminate";
comparator4.Name = "CurrentPopulationSize < MinimumPopulationSize";
comparator4.Comparison = new Comparison(ComparisonType.Less);
comparator4.LeftSideParameter.ActualName = "CurrentPopulationSize";
comparator4.RightSideParameter.ActualName = MinimumPopulationSizeParameter.Name;
comparator4.ResultParameter.ActualName = "Terminate";
conditionalBranch5.Name = "Terminate?";
conditionalBranch5.ConditionParameter.ActualName = "Terminate";
assigner3.Name = "Reset NumberOfCreatedOffspring";
assigner3.LeftSideParameter.ActualName = "NumberOfCreatedOffspring";
assigner3.RightSideParameter.Value = new IntValue(0);
assigner4.Name = "Reset NumberOfSuccessfulOffspring";
assigner4.LeftSideParameter.ActualName = "NumberOfSuccessfulOffspring";
assigner4.RightSideParameter.Value = new IntValue(0);
assigner5.Name = "Reset OffspringList";
assigner5.LeftSideParameter.ActualName = "OffspringList";
assigner5.RightSideParameter.Value = new ScopeList();
reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
reevaluateElitesBranch.Name = "Reevaluate elites ?";
uniformSubScopesProcessor2.Parallel.Value = true;
evaluator2.Name = "Evaluator (placeholder)";
evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter4.Name = "Increment EvaluatedSolutions";
subScopesCounter4.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = assigner1;
assigner1.Successor = resultsCollector;
resultsCollector.Successor = analyzer1;
analyzer1.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = calculator1;
childrenCreator.Successor = uniformSubScopesProcessor;
uniformSubScopesProcessor.Operator = crossover;
uniformSubScopesProcessor.Successor = intCounter1;
crossover.Successor = stochasticBranch;
stochasticBranch.FirstBranch = mutator;
stochasticBranch.SecondBranch = null;
mutator.Successor = null;
stochasticBranch.Successor = evaluator;
evaluator.Successor = weightedParentsQualityComparator;
weightedParentsQualityComparator.Successor = subScopesRemover;
intCounter1.Successor = intCounter2;
intCounter2.Successor = conditionalSelector;
conditionalSelector.Successor = rightReducer1;
rightReducer1.Successor = duplicateSelector;
duplicateSelector.Successor = leftReducer1;
leftReducer1.Successor = progressiveOffspringSelector;
progressiveOffspringSelector.Successor = subScopesCounter2;
calculator1.Successor = conditionalBranch1;
conditionalBranch1.FalseBranch = comparator1;
conditionalBranch1.TrueBranch = subScopesProcessor2;
comparator1.Successor = conditionalBranch2;
conditionalBranch2.FalseBranch = leftReducer2;
conditionalBranch2.TrueBranch = subScopesProcessor2;
leftReducer2.Successor = selector;
subScopesProcessor2.Operators.Add(bestSelector);
subScopesProcessor2.Operators.Add(scopeCleaner);
subScopesProcessor2.Successor = mergingReducer;
bestSelector.Successor = rightReducer2;
rightReducer2.Successor = reevaluateElitesBranch;
reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = evaluator2;
uniformSubScopesProcessor2.Successor = subScopesCounter4;
evaluator2.Successor = null;
subScopesCounter4.Successor = null;
reevaluateElitesBranch.FalseBranch = null;
reevaluateElitesBranch.Successor = null;
scopeCleaner.Successor = scopeRestorer;
mergingReducer.Successor = intCounter3;
intCounter3.Successor = subScopesCounter3;
subScopesCounter3.Successor = calculator2;
calculator2.Successor = comparator2;
comparator2.Successor = conditionalBranch3;
conditionalBranch3.FalseBranch = analyzer2;
conditionalBranch3.TrueBranch = null;
analyzer2.Successor = comparator3;
comparator3.Successor = conditionalBranch4;
conditionalBranch4.FalseBranch = comparator4;
conditionalBranch4.TrueBranch = null;
conditionalBranch4.Successor = null;
comparator4.Successor = conditionalBranch5;
conditionalBranch5.FalseBranch = assigner3;
conditionalBranch5.TrueBranch = null;
conditionalBranch5.Successor = null;
assigner3.Successor = assigner4;
assigner4.Successor = assigner5;
assigner5.Successor = selector;
#endregion
}
private void CreateModuleCode()
{
String eventManagerName;
//-----------------------------------------------------------------------------------------------------------------------
//---------------------------------Create module In-Out Structs --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
moduleConditionsToFire = dut.CreateChild(
module.getName + "conditionsToFire",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintModuleOutStruct,
new string[] { "@moduleName@" },
new string[] { module.getName }
)
);
//Structure that defines the Event-Triggers that will be used as inputs in the Eventmanager
moduleEventTriggers = dut.CreateChild(
module.getName + "EventTriggers",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintModuleInStruct,
new string[] { "@moduleName@" },
new string[] { module.getName }
)
);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Fill the ModulesGVL ----------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
modulesGvlImplementation = "\t" + module.getName + ": " + module.getName + ";" + "\n";
decl = (ITcPlcDeclaration)modules;
index = decl.DeclarationText.IndexOf(keyVarGlobal);
decl.DeclarationText =
decl.DeclarationText.Insert(
index + (keyVarGlobal.Length + 1),
modulesGvlImplementation
);
//-----------------------------------------------------------------------------------------------------------------------
//------------------------------------------------Create the FB_TargetModule---------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//604 TREEITEMTYPE_PLCPOUFB POU Function Block
ITcSmTreeItem targetModule = pou.CreateChild(module.getName, 604, "1");
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_TargetModule Methods --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
moduleEventManagerDeclaration = null;
eventNamesLists.Clear();
foreach (EventManager eventManager in module.content)
{
eventNamesLists.Add(eventManager.content.eventNames);
eventManagerNames.Add(eventManager.getName);
moduleEventManagerDeclaration += Assigner.ReplaceBlueprintValues(
"\t" + AssignedConfigFileData.blueprintModuleEventManagerDeclaration + "\n",
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
);
moduleEventManagerImplementation += Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintModuleEventManagerImplementation + "\n",
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
);
}
foreach (String[] eventNamesGroup in eventNamesLists)
{
eventManagerName = eventManagerNames.First();
eventManagerNames.RemoveAt(0);
foreach (String eventName in eventNamesGroup)
{
//Create EventMethods
currentMethod = targetModule.CreateChild(eventName + "Event", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventMethodDeclaration,
new string[] { "@eventName@" },
new string[] { eventName }
);
//Create SenderMethods
currentMethod = targetModule.CreateChild("fire" + Functions.UppercaseFirst(eventName) + "Event", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintSenderMethodDeclaration,
new string[] { "@eventName@" },
new string[] { eventName }
);
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintSenderMethodImplementation,
new string[] { "@eventName@", "@eventManagerName@" },
new string[] { eventName, eventManagerName }
);
outConditionsToFire += "\t" + eventName + "Event : BOOL;\n";
eventRaiserImplementation += Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventRaiserImplementation + "\n",
new string[] { "@eventName@" },
new string[] { eventName }
);
moduleTriggerEventDeclaration += Assigner.ReplaceBlueprintValues(
"\t" + AssignedConfigFileData.blueprintModuleTriggerEventsDeclaration + "\n",
new string[] { "@eventName@" },
new string[] { Functions.UppercaseFirst(eventName) }
);
}
}
//Fill the module structures with the relevant data
//--------------------------------------------------------------------------------
decl = (ITcPlcDeclaration)moduleEventTriggers;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
moduleTriggerEventDeclaration
);
decl = (ITcPlcDeclaration)moduleConditionsToFire;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
outConditionsToFire
);
//--------------------------------------------------------------------------------
//eventRaiser method
currentMethod = targetModule.CreateChild("eventRaiser", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintEventRaiserDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = eventRaiserImplementation;
//callComponents method
currentMethod = targetModule.CreateChild("callComponents", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintCallComponentsDeclaration;
//registerSequence method
currentMethod = targetModule.CreateChild("registerSequence", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintRegisterSequenceDeclarationText;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintRegisterSequenceImplementationText;
//runSequence method
currentMethod = targetModule.CreateChild("runSequence", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintRunSequenceDeclarationText;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintRunSequenceImplementationText;
/*
* currentMethod = targetModule.CreateChild("eventRaiser", 609, "", methodDescription);
*
* //M_EventRaiser
* decl = (ITcPlcDeclaration)currentMethod;
* decl.DeclarationText = AssignedConfigFileData.blueprintEventRaiserDeclaration;
*
* impl = (ITcPlcImplementation)currentMethod;
* impl.ImplementationText = eventRaiserImplementation;
*
* currentMethod = targetModule.CreateChild("callComponents", 609, "", methodDescription);
*
* //M_CallComponents
* decl = (ITcPlcDeclaration)currentMethod;
* decl.DeclarationText = AssignedConfigFileData.blueprintCallComponentsDeclaration;
*/
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Fill the declaration and implementation part of FB_TargetModule with code-------------------
//-----------------------------------------------------------------------------------------------------------------------
decl = (ITcPlcDeclaration)targetModule;
impl = (ITcPlcImplementation)targetModule;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.modulesDeclarations[targetIndex],
new string[] { "@eventManagers", "@moduleName@" },
new string[] { moduleEventManagerDeclaration, module.getName }
);
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.modulesImplementations[targetIndex],
new string[] { "@eventManagers" },
new string[] { moduleEventManagerImplementation }
);
}
private void Initialize()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new LookupParameter <DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
Parameters.Add(new LookupParameter <DoubleValue>("Temperature", "The current temperature."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("StartTemperature", "The initial temperature."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("EndTemperature", "The end temperature."));
Parameters.Add(new ValueLookupParameter <IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again)."));
Parameters.Add(new LookupParameter <IntValue>("Iterations", "The number of iterations."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveGenerator", "The operator that generates the moves."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveEvaluator", "The operator that evaluates a move."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
Parameters.Add(new ValueLookupParameter <IOperator>("AnnealingOperator", "The operator that modifies the temperature."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new LookupParameter <IntValue>("EvaluatedMoves", "The number of evaluated moves."));
#endregion
#region Create operators
Assigner temperatureInitializer = new Assigner();
ResultsCollector resultsCollector1 = new ResultsCollector();
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Placeholder analyzer1 = new Placeholder();
SubScopesProcessor sssp = new SubScopesProcessor();
ResultsCollector resultsCollector = new ResultsCollector();
Placeholder annealingOperator = new Placeholder();
UniformSubScopesProcessor mainProcessor = new UniformSubScopesProcessor();
Placeholder moveGenerator = new Placeholder();
UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
Placeholder moveEvaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
ProbabilisticQualityComparator qualityComparator = new ProbabilisticQualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Placeholder moveMaker = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch iterationsTermination = new ConditionalBranch();
temperatureInitializer.LeftSideParameter.ActualName = TemperatureParameter.ActualName;
temperatureInitializer.RightSideParameter.ActualName = StartTemperatureParameter.Name;
resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>(IterationsParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
annealingOperator.Name = "Annealing operator (placeholder)";
annealingOperator.OperatorParameter.ActualName = AnnealingOperatorParameter.Name;
moveGenerator.Name = "Move generator (placeholder)";
moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
moveEvaluator.Name = "Move evaluator (placeholder)";
moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedMoves";
subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
qualityComparator.ResultParameter.ActualName = "IsBetter";
qualityComparator.DampeningParameter.ActualName = "Temperature";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
moveMaker.Name = "Move maker (placeholder)";
moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
iterationsCounter.Name = "Increment Iterations";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
iterationsTermination.Name = "Iterations termination condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = temperatureInitializer;
temperatureInitializer.Successor = resultsCollector1;
resultsCollector1.Successor = subScopesProcessor0;
subScopesProcessor0.Operators.Add(analyzer1);
subScopesProcessor0.Successor = sssp;
analyzer1.Successor = null;
sssp.Operators.Add(resultsCollector);
sssp.Successor = annealingOperator;
resultsCollector.Successor = null;
annealingOperator.Successor = mainProcessor;
mainProcessor.Operator = moveGenerator;
mainProcessor.Successor = iterationsCounter;
moveGenerator.Successor = moveEvaluationProcessor;
moveEvaluationProcessor.Operator = moveEvaluator;
moveEvaluationProcessor.Successor = subScopesCounter;
moveEvaluator.Successor = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = moveMaker;
improvesQualityBranch.FalseBranch = null;
improvesQualityBranch.Successor = null;
moveMaker.Successor = null;
subScopesCounter.Successor = subScopesRemover;
subScopesRemover.Successor = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(analyzer2);
subScopesProcessor1.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = annealingOperator;
#endregion
}
public AlpsOffspringSelectionGeneticAlgorithm()
: base()
{
#region Add parameters
Parameters.Add(new FixedValueParameter <IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new FixedValueParameter <BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new FixedValueParameter <MultiAnalyzer>("Analyzer", "The operator used to analyze all individuals from all layers combined.", new MultiAnalyzer()));
Parameters.Add(new FixedValueParameter <MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
Parameters.Add(new FixedValueParameter <IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
Parameters.Add(new FixedValueParameter <IntValue>("PopulationSize", "The size of the population of solutions in each layer.", new IntValue(100)));
Parameters.Add(new ConstrainedValueParameter <ISelector>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ConstrainedValueParameter <ICrossover>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ConstrainedValueParameter <IManipulator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new FixedValueParameter <PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
Parameters.Add(new FixedValueParameter <IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
Parameters.Add(new FixedValueParameter <BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false))
{
Hidden = true
});
Parameters.Add(new FixedValueParameter <DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
Parameters.Add(new FixedValueParameter <DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1].", new DoubleValue(1)));
Parameters.Add(new FixedValueParameter <DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
Parameters.Add(new FixedValueParameter <BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
Parameters.Add(new FixedValueParameter <IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems.", new IntValue(200)));
Parameters.Add(new FixedValueParameter <BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false))
{
Hidden = true
});
Parameters.Add(new FixedValueParameter <EnumValue <AgingScheme> >("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue <AgingScheme>(ALPS.AgingScheme.Polynomial)));
Parameters.Add(new FixedValueParameter <IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(20)));
Parameters.Add(new FixedValueParameter <DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(1.0))
{
Hidden = true
});
Parameters.Add(new FixedValueParameter <IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0]))
{
Hidden = true
});
Parameters.Add(new FixedValueParameter <IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1))
{
Hidden = true
});
Parameters.Add(new FixedValueParameter <BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true))
{
Hidden = true
});
Parameters.Add(new FixedValueParameter <MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
#endregion
#region Create operators
var globalRandomCreator = new RandomCreator();
var layer0Creator = new SubScopesCreator()
{
Name = "Create Layer Zero"
};
var layer0Processor = new SubScopesProcessor();
var localRandomCreator = new LocalRandomCreator();
var layerSolutionsCreator = new SolutionsCreator();
var initializeAgeProcessor = new UniformSubScopesProcessor();
var initializeAge = new VariableCreator()
{
Name = "Initialize Age"
};
var initializeCurrentPopulationSize = new SubScopesCounter()
{
Name = "Initialize CurrentPopulationCounter"
};
var initializeLocalEvaluatedSolutions = new Assigner()
{
Name = "Initialize LayerEvaluatedSolutions"
};
var initializeGlobalEvaluatedSolutions = new DataReducer()
{
Name = "Initialize EvaluatedSolutions"
};
var resultsCollector = new ResultsCollector();
var mainLoop = new AlpsOffspringSelectionGeneticAlgorithmMainLoop();
#endregion
#region Create and parameterize operator graph
OperatorGraph.InitialOperator = globalRandomCreator;
globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
globalRandomCreator.SeedParameter.Value = null;
globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
globalRandomCreator.SetSeedRandomlyParameter.Value = null;
globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
globalRandomCreator.Successor = layer0Creator;
layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
layer0Creator.Successor = layer0Processor;
layer0Processor.Operators.Add(localRandomCreator);
layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
localRandomCreator.Successor = layerSolutionsCreator;
layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
layerSolutionsCreator.Successor = initializeAgeProcessor;
initializeAgeProcessor.Operator = initializeAge;
initializeAgeProcessor.Successor = initializeCurrentPopulationSize;
initializeCurrentPopulationSize.ValueParameter.ActualName = "CurrentPopulationSize";
initializeCurrentPopulationSize.Successor = initializeLocalEvaluatedSolutions;
initializeAge.CollectedValues.Add(new ValueParameter <DoubleValue>("Age", new DoubleValue(0)));
initializeAge.Successor = null;
initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "CurrentPopulationSize";
initializeLocalEvaluatedSolutions.Successor = null;
initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
resultsCollector.Successor = mainLoop;
mainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
mainLoop.LocalRandomParameter.ActualName = localRandomCreator.LocalRandomParameter.Name;
mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
mainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
mainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
mainLoop.AgeParameter.ActualName = "Age";
mainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
mainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
mainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
mainLoop.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
mainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
mainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
#endregion
#region Set operators
foreach (var selector in ApplicationManager.Manager.GetInstances <ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
{
SelectorParameter.ValidValues.Add(selector);
}
var defaultSelector = SelectorParameter.ValidValues.OfType <GeneralizedRankSelector>().FirstOrDefault();
if (defaultSelector != null)
{
defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
SelectorParameter.Value = defaultSelector;
}
#endregion
#region Create analyzers
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
ageAnalyzer = new OldestAverageYoungestAgeAnalyzer();
layerAgeAnalyzer = new OldestAverageYoungestAgeAnalyzer();
ageDistributionAnalyzer = new AgeDistributionAnalyzer();
layerAgeDistributionAnalyzer = new AgeDistributionAnalyzer();
selectionPressureAnalyzer = new ValueAnalyzer();
layerSelectionPressureAnalyzer = new ValueAnalyzer();
currentSuccessRatioAnalyzer = new ValueAnalyzer();
#endregion
#region Create terminators
generationsTerminator = new ComparisonTerminator <IntValue>("Generations", ComparisonType.Less, new IntValue(1000))
{
Name = "Generations"
};
evaluationsTerminator = new ComparisonTerminator <IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue))
{
Name = "Evaluations"
};
qualityTerminator = new SingleObjectiveQualityTerminator()
{
Name = "Quality"
};
executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
#endregion
#region Parameterize
UpdateAnalyzers();
ParameterizeAnalyzers();
ParameterizeSelectors();
UpdateTerminators();
ParameterizeAgeLimits();
#endregion
Initialize();
}
private void CreateEventManagerCode()
{
//-----------------------------------------------------------------------------------------------------------------------
//------------------------------------------------Create the FB_EventManager---------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
foreach (EventManager eventManager in module.content)
{
ITcSmTreeItem fbEventManager = eventManagers.CreateChild(eventManager.getName + "EventManager", 604, "1");
String[] eventNameGroup = eventManager.content.eventNames;
outEventManagerEvents = null;
eventManagerEventsStrings = null;
eventDispatcherImplementation = null;
handlerOperations = null;
enumEventDeclaration = null;
triggersImplementation = null;
foreach (String eventName in eventNameGroup)
{
outEventManagerEvents += "\t" + eventName + "Event : BOOL;\n";
if (eventNameGroup.Last() == eventName)
{
eventManagerEventsStrings += "\t\t'" + eventName + "Event'\n";
}
else
{
eventManagerEventsStrings += "\t\t'" + eventName + "Event',\n";
}
eventDispatcherImplementation += Assigner.ReplaceBlueprintValues(
"\n" + AssignedConfigFileData.blueprintEventDispatcherImplementation,
new string[] { "@eventManagerName@", "@eventName@" },
new string[] { eventManager.getName, eventName }
);
handlerOperations += Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintHandlerOperation + "\n",
new string[] { "@eventManagerName@", "@eventName@", "@moduleName@" },
new string[] { eventManager.getName, eventName, module.getName }
);
enumEventDeclaration += "\t" + eventName + "Event,\n";
triggersImplementation += "\t" + eventName + "RTrigger : R_TRIG;" + "\n";
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_EventManager eventReceivers -------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//Implement receivers
currentReceiver = fbEventManager.CreateChild(eventName + "Receiver", 611, "", propertyDescription);
decl = (ITcPlcDeclaration)currentReceiver;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintReceiversDeclaration,
new string[] { "@eventName@" },
new string[] { eventName }
);
//Implement getters
currentReceiver = currentReceiver.CreateChild("", 613, "", "1");
impl = (ITcPlcImplementation)currentReceiver;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintReceiversGetterImplementation,
new string[] { "@eventManagerName@", "@eventName@" },
new string[] { eventManager.getName, eventName }
);
}
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Create the E_<X>Event Enumaration ---------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//605 TREEITEMTYPE_PLCDUTENUM DUT enum data type
dut.CreateChild(
eventManager.getName + "Event",
605, "",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEnumEventDeclaration,
new string[] { "@eventManagerName@", "@eventNames" },
new string[] { eventManager.getName, enumEventDeclaration }
)
);
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Create the EventManager-Structures ----------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
dut.CreateChild(
eventManager.getName + "EventRecord",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventRecordDeclaration,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
)
);
//Structure that defines the Event-Triggers that will be used as inputs in the Eventmanager
eventManagerEventTriggers = dut.CreateChild(
eventManager.getName + "EventTriggers",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerInStruct,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
)
);
decl = (ITcPlcDeclaration)eventManagerEventTriggers;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
triggersImplementation
);
eventManagerEventReceivers = dut.CreateChild(
eventManager.getName + "EventReceiver",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerOutStruct,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
)
);
decl = (ITcPlcDeclaration)eventManagerEventReceivers;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
outEventManagerEvents
);
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Fill the declaration and implementation part of FB_EventManager with code-------------------
//-----------------------------------------------------------------------------------------------------------------------
decl = (ITcPlcDeclaration)fbEventManager;
impl = (ITcPlcImplementation)fbEventManager;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerDeclaration,
new string[] { "@eventManagerName@", "@eventStrings", "@moduleName@" },
new string[] { eventManager.getName, eventManagerEventsStrings, module.getName }
);
impl.ImplementationText = AssignedConfigFileData.blueprintEventManagerImplementation;
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_EventManager Methods --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//M_CheckForRaceCondition
currentMethod = fbEventManager.CreateChild("checkForRaceCondition", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintRaceConditionDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintRaceConditionImplementation,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
);
//M_EventDispatcher
currentMethod = fbEventManager.CreateChild("eventDispatcher", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintEventDispatcherDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = eventDispatcherImplementation;
//M_ExecuteHandler
currentMethod = fbEventManager.CreateChild("executeHandler", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintExecuteHandlerDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintExecuteHandlerImplementation,
new string[] { "@handlerOperations" },
new string[] { handlerOperations }
);
//M_UpdateEventHistory
currentMethod = fbEventManager.CreateChild("updateEventHistory", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintUpdateEventHistoryDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintUpdateEventHistoryImplementation;
//M_UpdateEventRecord
currentMethod = fbEventManager.CreateChild("updateEventRecord", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintUpdateEventRecordDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintUpdateEventRecordImplementation,
new string[] { "@unequal" },
new string[] { "<>" }
);
//FB_Init
currentMethod = fbEventManager.CreateChild("FB_init", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerFBInitDeclarationText,
new string[] { "@moduleName@" },
new string[] { module.getName }
);
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerFBInitImplementationText,
new string[] { "@moduleName@" },
new string[] { module.getName }
);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_EventManager disable signal -------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
disableSignal =
fbEventManager.
CreateChild("disableEventManagerSignal", 611, "", propertyDescription);
decl = (ITcPlcDeclaration)disableSignal;
decl.DeclarationText = AssignedConfigFileData.blueprintDisableEventManagerSignalDeclaration;
//Implement getter
currentSignal = disableSignal.CreateChild("", 613, "", "1");
impl = (ITcPlcImplementation)currentSignal;
impl.ImplementationText = AssignedConfigFileData.blueprintDisableEventManagerSignalGetterImplementation;
//Implement setter
currentSignal = disableSignal.CreateChild("", 614, "", "1");
impl = (ITcPlcImplementation)currentSignal;
impl.ImplementationText = AssignedConfigFileData.blueprintDisableEventManagerSignalSetterImplementation;
Console.WriteLine("Code for " + eventManager.getName + "EventManager" + " created.");
}
}
public AlpsGeneticAlgorithmMainLoop()
: base()
{
Parameters.Add(new ValueLookupParameter <IRandom>("GlobalRandom", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <IRandom>("LocalRandom", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter <IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ScopeTreeLookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze all individuals from all layers combined."));
Parameters.Add(new ValueLookupParameter <IOperator>("LayerAnalyzer", "The operator used to analyze each layer."));
Parameters.Add(new ValueLookupParameter <IntValue>("NumberOfLayers", "The number of layers."));
Parameters.Add(new ValueLookupParameter <IntValue>("PopulationSize", "The size of the population of solutions in each layer."));
Parameters.Add(new LookupParameter <IntValue>("CurrentPopulationSize", "The current size of the population."));
Parameters.Add(new ValueLookupParameter <IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter <IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter <IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter <PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter <IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter <BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter <BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation."));
Parameters.Add(new ScopeTreeLookupParameter <DoubleValue>("Age", "The age of individuals."));
Parameters.Add(new ValueLookupParameter <IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
Parameters.Add(new ValueLookupParameter <IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
Parameters.Add(new ValueLookupParameter <IntValue>("MatingPoolRange", "The range of sub - populations used for creating a mating pool. (1 = current + previous sub-population)"));
Parameters.Add(new ValueLookupParameter <BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize"));
Parameters.Add(new ValueLookupParameter <IOperator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop"));
var variableCreator = new VariableCreator()
{
Name = "Initialize"
};
var initLayerAnalyzerProcessor = new SubScopesProcessor();
var layerVariableCreator = new VariableCreator()
{
Name = "Initialize Layer"
};
var initLayerAnalyzerPlaceholder = new Placeholder()
{
Name = "LayerAnalyzer (Placeholder)"
};
var initAnalyzerPlaceholder = new Placeholder()
{
Name = "Analyzer (Placeholder)"
};
var resultsCollector = new ResultsCollector();
var matingPoolCreator = new MatingPoolCreator()
{
Name = "Create Mating Pools"
};
var matingPoolProcessor = new UniformSubScopesProcessor()
{
Name = "Process Mating Pools"
};
var initializeLayer = new Assigner()
{
Name = "Reset LayerEvaluatedSolutions"
};
var mainOperator = new AlpsGeneticAlgorithmMainOperator();
var generationsIcrementor = new IntCounter()
{
Name = "Increment Generations"
};
var evaluatedSolutionsReducer = new DataReducer()
{
Name = "Increment EvaluatedSolutions"
};
var eldersEmigrator = CreateEldersEmigrator();
var layerOpener = CreateLayerOpener();
var layerReseeder = CreateReseeder();
var layerAnalyzerProcessor = new UniformSubScopesProcessor();
var layerAnalyzerPlaceholder = new Placeholder()
{
Name = "LayerAnalyzer (Placeholder)"
};
var analyzerPlaceholder = new Placeholder()
{
Name = "Analyzer (Placeholder)"
};
var termination = new TerminationOperator();
OperatorGraph.InitialOperator = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Generations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("OpenLayers", new IntValue(1)));
variableCreator.Successor = initLayerAnalyzerProcessor;
initLayerAnalyzerProcessor.Operators.Add(layerVariableCreator);
initLayerAnalyzerProcessor.Successor = initAnalyzerPlaceholder;
layerVariableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Layer", new IntValue(0)));
layerVariableCreator.CollectedValues.Add(new ValueParameter <ResultCollection>("LayerResults"));
layerVariableCreator.Successor = initLayerAnalyzerPlaceholder;
initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
initLayerAnalyzerPlaceholder.Successor = null;
initAnalyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
initAnalyzerPlaceholder.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("Generations"));
resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter <ResultCollection>("LayerResults", "Result set for each Layer", "LayerResults"));
resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>("OpenLayers"));
resultsCollector.CopyValue = new BoolValue(false);
resultsCollector.Successor = matingPoolCreator;
matingPoolCreator.MatingPoolRangeParameter.Value = null;
matingPoolCreator.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
matingPoolCreator.Successor = matingPoolProcessor;
matingPoolProcessor.Parallel.Value = true;
matingPoolProcessor.Operator = initializeLayer;
matingPoolProcessor.Successor = generationsIcrementor;
initializeLayer.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
initializeLayer.RightSideParameter.Value = new IntValue(0);
initializeLayer.Successor = mainOperator;
mainOperator.RandomParameter.ActualName = LocalRandomParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.ActualName;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
mainOperator.AgeParameter.ActualName = AgeParameter.Name;
mainOperator.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
mainOperator.AgeIncrementParameter.Value = new DoubleValue(1.0);
mainOperator.Successor = null;
generationsIcrementor.ValueParameter.ActualName = "Generations";
generationsIcrementor.Increment = new IntValue(1);
generationsIcrementor.Successor = evaluatedSolutionsReducer;
evaluatedSolutionsReducer.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
evaluatedSolutionsReducer.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
evaluatedSolutionsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.Successor = eldersEmigrator;
eldersEmigrator.Successor = layerOpener;
layerOpener.Successor = layerReseeder;
layerReseeder.Successor = layerAnalyzerProcessor;
layerAnalyzerProcessor.Operator = layerAnalyzerPlaceholder;
layerAnalyzerProcessor.Successor = analyzerPlaceholder;
layerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
analyzerPlaceholder.Successor = termination;
termination.TerminatorParameter.ActualName = TerminatorParameter.Name;
termination.ContinueBranch = matingPoolCreator;
}
private CombinedOperator CreateLayerOpener()
{
var layerOpener = new CombinedOperator()
{
Name = "Open new Layer if needed"
};
var maxLayerReached = new Comparator()
{
Name = "MaxLayersReached = OpenLayers >= NumberOfLayers"
};
var maxLayerReachedBranch = new ConditionalBranch()
{
Name = "MaxLayersReached?"
};
var openNewLayerCalculator = new ExpressionCalculator()
{
Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]"
};
var openNewLayerBranch = new ConditionalBranch()
{
Name = "OpenNewLayer?"
};
var layerCreator = new LastLayerCloner()
{
Name = "Create Layer"
};
var updateLayerNumber = new Assigner()
{
Name = "Layer = OpenLayers"
};
var historyWiper = new ResultsHistoryWiper()
{
Name = "Clear History in Results"
};
var createChildrenViaCrossover = new AlpsGeneticAlgorithmMainOperator();
var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter()
{
Name = "Update EvaluatedSolutions"
};
var incrOpenLayers = new IntCounter()
{
Name = "Incr. OpenLayers"
};
var newLayerResultsCollector = new ResultsCollector()
{
Name = "Collect new Layer Results"
};
layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
maxLayerReached.RightSideParameter.ActualName = NumberOfLayersParameter.Name;
maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxLayerReached.Successor = maxLayerReachedBranch;
maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
openNewLayerCalculator.CollectedValues.Add(new LookupParameter <IntArray>(AgeLimitsParameter.Name));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter <IntValue>("Generations"));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter <IntValue>(NumberOfLayersParameter.Name));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter <IntValue>("OpenLayers"));
openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
openNewLayerCalculator.Successor = openNewLayerBranch;
openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
openNewLayerBranch.TrueBranch = layerCreator;
layerCreator.NewLayerOperator = updateLayerNumber;
layerCreator.Successor = incrOpenLayers;
updateLayerNumber.LeftSideParameter.ActualName = "Layer";
updateLayerNumber.RightSideParameter.ActualName = "OpenLayers";
updateLayerNumber.Successor = historyWiper;
historyWiper.ResultsParameter.ActualName = "LayerResults";
historyWiper.Successor = createChildrenViaCrossover;
// Maybe use only crossover and no elitism instead of "default operator"
createChildrenViaCrossover.RandomParameter.ActualName = LocalRandomParameter.Name;
createChildrenViaCrossover.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
createChildrenViaCrossover.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
createChildrenViaCrossover.QualityParameter.ActualName = QualityParameter.Name;
createChildrenViaCrossover.MaximizationParameter.ActualName = MaximizationParameter.Name;
createChildrenViaCrossover.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
createChildrenViaCrossover.SelectorParameter.ActualName = SelectorParameter.Name;
createChildrenViaCrossover.CrossoverParameter.ActualName = CrossoverParameter.Name;
createChildrenViaCrossover.MutatorParameter.ActualName = MutatorParameter.Name;
createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
createChildrenViaCrossover.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
createChildrenViaCrossover.AgeParameter.ActualName = AgeParameter.Name;
createChildrenViaCrossover.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
createChildrenViaCrossover.AgeIncrementParameter.Value = new DoubleValue(0.0);
createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
incrOpenLayers.ValueParameter.ActualName = "OpenLayers";
incrOpenLayers.Increment = new IntValue(1);
incrOpenLayers.Successor = newLayerResultsCollector;
newLayerResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter <ResultCollection>("LayerResults", "Result set for each layer", "LayerResults"));
newLayerResultsCollector.CopyValue = new BoolValue(false);
newLayerResultsCollector.Successor = null;
return(layerOpener);
}
public static void RunSelect <T>(string callerName, MySqlCommand command, T values, Assigner <T> assigner)
{
MySqlConnection connection = null;
try
{
using (connection = new MySqlConnection(Settings.ConnectionString))
{
connection.Open();
command.Connection = connection;
command.CommandTimeout = 600;
using (MySqlDataAdapter adapter = new MySqlDataAdapter(command))
{
HashSet <string> newKeywords = new HashSet <string>();
using (MySqlDataReader reader = adapter.SelectCommand.ExecuteReader())
{
while (reader.Read())
{
assigner(values, reader);
}
reader.Close();
}
}
command.Dispose();
connection.Close();
}
}
catch (Exception e)
{
Output.Print(callerName, "Exception while running query:" + Environment.NewLine
+ e + Environment.NewLine
+ "Query was:" + Environment.NewLine
+ command.CommandText);
}
finally
{
try
{
if (connection != null && connection.State != System.Data.ConnectionState.Closed)
{
connection.Close();
}
}
catch (Exception e)
{
Output.Print(callerName, "Exception while closing DB connection:" + Environment.NewLine + e);
}
}
}
public ParticleSwarmOptimization()
: base()
{
Parameters.Add(new ValueParameter <IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter <BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ValueParameter <IntValue>("SwarmSize", "Size of the particle swarm.", new IntValue(40)));
Parameters.Add(new ValueParameter <IntValue>("MaxIterations", "Maximal number of iterations.", new IntValue(1000)));
Parameters.Add(new ValueParameter <MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
Parameters.Add(new ValueParameter <DoubleValue>("Inertia", "Inertia weight on a particle's movement (omega).", new DoubleValue(0.721)));
Parameters.Add(new ValueParameter <DoubleValue>("PersonalBestAttraction", "Weight for particle's pull towards its personal best soution (phi_p).", new DoubleValue(1.193)));
Parameters.Add(new ValueParameter <DoubleValue>("NeighborBestAttraction", "Weight for pull towards the neighborhood best solution or global best solution in case of a totally connected topology (phi_g).", new DoubleValue(1.193)));
Parameters.Add(new ConstrainedValueParameter <IParticleCreator>("ParticleCreator", "Operator that creates a new particle."));
Parameters.Add(new ConstrainedValueParameter <IParticleUpdater>("ParticleUpdater", "Operator that updates a particle."));
Parameters.Add(new OptionalConstrainedValueParameter <ITopologyInitializer>("TopologyInitializer", "Creates neighborhood description vectors."));
Parameters.Add(new OptionalConstrainedValueParameter <ITopologyUpdater>("TopologyUpdater", "Updates the neighborhood description vectors."));
Parameters.Add(new OptionalConstrainedValueParameter <IDiscreteDoubleValueModifier>("InertiaUpdater", "Updates the omega parameter."));
Parameters.Add(new ConstrainedValueParameter <ISwarmUpdater>("SwarmUpdater", "Encoding-specific parameter which is provided by the problem. May provide additional encoding-specific parameters, such as velocity bounds for real valued problems"));
RandomCreator randomCreator = new RandomCreator();
VariableCreator variableCreator = new VariableCreator();
Assigner currentInertiaAssigner = new Assigner();
solutionsCreator = new SolutionsCreator();
SubScopesCounter subScopesCounter = new SubScopesCounter();
Placeholder topologyInitializerPlaceholder = new Placeholder();
mainLoop = new ParticleSwarmOptimizationMainLoop();
OperatorGraph.InitialOperator = randomCreator;
randomCreator.SetSeedRandomlyParameter.Value = null;
randomCreator.SeedParameter.Value = null;
randomCreator.Successor = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Iterations", new IntValue(0)));
variableCreator.Successor = currentInertiaAssigner;
currentInertiaAssigner.Name = "CurrentInertia := Inertia";
currentInertiaAssigner.LeftSideParameter.ActualName = "CurrentInertia";
currentInertiaAssigner.RightSideParameter.ActualName = "Inertia";
currentInertiaAssigner.Successor = solutionsCreator;
solutionsCreator.NumberOfSolutionsParameter.ActualName = "SwarmSize";
ParameterizeSolutionsCreator();
solutionsCreator.Successor = subScopesCounter;
subScopesCounter.Name = "Initialize EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
subScopesCounter.Successor = topologyInitializerPlaceholder;
topologyInitializerPlaceholder.Name = "(TopologyInitializer)";
topologyInitializerPlaceholder.OperatorParameter.ActualName = "TopologyInitializer";
topologyInitializerPlaceholder.Successor = mainLoop;
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.InertiaParameter.ActualName = "CurrentInertia";
mainLoop.MaxIterationsParameter.ActualName = MaxIterationsParameter.Name;
mainLoop.NeighborBestAttractionParameter.ActualName = NeighborBestAttractionParameter.Name;
mainLoop.InertiaUpdaterParameter.ActualName = InertiaUpdaterParameter.Name;
mainLoop.ParticleUpdaterParameter.ActualName = ParticleUpdaterParameter.Name;
mainLoop.PersonalBestAttractionParameter.ActualName = PersonalBestAttractionParameter.Name;
mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
mainLoop.SwarmSizeParameter.ActualName = SwarmSizeParameter.Name;
mainLoop.TopologyUpdaterParameter.ActualName = TopologyUpdaterParameter.Name;
mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
mainLoop.ResultsParameter.ActualName = "Results";
InitializeAnalyzers();
InitializeParticleCreator();
InitializeSwarmUpdater();
ParameterizeSolutionsCreator();
UpdateAnalyzers();
UpdateInertiaUpdater();
InitInertiaUpdater();
UpdateTopologyInitializer();
Initialize();
ParameterizeMainLoop();
}
private void Initialize()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter <IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new LookupParameter <IntValue>("Iterations", "The iterations to count."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze the solution."));
Parameters.Add(new LookupParameter <IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
Parameters.Add(new ValueLookupParameter <ILocalImprovementOperator>("LocalImprovement", "The local improvement operation."));
Parameters.Add(new ValueLookupParameter <IMultiNeighborhoodShakingOperator>("ShakingOperator", "The shaking operation."));
Parameters.Add(new LookupParameter <IntValue>("CurrentNeighborhoodIndex", "The index of the current shaking operation that should be applied."));
Parameters.Add(new LookupParameter <IntValue>("NeighborhoodCount", "The number of neighborhood operators used for shaking."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
CombinedOperator iteration = new CombinedOperator();
Assigner iterationInit = new Assigner();
SubScopesCloner createChild = new SubScopesCloner();
SubScopesProcessor childProcessor = new SubScopesProcessor();
Assigner qualityAssigner = new Assigner();
Placeholder shaking = new Placeholder();
Placeholder localImprovement = new Placeholder();
Placeholder evaluator = new Placeholder();
IntCounter evalCounter = new IntCounter();
QualityComparator qualityComparator = new QualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Assigner bestQualityUpdater = new Assigner();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
IntCounter indexCounter = new IntCounter();
Assigner indexResetter = new Assigner();
Placeholder analyzer2 = new Placeholder();
Comparator indexComparator = new Comparator();
ConditionalBranch indexTermination = new ConditionalBranch();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter <BoolValue>("IsBetter", new BoolValue(false)));
variableCreator.CollectedValues.Add(new ValueParameter <DoubleValue>("BestQuality", new DoubleValue(0)));
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = "BestQuality";
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter <DoubleValue>("Best Quality", null, "BestQuality"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
iteration.Name = "MainLoop Body";
iterationInit.Name = "Init k = 0";
iterationInit.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
iterationInit.RightSideParameter.Value = new IntValue(0);
createChild.Name = "Clone solution";
qualityAssigner.Name = "Assign quality";
qualityAssigner.LeftSideParameter.ActualName = "OriginalQuality";
qualityAssigner.RightSideParameter.ActualName = QualityParameter.Name;
shaking.Name = "Shaking operator (placeholder)";
shaking.OperatorParameter.ActualName = ShakingOperatorParameter.Name;
localImprovement.Name = "Local improvement operator (placeholder)";
localImprovement.OperatorParameter.ActualName = LocalImprovementParameter.Name;
evaluator.Name = "Evaluation operator (placeholder)";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
evalCounter.Name = "Count evaluations";
evalCounter.Increment.Value = 1;
evalCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.ActualName;
qualityComparator.LeftSideParameter.ActualName = QualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = "OriginalQuality";
qualityComparator.ResultParameter.ActualName = "IsBetter";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.LeftSideParameter.ActualName = "BestQuality";
bestQualityUpdater.RightSideParameter.ActualName = QualityParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
indexCounter.Name = "Count neighborhood index";
indexCounter.Increment.Value = 1;
indexCounter.ValueParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexResetter.Name = "Reset neighborhood index";
indexResetter.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexResetter.RightSideParameter.Value = new IntValue(0);
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
indexComparator.Name = "k < k_max (index condition)";
indexComparator.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexComparator.RightSideParameter.ActualName = NeighborhoodCountParameter.Name;
indexComparator.Comparison = new Comparison(ComparisonType.Less);
indexComparator.ResultParameter.ActualName = "ContinueIteration";
indexTermination.Name = "Index Termination Condition";
indexTermination.ConditionParameter.ActualName = "ContinueIteration";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = subScopesProcessor0;
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
/////////
resultsCollector1.Successor = iteration;
iteration.OperatorGraph.InitialOperator = iterationInit;
iteration.Successor = iterationsCounter;
iterationInit.Successor = createChild;
createChild.Successor = childProcessor;
childProcessor.Operators.Add(new EmptyOperator());
childProcessor.Operators.Add(qualityAssigner);
childProcessor.Successor = bestSelector;
/////////
qualityAssigner.Successor = shaking;
shaking.Successor = evaluator;
evaluator.Successor = evalCounter;
evalCounter.Successor = localImprovement;
localImprovement.Successor = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = bestQualityUpdater;
improvesQualityBranch.FalseBranch = indexCounter;
bestQualityUpdater.Successor = indexResetter;
indexResetter.Successor = null;
indexCounter.Successor = null;
/////////
bestSelector.Successor = rightReducer;
rightReducer.Successor = analyzer2;
analyzer2.Successor = indexComparator;
indexComparator.Successor = indexTermination;
indexTermination.TrueBranch = createChild;
indexTermination.FalseBranch = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = iteration;
#endregion
}
public IslandOffspringSelectionGeneticAlgorithmMainLoop()
: base()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter <IntValue>("NumberOfIslands", "The number of islands."));
Parameters.Add(new ValueLookupParameter <IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
Parameters.Add(new ValueLookupParameter <PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
Parameters.Add(new ValueLookupParameter <IOperator>("Migrator", "The migration strategy."));
Parameters.Add(new ValueLookupParameter <IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
Parameters.Add(new ValueLookupParameter <IOperator>("ImmigrationReplacer", "Replaces part of the original population with the immigrants."));
Parameters.Add(new ValueLookupParameter <IntValue>("PopulationSize", "The size of the population of solutions."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumGenerations", "The maximum number of generations that should be processed."));
Parameters.Add(new ValueLookupParameter <IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter <IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter <PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter <IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter <IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter <IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter <BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter <ResultCollection>("Results", "The results collection to store the results."));
Parameters.Add(new ValueLookupParameter <IOperator>("Visualizer", "The operator used to visualize solutions."));
Parameters.Add(new LookupParameter <IItem>("Visualization", "The item which represents the visualization of solutions."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter <DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("ComparisonFactorStart", "The initial value for the comparison factor."));
Parameters.Add(new ValueLookupParameter <IOperator>("ComparisonFactorModifier", "The operator used to modify the comparison factor."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter <BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to the analyze the islands."));
Parameters.Add(new ValueLookupParameter <IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
Parameters.Add(new LookupParameter <IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter <BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
VariableCreator islandVariableCreator = new VariableCreator();
Placeholder islandAnalyzer1 = new Placeholder();
ResultsCollector islandResultsCollector1 = new ResultsCollector();
Assigner comparisonFactorInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
ConditionalBranch islandTerminatedBySelectionPressure1 = new ConditionalBranch();
OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
Placeholder islandAnalyzer2 = new Placeholder();
ResultsCollector islandResultsCollector2 = new ResultsCollector();
Comparator islandSelectionPressureComparator = new Comparator();
ConditionalBranch islandTerminatedBySelectionPressure2 = new ConditionalBranch();
IntCounter terminatedIslandsCounter = new IntCounter();
IntCounter generationsCounter = new IntCounter();
IntCounter generationsSinceLastMigrationCounter = new IntCounter();
Comparator migrationComparator = new Comparator();
ConditionalBranch migrationBranch = new ConditionalBranch();
Assigner resetTerminatedIslandsAssigner = new Assigner();
Assigner resetGenerationsSinceLastMigrationAssigner = new Assigner();
IntCounter migrationsCounter = new IntCounter();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Assigner reviveIslandAssigner = new Assigner();
Placeholder emigrantsSelector = new Placeholder();
Placeholder migrator = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
Placeholder immigrationReplacer = new Placeholder();
Comparator generationsComparator = new Comparator();
Comparator terminatedIslandsComparator = new Comparator();
Comparator maxEvaluatedSolutionsComparator = new Comparator();
Placeholder comparisonFactorModifier = new Placeholder();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch generationsTerminationCondition = new ConditionalBranch();
ConditionalBranch terminatedIslandsCondition = new ConditionalBranch();
ConditionalBranch evaluatedSolutionsTerminationCondition = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Migrations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Generations", new IntValue(0))); // Class IslandOffspringSelectionGeneticAlgorithm expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("GenerationsSinceLastMigration", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("TerminatedIslands", new IntValue(0)));
islandVariableCreator.CollectedValues.Add(new ValueParameter <ResultCollection>(ResultsParameter.Name, new ResultCollection()));
islandVariableCreator.CollectedValues.Add(new ValueParameter <BoolValue>("TerminateSelectionPressure", new BoolValue(false)));
islandVariableCreator.CollectedValues.Add(new ValueParameter <DoubleValue>("SelectionPressure", new DoubleValue(0)));
islandAnalyzer1.Name = "Island Analyzer (placeholder)";
islandAnalyzer1.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
islandResultsCollector1.CollectedValues.Add(new LookupParameter <DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
islandResultsCollector1.CollectedValues.Add(new LookupParameter <DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
islandResultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
comparisonFactorInitializer.Name = "Initialize Comparison Factor";
comparisonFactorInitializer.LeftSideParameter.ActualName = ComparisonFactorParameter.Name;
comparisonFactorInitializer.RightSideParameter.ActualName = ComparisonFactorStartParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>("Migrations"));
resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter <DoubleValue>("Current Comparison Factor", null, ComparisonFactorParameter.Name));
resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter <ResultCollection>("IslandResults", "Result set for each island", ResultsParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
islandTerminatedBySelectionPressure1.Name = "Island Terminated ?";
islandTerminatedBySelectionPressure1.ConditionParameter.ActualName = "TerminateSelectionPressure";
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.RandomParameter.ActualName = RandomParameter.Name;
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
islandAnalyzer2.Name = "Island Analyzer (placeholder)";
islandAnalyzer2.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
islandResultsCollector2.CollectedValues.Add(new LookupParameter <DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
islandResultsCollector2.CollectedValues.Add(new LookupParameter <DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
islandResultsCollector2.ResultsParameter.ActualName = "Results";
islandSelectionPressureComparator.Name = "SelectionPressure >= MaximumSelectionPressure ?";
islandSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
islandSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
islandSelectionPressureComparator.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
islandSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
islandTerminatedBySelectionPressure2.Name = "Island Terminated ?";
islandTerminatedBySelectionPressure2.ConditionParameter.ActualName = "TerminateSelectionPressure";
terminatedIslandsCounter.Name = "TerminatedIslands + 1";
terminatedIslandsCounter.ValueParameter.ActualName = "TerminatedIslands";
terminatedIslandsCounter.Increment = new IntValue(1);
generationsCounter.Name = "Generations + 1";
generationsCounter.ValueParameter.ActualName = "Generations";
generationsCounter.Increment = new IntValue(1);
generationsSinceLastMigrationCounter.Name = "GenerationsSinceLastMigration + 1";
generationsSinceLastMigrationCounter.ValueParameter.ActualName = "GenerationsSinceLastMigration";
generationsSinceLastMigrationCounter.Increment = new IntValue(1);
migrationComparator.Name = "GenerationsSinceLastMigration = MigrationInterval ?";
migrationComparator.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
migrationComparator.Comparison = new Comparison(ComparisonType.Equal);
migrationComparator.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
migrationComparator.ResultParameter.ActualName = "Migrate";
migrationBranch.Name = "Migrate?";
migrationBranch.ConditionParameter.ActualName = "Migrate";
resetTerminatedIslandsAssigner.Name = "Reset TerminatedIslands";
resetTerminatedIslandsAssigner.LeftSideParameter.ActualName = "TerminatedIslands";
resetTerminatedIslandsAssigner.RightSideParameter.Value = new IntValue(0);
resetGenerationsSinceLastMigrationAssigner.Name = "Reset GenerationsSinceLastMigration";
resetGenerationsSinceLastMigrationAssigner.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
resetGenerationsSinceLastMigrationAssigner.RightSideParameter.Value = new IntValue(0);
migrationsCounter.Name = "Migrations + 1";
migrationsCounter.IncrementParameter.Value = new IntValue(1);
migrationsCounter.ValueParameter.ActualName = "Migrations";
reviveIslandAssigner.Name = "Revive Island";
reviveIslandAssigner.LeftSideParameter.ActualName = "TerminateSelectionPressure";
reviveIslandAssigner.RightSideParameter.Value = new BoolValue(false);
emigrantsSelector.Name = "Emigrants Selector (placeholder)";
emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
migrator.Name = "Migrator (placeholder)";
migrator.OperatorParameter.ActualName = MigratorParameter.Name;
immigrationReplacer.Name = "Immigration Replacer (placeholder)";
immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
generationsComparator.Name = "Generations >= MaximumGenerations ?";
generationsComparator.LeftSideParameter.ActualName = "Generations";
generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
generationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
generationsComparator.ResultParameter.ActualName = "TerminateGenerations";
terminatedIslandsComparator.Name = "All Islands terminated ?";
terminatedIslandsComparator.LeftSideParameter.ActualName = "TerminatedIslands";
terminatedIslandsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
terminatedIslandsComparator.RightSideParameter.ActualName = NumberOfIslandsParameter.Name;
terminatedIslandsComparator.ResultParameter.ActualName = "TerminateTerminatedIslands";
maxEvaluatedSolutionsComparator.Name = "EvaluatedSolutions >= MaximumEvaluatedSolutions ?";
maxEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxEvaluatedSolutionsComparator.LeftSideParameter.ActualName = EvaluatedSolutionsParameter.Name;
maxEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
comparisonFactorModifier.Name = "Update Comparison Factor (Placeholder)";
comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
generationsTerminationCondition.Name = "Terminate (MaxGenerations) ?";
generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
terminatedIslandsCondition.Name = "Terminate (TerminatedIslands) ?";
terminatedIslandsCondition.ConditionParameter.ActualName = "TerminateTerminatedIslands";
evaluatedSolutionsTerminationCondition.Name = "Terminate (EvaluatedSolutions) ?";
evaluatedSolutionsTerminationCondition.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = uniformSubScopesProcessor0;
uniformSubScopesProcessor0.Operator = islandVariableCreator;
uniformSubScopesProcessor0.Successor = comparisonFactorInitializer;
islandVariableCreator.Successor = islandAnalyzer1;
islandAnalyzer1.Successor = islandResultsCollector1;
islandResultsCollector1.Successor = null;
comparisonFactorInitializer.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = islandTerminatedBySelectionPressure1;
uniformSubScopesProcessor1.Successor = generationsCounter;
islandTerminatedBySelectionPressure1.TrueBranch = null;
islandTerminatedBySelectionPressure1.FalseBranch = mainOperator;
islandTerminatedBySelectionPressure1.Successor = null;
mainOperator.Successor = islandAnalyzer2;
islandAnalyzer2.Successor = islandResultsCollector2;
islandResultsCollector2.Successor = islandSelectionPressureComparator;
islandSelectionPressureComparator.Successor = islandTerminatedBySelectionPressure2;
islandTerminatedBySelectionPressure2.TrueBranch = terminatedIslandsCounter;
islandTerminatedBySelectionPressure2.FalseBranch = null;
islandTerminatedBySelectionPressure2.Successor = null;
generationsCounter.Successor = generationsSinceLastMigrationCounter;
generationsSinceLastMigrationCounter.Successor = migrationComparator;
migrationComparator.Successor = migrationBranch;
migrationBranch.TrueBranch = resetTerminatedIslandsAssigner;
migrationBranch.FalseBranch = null;
migrationBranch.Successor = generationsComparator;
resetTerminatedIslandsAssigner.Successor = resetGenerationsSinceLastMigrationAssigner;
resetGenerationsSinceLastMigrationAssigner.Successor = migrationsCounter;
migrationsCounter.Successor = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = reviveIslandAssigner;
uniformSubScopesProcessor2.Successor = migrator;
reviveIslandAssigner.Successor = emigrantsSelector;
emigrantsSelector.Successor = null;
migrator.Successor = uniformSubScopesProcessor3;
uniformSubScopesProcessor3.Operator = immigrationReplacer;
uniformSubScopesProcessor3.Successor = null;
immigrationReplacer.Successor = null;
generationsComparator.Successor = terminatedIslandsComparator;
terminatedIslandsComparator.Successor = maxEvaluatedSolutionsComparator;
maxEvaluatedSolutionsComparator.Successor = comparisonFactorModifier;
comparisonFactorModifier.Successor = analyzer2;
analyzer2.Successor = generationsTerminationCondition;
generationsTerminationCondition.TrueBranch = null;
generationsTerminationCondition.FalseBranch = terminatedIslandsCondition;
generationsTerminationCondition.Successor = null;
terminatedIslandsCondition.TrueBranch = null;
terminatedIslandsCondition.FalseBranch = evaluatedSolutionsTerminationCondition;
terminatedIslandsCondition.Successor = null;
evaluatedSolutionsTerminationCondition.TrueBranch = null;
evaluatedSolutionsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
evaluatedSolutionsTerminationCondition.Successor = null;
#endregion
}
private void Initialize()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IMultiAnalyzer>("Analyzer", "The analyzer used to analyze each iteration."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter <ICrossover>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter <IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter <IEvaluator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter <BoolValue>("ExecutePathRelinking", "True if path relinking should be executed instead of crossover, otherwise false."));
Parameters.Add(new ValueLookupParameter <IImprovementOperator>("Improver", "The operator used to improve solutions."));
Parameters.Add(new ValueLookupParameter <IntValue>("Iterations", "The number of iterations performed."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
Parameters.Add(new ValueLookupParameter <IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions in the reference set."));
Parameters.Add(new ValueLookupParameter <IPathRelinker>("PathRelinker", "The operator used to execute path relinking."));
Parameters.Add(new ValueLookupParameter <IntValue>("PopulationSize", "The size of the population of solutions."));
Parameters.Add(new ValueLookupParameter <IntValue>("ReferenceSetSize", "The size of the reference set."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("Quality", "This parameter is used for name translation only."));
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter <ISolutionSimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
#endregion
#region Create operators
Placeholder analyzer = new Placeholder();
Assigner assigner1 = new Assigner();
Assigner assigner2 = new Assigner();
ChildrenCreator childrenCreator = new ChildrenCreator();
Placeholder crossover = new Placeholder();
Comparator iterationsChecker = new Comparator();
IntCounter iterationsCounter = new IntCounter();
MergingReducer mergingReducer = new MergingReducer();
ConditionalBranch executePathRelinkingBranch = new ConditionalBranch();
ConditionalBranch newSolutionsBranch = new ConditionalBranch();
OffspringProcessor offspringProcessor = new OffspringProcessor();
Placeholder pathRelinker = new Placeholder();
PopulationRebuildMethod populationRebuildMethod = new PopulationRebuildMethod();
ReferenceSetUpdateMethod referenceSetUpdateMethod = new ReferenceSetUpdateMethod();
ResultsCollector resultsCollector = new ResultsCollector();
RightSelector rightSelector = new RightSelector();
Placeholder solutionEvaluator1 = new Placeholder();
Placeholder solutionEvaluator2 = new Placeholder();
Placeholder solutionImprover1 = new Placeholder();
Placeholder solutionImprover2 = new Placeholder();
SolutionPoolUpdateMethod solutionPoolUpdateMethod = new SolutionPoolUpdateMethod();
SolutionsCreator solutionsCreator = new SolutionsCreator();
DataReducer dataReducer1 = new DataReducer();
DataReducer dataReducer2 = new DataReducer();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
SubScopesProcessor subScopesProcessor3 = new SubScopesProcessor();
SubScopesProcessor subScopesProcessor4 = new SubScopesProcessor();
ConditionalBranch terminateBranch = new ConditionalBranch();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
VariableCreator variableCreator = new VariableCreator();
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>(IterationsParameter.Name, new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter <BoolValue>("NewSolutions", new BoolValue(false)));
variableCreator.Successor = resultsCollector;
resultsCollector.CopyValue = new BoolValue(false);
resultsCollector.CollectedValues.Add(new LookupParameter <IntValue>(IterationsParameter.Name));
resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
resultsCollector.Successor = iterationsChecker;
iterationsChecker.Name = "IterationsChecker";
iterationsChecker.Comparison.Value = ComparisonType.GreaterOrEqual;
iterationsChecker.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsChecker.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsChecker.ResultParameter.ActualName = "Terminate";
iterationsChecker.Successor = terminateBranch;
terminateBranch.Name = "TerminateChecker";
terminateBranch.ConditionParameter.ActualName = "Terminate";
terminateBranch.FalseBranch = referenceSetUpdateMethod;
referenceSetUpdateMethod.Successor = assigner1;
assigner1.Name = "NewSolutions = true";
assigner1.LeftSideParameter.ActualName = "NewSolutions";
assigner1.RightSideParameter.Value = new BoolValue(true);
assigner1.Successor = subScopesProcessor1;
subScopesProcessor1.DepthParameter.Value = new IntValue(1);
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = newSolutionsBranch;
childrenCreator.Name = "SubsetGenerator";
childrenCreator.ParentsPerChildParameter.Value = new IntValue(2);
childrenCreator.Successor = assigner2;
assigner2.Name = "NewSolutions = false";
assigner2.LeftSideParameter.ActualName = "NewSolutions";
assigner2.RightSideParameter.Value = new BoolValue(false);
assigner2.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.DepthParameter.Value = new IntValue(1);
uniformSubScopesProcessor1.Operator = executePathRelinkingBranch;
uniformSubScopesProcessor1.Successor = solutionPoolUpdateMethod;
executePathRelinkingBranch.Name = "ExecutePathRelinkingChecker";
executePathRelinkingBranch.ConditionParameter.ActualName = ExecutePathRelinkingParameter.ActualName;
executePathRelinkingBranch.TrueBranch = pathRelinker;
executePathRelinkingBranch.FalseBranch = crossover;
pathRelinker.Name = "PathRelinker";
pathRelinker.OperatorParameter.ActualName = PathRelinkerParameter.Name;
pathRelinker.Successor = rightSelector;
crossover.Name = "Crossover";
crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
crossover.Successor = offspringProcessor;
offspringProcessor.Successor = rightSelector;
rightSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
rightSelector.CopySelected = new BoolValue(false);
rightSelector.Successor = subScopesProcessor2;
subScopesProcessor2.DepthParameter.Value = new IntValue(1);
subScopesProcessor2.Operators.Add(new EmptyOperator());
subScopesProcessor2.Operators.Add(uniformSubScopesProcessor2);
subScopesProcessor2.Successor = mergingReducer;
uniformSubScopesProcessor2.DepthParameter.Value = new IntValue(2);
uniformSubScopesProcessor2.Operator = solutionImprover1;
uniformSubScopesProcessor2.ParallelParameter.Value = new BoolValue(true);
uniformSubScopesProcessor2.Successor = subScopesProcessor4;
solutionImprover1.Name = "SolutionImprover";
solutionImprover1.OperatorParameter.ActualName = ImproverParameter.Name;
solutionImprover1.Successor = solutionEvaluator1;
solutionEvaluator1.Name = "SolutionEvaluator";
solutionEvaluator1.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesProcessor4.Operators.Add(dataReducer1);
dataReducer1.Name = "Increment EvaluatedSolutions";
dataReducer1.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
dataReducer1.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
dataReducer1.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
dataReducer1.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
solutionPoolUpdateMethod.QualityParameter.ActualName = QualityParameter.ActualName;
solutionPoolUpdateMethod.Successor = analyzer;
analyzer.Name = "Analyzer";
analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;
newSolutionsBranch.Name = "NewSolutionsChecker";
newSolutionsBranch.ConditionParameter.ActualName = "NewSolutions";
newSolutionsBranch.TrueBranch = subScopesProcessor1;
newSolutionsBranch.FalseBranch = populationRebuildMethod;
populationRebuildMethod.QualityParameter.ActualName = QualityParameter.ActualName;
populationRebuildMethod.Successor = subScopesProcessor3;
subScopesProcessor3.DepthParameter.Value = new IntValue(1);
subScopesProcessor3.Operators.Add(solutionsCreator);
subScopesProcessor3.Operators.Add(new EmptyOperator());
subScopesProcessor3.Successor = iterationsCounter;
solutionsCreator.Name = "DiversificationGenerationMethod";
solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
solutionsCreator.Successor = uniformSubScopesProcessor3;
uniformSubScopesProcessor3.DepthParameter.Value = new IntValue(1);
uniformSubScopesProcessor3.Operator = solutionImprover2;
uniformSubScopesProcessor3.ParallelParameter.Value = new BoolValue(true);
uniformSubScopesProcessor3.Successor = dataReducer2;
solutionImprover2.Name = "SolutionImprover";
solutionImprover2.OperatorParameter.ActualName = ImproverParameter.Name;
solutionImprover2.Successor = solutionEvaluator2;
solutionEvaluator2.Name = "SolutionEvaluator";
solutionEvaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
dataReducer2.Name = "Increment EvaluatedSolutions";
dataReducer2.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
dataReducer2.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
dataReducer2.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
dataReducer2.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
iterationsCounter.Name = "IterationCounter";
iterationsCounter.IncrementParameter.Value = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsCounter.Successor = resultsCollector;
#endregion
}
private void Initialize()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new LookupParameter <DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
Parameters.Add(new LookupParameter <BoolValue>("MoveTabu", "The value that indicates if a move is tabu or not."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter <IntValue>("TabuTenure", "The length of the tabu list, and also means the number of iterations a move is kept tabu"));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveGenerator", "The operator that generates the moves."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveEvaluator", "The operator that evaluates a move."));
Parameters.Add(new ValueLookupParameter <IOperator>("TabuChecker", "The operator that checks whether a move is tabu."));
Parameters.Add(new ValueLookupParameter <IOperator>("TabuMaker", "The operator that declares a move tabu."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze the solution and moves."));
Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new LookupParameter <IntValue>("EvaluatedMoves", "The number of evaluated moves."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
SubScopesProcessor solutionProcessor = new SubScopesProcessor();
Placeholder moveGenerator = new Placeholder();
UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
Placeholder moveEvaluator = new Placeholder();
Placeholder tabuChecker = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
SubScopesSorter moveQualitySorter = new SubScopesSorter();
TabuSelector tabuSelector = new TabuSelector();
ConditionalBranch emptyNeighborhoodBranch1 = new ConditionalBranch();
SubScopesProcessor moveMakingProcessor = new SubScopesProcessor();
UniformSubScopesProcessor selectedMoveMakingProcesor = new UniformSubScopesProcessor();
Placeholder tabuMaker = new Placeholder();
Placeholder moveMaker = new Placeholder();
MergingReducer mergingReducer = new MergingReducer();
Placeholder analyzer2 = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
ConditionalBranch emptyNeighborhoodBranch2 = new ConditionalBranch();
BestQualityMemorizer bestQualityUpdater = new BestQualityMemorizer();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter <IntValue>("Iterations", new IntValue(0))); // Class TabuSearch expects this to be called Iterations
variableCreator.CollectedValues.Add(new ValueParameter <BoolValue>("EmptyNeighborhood", new BoolValue(false)));
variableCreator.CollectedValues.Add(new ValueParameter <ItemList <IItem> >("TabuList", new ItemList <IItem>()));
variableCreator.CollectedValues.Add(new ValueParameter <VariableCollection>("Memories", new VariableCollection()));
variableCreator.CollectedValues.Add(new ValueParameter <DoubleValue>("BestQuality", new DoubleValue(0)));
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = "BestQuality";
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>("Iterations"));
resultsCollector1.CollectedValues.Add(new LookupParameter <DoubleValue>("Best Quality", null, "BestQuality"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
moveGenerator.Name = "MoveGenerator (placeholder)";
moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
moveEvaluationProcessor.Parallel = new BoolValue(true);
moveEvaluator.Name = "MoveEvaluator (placeholder)";
moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
tabuChecker.Name = "TabuChecker (placeholder)";
tabuChecker.OperatorParameter.ActualName = TabuCheckerParameter.Name;
subScopesCounter.Name = "Increment EvaluatedMoves";
subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
moveQualitySorter.DescendingParameter.ActualName = MaximizationParameter.Name;
moveQualitySorter.ValueParameter.ActualName = MoveQualityParameter.Name;
tabuSelector.AspirationParameter.Value = new BoolValue(true);
tabuSelector.BestQualityParameter.ActualName = "BestQuality";
tabuSelector.CopySelected = new BoolValue(false);
tabuSelector.EmptyNeighborhoodParameter.ActualName = "EmptyNeighborhood";
tabuSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
tabuSelector.MoveQualityParameter.ActualName = MoveQualityParameter.Name;
tabuSelector.MoveTabuParameter.ActualName = MoveTabuParameter.Name;
moveMakingProcessor.Name = "MoveMaking processor (UniformSubScopesProcessor)";
emptyNeighborhoodBranch1.Name = "Neighborhood empty?";
emptyNeighborhoodBranch1.ConditionParameter.ActualName = "EmptyNeighborhood";
tabuMaker.Name = "TabuMaker (placeholder)";
tabuMaker.OperatorParameter.ActualName = TabuMakerParameter.Name;
moveMaker.Name = "MoveMaker (placeholder)";
moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestQualityUpdater.QualityParameter.ActualName = QualityParameter.Name;
bestQualityUpdater.BestQualityParameter.ActualName = "BestQuality";
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = "Iterations";
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = "Iterations";
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
emptyNeighborhoodBranch2.Name = "Neighborhood empty?";
emptyNeighborhoodBranch2.ConditionParameter.ActualName = "EmptyNeighborhood";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = subScopesProcessor0;
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = resultsCollector1;
bestQualityInitializer.Successor = analyzer1;
analyzer1.Successor = null;
resultsCollector1.Successor = solutionProcessor;
solutionProcessor.Operators.Add(moveGenerator);
solutionProcessor.Successor = iterationsCounter;
moveGenerator.Successor = moveEvaluationProcessor;
moveEvaluationProcessor.Operator = moveEvaluator;
moveEvaluationProcessor.Successor = subScopesCounter;
moveEvaluator.Successor = tabuChecker;
tabuChecker.Successor = null;
subScopesCounter.Successor = moveQualitySorter;
moveQualitySorter.Successor = tabuSelector;
tabuSelector.Successor = emptyNeighborhoodBranch1;
emptyNeighborhoodBranch1.FalseBranch = moveMakingProcessor;
emptyNeighborhoodBranch1.TrueBranch = null;
emptyNeighborhoodBranch1.Successor = subScopesRemover;
moveMakingProcessor.Operators.Add(new EmptyOperator());
moveMakingProcessor.Operators.Add(selectedMoveMakingProcesor);
moveMakingProcessor.Successor = mergingReducer;
selectedMoveMakingProcesor.Operator = tabuMaker;
selectedMoveMakingProcesor.Successor = null;
tabuMaker.Successor = moveMaker;
moveMaker.Successor = null;
mergingReducer.Successor = analyzer2;
analyzer2.Successor = null;
subScopesRemover.Successor = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = emptyNeighborhoodBranch2;
emptyNeighborhoodBranch2.TrueBranch = null;
emptyNeighborhoodBranch2.FalseBranch = iterationsTermination;
emptyNeighborhoodBranch2.Successor = null;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = solutionProcessor;
#endregion
}
/// <summary>
/// Serialize to a JSON object
/// </summary>
public new void SerializeJson(Utf8JsonWriter writer, JsonSerializerOptions options, bool includeStartObject = true)
{
if (includeStartObject)
{
writer.WriteStartObject();
}
((Fhir.R4.Models.Element) this).SerializeJson(writer, options, false);
if (!string.IsNullOrEmpty(Use))
{
writer.WriteString("use", (string)Use !);
}
if (_Use != null)
{
writer.WritePropertyName("_use");
_Use.SerializeJson(writer, options);
}
if (Type != null)
{
writer.WritePropertyName("type");
Type.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(System))
{
writer.WriteString("system", (string)System !);
}
if (_System != null)
{
writer.WritePropertyName("_system");
_System.SerializeJson(writer, options);
}
if (!string.IsNullOrEmpty(Value))
{
writer.WriteString("value", (string)Value !);
}
if (_Value != null)
{
writer.WritePropertyName("_value");
_Value.SerializeJson(writer, options);
}
if (Period != null)
{
writer.WritePropertyName("period");
Period.SerializeJson(writer, options);
}
if (Assigner != null)
{
writer.WritePropertyName("assigner");
Assigner.SerializeJson(writer, options);
}
if (includeStartObject)
{
writer.WriteEndObject();
}
}
static void Main(string[] args)
{
//-----------------------------------------------------------------------------------------------------------------------
// Retrieve all relevant data from config file
//-----------------------------------------------------------------------------------------------------------------------
ConfigFileReader configFileReader = new ConfigFileReader();
Assigner assigner = new Assigner();
MessageFilter.Register();
//-----------------------------------------------------------------------------------------------------------------------
// Attach to existing Dte
//-----------------------------------------------------------------------------------------------------------------------
AssignedConfigFileData.pathToSolution = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToSolution,
new string[] { "@NameOfProject@" },
new string[] { AssignedConfigFileData.nameOfProject }
);
Console.WriteLine("pathToSolution: {0}", AssignedConfigFileData.pathToSolution);
AssignedConfigFileData.pathToPOUsFolder = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToPOUsFolder,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToPOUsFolder: {0}", AssignedConfigFileData.pathToPOUsFolder);
AssignedConfigFileData.pathToDUTsFolder = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToDUTsFolder,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToDUTsFolder: {0}", AssignedConfigFileData.pathToDUTsFolder);
AssignedConfigFileData.pathToGVLsFolder = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToGVLsFolder,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToGVLsFolder: {0}", AssignedConfigFileData.pathToGVLsFolder);
AssignedConfigFileData.pathToMAIN = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToMAIN,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToMAIN: {0}", AssignedConfigFileData.pathToMAIN);
List <Project> projectList = new List <Project>();
Project plcProj = null;
bool projectFound = false;
ITcPlcDeclaration decl = (ITcPlcDeclaration)null;
ITcPlcImplementation impl = (ITcPlcImplementation)null;
ITcSmTreeItem currentMethod = null;
ITcSmTreeItem pou = null;
ITcSmTreeItem dut = null;
ITcSmTreeItem gvl = null;
ITcSmTreeItem main = null;
ITcSmTreeItem modules = null;
ITcSmTreeItem constants = null;
ITcSmTreeItem system = null;
ITcSmTreeItem targetModule = null;
ITcSmTreeItem triggers = null;
ITcSmTreeItem eventManagers = null;
ITcSmTreeItem interfaces = null;
ITcSmTreeItem i_sequence = null;
ITcSysManager sysManager = null;
EnvDTE.DTE dte =
DteAttacher.attachToExistingDte(
AssignedConfigFileData.pathToSolution,
AssignedConfigFileData.visualStudioVersion,
AssignedConfigFileData.nameOfProject
);
dynamic solution = dte.Solution;
Console.WriteLine("Full solution name:");
Console.WriteLine(solution.FullName);
Projects prjs = solution.projects;
Console.WriteLine("Projects in solution: {0}", prjs.Count);
for (int i = 1; i <= prjs.Count; i++)
{
projectList.Add(prjs.Item(i));
Console.WriteLine("Project found: {0}", prjs.Item(i).Name);
Console.WriteLine("Searching for project: {0}", AssignedConfigFileData.nameOfProject);
if (prjs.Item(i).Name.Equals(AssignedConfigFileData.nameOfProject))
{
plcProj = prjs.Item(i);
projectFound = true;
}
}
//-----------------------------------------------------------------------------------------------------------------------
// Perform checks
//-----------------------------------------------------------------------------------------------------------------------
Console.WriteLine("Performing checks:");
if (projectFound)
{
Console.WriteLine("Project found.");
sysManager = plcProj.Object;
}
else
{
Console.WriteLine("Project not found. Exiting on Enter.");
Console.Read();
return;
}
//Is POUs item available?
Functions.SearchForItem(AssignedConfigFileData.pathToPOUsFolder, ref sysManager, ref pou);
//Is DUTs item available?
Functions.SearchForItem(AssignedConfigFileData.pathToDUTsFolder, ref sysManager, ref dut);
//Is GVLs item available?
Functions.SearchForItem(AssignedConfigFileData.pathToGVLsFolder, ref sysManager, ref gvl);
//Is Main item available?
Functions.SearchForItem(AssignedConfigFileData.pathToMAIN, ref sysManager, ref main);
if (AssignedConfigFileData.activity.Equals("SpecificEventsModuleCreator"))
{
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- MAIN implementation -----------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
impl = (ITcPlcImplementation)main;
impl.ImplementationText = AssignedConfigFileData.blueprintMainImplementation;
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create methods for MAIN -------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
currentMethod = main.CreateChild("systemTime", 609, "");
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintMainSystemTimeDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintMainSystemTimeImplementation;
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the ModulesGVL --------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
modules = gvl.CreateChild("Modules", 615, "", AssignedConfigFileData.blueprintModulesGvlDeclaration);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the ConstantsGVL ------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
constants = gvl.CreateChild("Constants", 615, "", AssignedConfigFileData.blueprintConstantsGvlDeclaration);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the SystemGVL ----------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
system = gvl.CreateChild("System", 615, "", AssignedConfigFileData.blueprintSystemGvlDeclaration);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the EventManagers folder -----------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
eventManagers = pou.CreateChild("EventManagers", 601, "", "1");
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the Interfaces folder --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
interfaces = pou.CreateChild("Interfaces", 601, "", "1");
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the I_Sequence interface -----------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
i_sequence = interfaces.CreateChild("I_Sequence", 618);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the sequence interface method ------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
currentMethod = i_sequence.CreateChild("sequence", 610);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintInterfaceSequenceMethodDeclaration;
}
else
{
//Is the Module GVL present?
Functions.SearchForSubItem("Modules", ref gvl, ref modules);
//Is the Triggers GVL present?
//Functions.SearchForSubItem("Triggers", ref gvl, ref triggers);
//Is the Eventmanagers folder present?
Functions.SearchForSubItem("EventManagers", ref pou, ref eventManagers);
}
//Is TargetModule present?
/*
* if (AssignedConfigFileData.activity.Equals("InjectNewEventManagerInTarget"))
* {
* Functions.SearchForItem(AssignedConfigFileData.pathToTargetModule, ref sysManager, ref targetModule);
* }
*/
//Is the Interfaces folder present?
//Functions.SearchForSubItem("Interfaces", ref pou, ref interfaces);
//-----------------------------------------------------------------------------------------------------------------------
// Start activity
//-----------------------------------------------------------------------------------------------------------------------
Console.WriteLine("Executing program.");
for (int i = 0; i < AssignedConfigFileData.modulesContainer.content.Length; i++)
{
if (AssignedConfigFileData.activity.Equals("GeneralEventsModuleCreator"))
{
new GeneralEventsModuleCreator(i, pou, dut, gvl, eventManagers, modules, triggers);
}
else if (AssignedConfigFileData.activity.Equals("SpecificEventsModuleCreator"))
{
new SpecificEventsModuleCreator(i, pou, dut, gvl, eventManagers, modules, triggers);
}
}
MessageFilter.Revoke();
Console.WriteLine("Finished!");
Console.Read();
}
private void Initialize()
{
#region Create parameters
Parameters.Add(new ValueLookupParameter <IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter <BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter <DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new LookupParameter <DoubleValue>("BestLocalQuality", "The value which represents the best quality found so far."));
Parameters.Add(new ValueLookupParameter <DoubleValue>("BestKnownQuality", "The problem's best known quality value found so far."));
Parameters.Add(new LookupParameter <DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
Parameters.Add(new LookupParameter <IntValue>("Iterations", "The number of iterations performed."));
Parameters.Add(new ValueLookupParameter <IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter <VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveGenerator", "The operator that generates the moves."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
Parameters.Add(new ValueLookupParameter <IOperator>("MoveEvaluator", "The operator that evaluates a move."));
Parameters.Add(new ValueLookupParameter <IOperator>("Analyzer", "The operator used to analyze the solution and moves."));
Parameters.Add(new LookupParameter <IntValue>("EvaluatedMoves", "The number of evaluated moves."));
#endregion
#region Create operators
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
SubScopesProcessor mainProcessor = new SubScopesProcessor();
Placeholder moveGenerator = new Placeholder();
UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
Placeholder moveEvaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
BestSelector bestSelector = new BestSelector();
SubScopesProcessor moveMakingProcessor = new SubScopesProcessor();
UniformSubScopesProcessor selectedMoveMakingProcessor = new UniformSubScopesProcessor();
QualityComparator qualityComparator = new QualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Placeholder moveMaker = new Placeholder();
Assigner bestQualityUpdater = new Assigner();
ResultsCollector resultsCollector2 = new ResultsCollector();
MergingReducer mergingReducer = new MergingReducer();
Placeholder analyzer2 = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter <IntValue>(IterationsParameter.Name));
resultsCollector1.CollectedValues.Add(new LookupParameter <DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
moveGenerator.Name = "MoveGenerator (placeholder)";
moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
moveEvaluationProcessor.Parallel = new BoolValue(true);
moveEvaluator.Name = "MoveEvaluator (placeholder)";
moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedMoves";
subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
bestSelector.QualityParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
qualityComparator.ResultParameter.ActualName = "IsBetter";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
moveMaker.Name = "MoveMaker (placeholder)";
moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
bestQualityUpdater.RightSideParameter.ActualName = QualityParameter.Name;
resultsCollector2.CopyValue = new BoolValue(false);
resultsCollector2.CollectedValues.Add(new LookupParameter <DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
resultsCollector2.ResultsParameter.ActualName = ResultsParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = subScopesProcessor0; // don't change this without adapting the constructor of LocalSearchImprovementOperator
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = resultsCollector1;
bestQualityInitializer.Successor = analyzer1;
analyzer1.Successor = null;
resultsCollector1.Successor = mainProcessor;
mainProcessor.Operators.Add(moveGenerator);
mainProcessor.Successor = iterationsCounter;
moveGenerator.Successor = moveEvaluationProcessor;
moveEvaluationProcessor.Operator = moveEvaluator;
moveEvaluationProcessor.Successor = subScopesCounter;
moveEvaluator.Successor = null;
subScopesCounter.Successor = bestSelector;
bestSelector.Successor = moveMakingProcessor;
moveMakingProcessor.Operators.Add(new EmptyOperator());
moveMakingProcessor.Operators.Add(selectedMoveMakingProcessor);
moveMakingProcessor.Successor = mergingReducer;
selectedMoveMakingProcessor.Operator = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = moveMaker;
improvesQualityBranch.FalseBranch = null;
improvesQualityBranch.Successor = null;
moveMaker.Successor = bestQualityUpdater;
bestQualityUpdater.Successor = null;
mergingReducer.Successor = analyzer2;
analyzer2.Successor = subScopesRemover;
subScopesRemover.Successor = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = mainProcessor;
#endregion
}
