public totalObjFunction(GearEvaluator gt, candidate c, double[,] stateVars)
{
this.gt = gt;
this.c = c;
this.stateVars = stateVars;
findDerivBy = differentiate.Central2;
}
public void displayBiggest(candidate[] candidates)
{
double best = double.NegativeInfinity;
foreach (candidate c in candidates)
if (c.f0 > best)
best = c.f0;
SearchIO.miscObject = best;
}
private static void addChildToSortedCandList(List<candidate> candidates, candidate child, int fIndex)
{
if (candidates.Count == 0) candidates.Add(child);
else
{
int i = 0;
double fChild = child.performanceParams[fIndex];
while ((i < candidates.Count) && (fChild >= candidates[i].performanceParams[fIndex])) i++;
candidates.Insert(i, child);
}
}
public outputLocationConstraint(double[,] stateVars, candidate c, GearEvaluator gt)
{
this.gt = gt;
this.c = c;
this.stateVars = stateVars;
this.findDerivBy = differentiate.Central2;
this.xtarget = gt.udg.outputLocation[0,3];
this.ytarget = gt.udg.outputLocation[1,3];
this.ztarget = gt.udg.outputLocation[2,3];
this.theta1t = gt.udg.outputLocation[0, 2];
this.theta2t = gt.udg.outputLocation[1, 2];
this.theta3t = gt.udg.outputLocation[2, 2];
}
private double calcSwirlSize(candidate c)
{
double minX = double.PositiveInfinity;
double minY = double.PositiveInfinity;
double maxX = double.NegativeInfinity;
double maxY = double.NegativeInfinity;
foreach (vertex v in c.graph.nodes)
{
if (v.x < minX) minX = v.x;
if (v.x > maxX) maxX = v.x;
if (v.y < minY) minY = v.y;
if (v.y > maxY) maxY = v.y;
}
return ((maxX - minX) * (maxY - minY));
}
/* One can use the functions provided in RecognizeChooseApply.cs under "Invoking the
* RecognizeChooseApplyCycle" since these will be inherited into every generation method,
* but there is no reason one could not write other functions directly into their specific
* choose class. */
public void makeOneRandomAddition(candidate cand)
{
/* the RecognizeChooseApplyCycle requires an array of ruleSet limits,
* since we only intend to make one call on the activeRuleSet we make
* an array (it should initialize to all zeros) of the proper length
* and set its one value at the activeRuleSetIndex to 1. */
int[] numOfCalls = new int[numOfRuleSets];
numOfCalls[cand.activeRuleSetIndex] = 1;
/* here the main cycle is invoked. First, we must pass a copy of the candidate
* to the RCA cycle since the apply set will modify it, and then move the prevoius
* state onto the prevStates under the candidate. It is not incorrect to state
* merely the candidate here, but the prevStates will not be stored correctly.*/
RecognizeChooseApplyCycle(cand, cand.activeRuleSetIndex, numOfCalls);
}
public override int choose(List<option> options, candidate cand)
{
SearchIO.output("There are " + options.Count.ToString() + " recognized locations.", 2);
if (options.Count == 0)
{
SearchIO.output("Sorry there are no rules recognized.", 0);
return int.MinValue;
}
else if (options.Count > Program.settings.maxRulesToDisplay)
{
SearchIO.output("Sorry there are too many rules to show.", 0);
return int.MinValue;
}
else
{
SearchIO.output("Double-click on one to show the location.", 2);
chooseDisplay choiceDisplay = new chooseDisplay();
choiceDisplay.promptUser(options, (Boolean)(cand.recipe.Count == 0));
return choiceDisplay.choice;
}
}
public void evalGT(candidate c)
{
current = c;
reorderNodes(c);
Boolean found = false;
/* recall that gearcount is found in reorderNodes, Albert! */
stateVars = new double[gearcount + 1, 10];
#region Set up optMethod
//NelderMead optMethod =
// new NelderMead(.001, 10, true);
//GradientBasedUnconstrained optMethod =
// new GradientBasedUnconstrained(10);
GradientBasedOptimization optMethod = new GradientBasedOptimization(10);
//SequentialQuadraticProgramming optMethod = new SequentialQuadraticProgramming(true);
//GeneralizedReducedGradientActiveSet optMethod =
// new GeneralizedReducedGradientActiveSet(true);
optMethod.Add(new ArithmeticMean(optMethod, 0.001, 2, 200));
//optMethod.Add(new GoldenSection(optMethod, 0.001,200, int.MaxValue));
//optMethod.Add(new BFGSDirection());
optMethod.Add(new FletcherReevesDirection());
optMethod.Add(new convergenceBasic(BasicConvergenceTypes.OrBetweenSetConditions, 200, 0.0001, double.NaN, double.NaN, int.MaxValue));
//optMethod.Add(new convergenceBasic(BasicConvergenceTypes.AndBetweenSetConditions, 20, 0.01, double.NaN, double.NaN, int.MaxValue));
optMethod.Add(new squaredExteriorPenalty(optMethod, 10.0));
//optMethod.Add(new linearExteriorPenaltySum(optMethod, 10.0));
DiscreteSpaceDescriptor dsd = new DiscreteSpaceDescriptor(optMethod, 4 * gearcount);
optMethod.Add(dsd);
#endregion
for (int i = 0; i < gearcount; i++)
{
foreach (GearFamily gf in gearFamilies)
if (c.graph.nodes[i].localLabels.Contains(gf.label))
{
for (int j = 0; j < 3; j++)
{
if (c.graph.nodes[i].localVariables.Count < j + 1)
c.graph.nodes[i].localVariables.Add(double.NaN);
}
c.graph.nodes[i].localVariables[0] = gf.Sfb;
c.graph.nodes[i].localVariables[1] = gf.Sfc;
c.graph.nodes[i].localVariables[2] = gf.density;
dsd.addLinkedVariableValues(new int[] { 4 * i, 4 * i + 1, 4 * i + 2 }, gf.gears);
}
}
SearchIO.output("The parametric space is " + dsd.SizeOfSpace.ToString(), 3);
//setup constraints for optimization
//slot 1 - number of teeth
//slot 2 - pitch
//slot 3 - face Width
//slot 4 - location variable
#region Constraint Building Region
double[] x = new double[4 * gearcount];
double[] xStar = new double[4 * gearcount];
//double fStar = double.PositiveInfinity;
double fStar = 0.0;
double ftemp = 1000;
double weightstar = 100;
double lowestmass = 100;
double massstar = 100;
double mass = 100;
double[,] stateVarsStar = new double[gearcount + 1, 10];
outputSpeedConstraint oSC =
new outputSpeedConstraint(stateVars, this);
optMethod.Add(oSC);
stressConstraint sc =
new stressConstraint(stateVars, c, this);
optMethod.Add(sc);
boundingboxConstraint bbc =
new boundingboxConstraint(stateVars, c, this);
optMethod.Add(bbc);
outputLocationConstraint olc =
new outputLocationConstraint(stateVars, c, this);
optMethod.Add(olc);
List<samePitch> samePitches = new List<samePitch>();
for (int i = 0; i < gearcount; i++)
{
if ((c.graph.nodes[i].localLabels.Contains("contact")) || (c.graph.nodes[i].localLabels.Contains("bevelcontact")) || (c.graph.nodes[i].localLabels.Contains("wormcontact")))
{
samePitches.Add(new samePitch(((i - 1) * 4) + 1, ((i * 4) + 1)));
}
}
f = new totalObjFunction(this, current, stateVars);
optMethod.Add(f);
#endregion
int numVars = dsd.linkedSpace.Count;
int[] VarIndices = new int[numVars];
for (int i = 0; i < numVars; i++)
VarIndices[i] = 0;
int[] VarMaxes = new int[numVars];
for (int i = 0; i < numVars; i++)
VarMaxes[i] = dsd.linkedSpace[i].GetLength(0);
int currentI = 0;
VarIndices[currentI]--; //this is an unavoidable hack to start at all zeroes.
do
{
VarIndices[currentI]++;
if (VarIndices[currentI] == VarMaxes[currentI])
{
VarIndices[currentI] = 0;
currentI++;
if ((currentI > numVars - 3) && (currentI < numVars))
SearchIO.output("Index " + currentI.ToString() + " changed to " + VarIndices[currentI].ToString(), 4);
}
else
{
currentI = 0;
x = dsd.GetDesignVector(null, VarIndices);
//fStar = f.calculate(x);
Boolean Feasible = true;
foreach (samePitch sp in samePitches)
if (!sp.feasible(x)) Feasible = false;
if (Feasible && oSC.feasible(x))
{
if (sc.feasible(x))
{
//run optMethod here
double[] xTuned;
mass = 0;
double fTuned = optMethod.run(x, out xTuned);
for (int k = 0; k < gearcount; k++)
{
mass += stateVars[k, 2];
}
found = false;
if (fTuned< ftemp)
{
ftemp = fTuned;
}
found = isCurrentTheGoal(stateVars, udg);
if (found == true)
{
if (mass < massstar)
{
fStar = fTuned;
xStar = (double[])xTuned.Clone();
massstar = mass;
stateVarsStar = (double[,])stateVars.Clone();
}
}
}
}
}
} while (currentI < numVars);
SearchIO.output("final report f = " + c.f0, 3);
if (gearcount > 2)
{
if (massstar == 100)
fStar = ftemp+50;
}
c.f0 = fStar;
c.f2 = massstar;
c.f1 = calcInefficiency(stateVarsStar);
string outputString = "";
string outputString2 = "";
double p = 0;
for (int i = 0; i < gearcount; i++)
//var order
//x, y, z, vx, vy, vz, face width, diameter, number of teeth, type ID number
{//output for gear visualizer!
outputString += "gear," + (i + 1) + "," + stateVarsStar[i, 3] + "," + stateVarsStar[i, 4] +
"," + stateVarsStar[i, 5] + "," + stateVarsStar[i, 6] + "," + stateVarsStar[i, 7] + "," +
stateVarsStar[i, 8] + "," + xStar[i * 4 + 2] + "," + (xStar[i * 4] / xStar[i * 4 + 1]) +
"," + xStar[i * 4] + "," + stateVarsStar[i, 9] + "\n";
if (i != 0)
{
if ((stateVarsStar[i, 3] - stateVarsStar[(i - 1), 3] == 0) && (stateVarsStar[i, 4] - stateVarsStar[(i - 1), 4] == 0))
{
outputString2 += "rod," + (p) + "," + i + "," + (i - 1);//(stateVarsStar[i, 5] - stateVarsStar[(i - 1), 5]);
p += 1;
}
}
for (int j = 1; j < 9; j++)
{
if (c.graph.nodes[i].localVariables.Count <= j)
c.graph.nodes[i].localVariables.Add(double.NaN);
}
c.graph.nodes[i].localVariables[3] = stateVarsStar[i, 3];
c.graph.nodes[i].localVariables[4] = stateVarsStar[i, 4];
c.graph.nodes[i].localVariables[5] = stateVarsStar[i, 5];
c.graph.nodes[i].localVariables[6] = stateVarsStar[i, 6];
c.graph.nodes[i].localVariables[7] = stateVarsStar[i, 7];
c.graph.nodes[i].localVariables[8] = stateVarsStar[i, 8];
}
for (int j = 1; j < 9; j++)
{
if (c.graph.nodes[gearcount].localVariables.Count <= j)
c.graph.nodes[gearcount].localVariables.Add(double.NaN);
}
c.graph.nodes[gearcount].localVariables[3] = stateVarsStar[gearcount, 3];
c.graph.nodes[gearcount].localVariables[4] = stateVarsStar[gearcount, 4];
c.graph.nodes[gearcount].localVariables[5] = stateVarsStar[gearcount, 5];
c.graph.nodes[gearcount].localVariables[6] = stateVarsStar[gearcount, 6];
c.graph.nodes[gearcount].localVariables[7] = stateVarsStar[gearcount, 7];
c.graph.nodes[gearcount].localVariables[8] = stateVarsStar[gearcount, 8];
string filename = Program.settings.outputDirectory + "visualizerOutput1.txt";
FileStream fs = new FileStream(filename, FileMode.Create);
StreamWriter outputWriter = new StreamWriter(fs);
outputWriter.WriteLine(outputString);
outputWriter.WriteLine(outputString2);
outputWriter.Close();
fs.Close();
}
private void reorderNodes(candidate c)
{
node inputShaft = null;
node temp;
/* find first gear (connected to input shaft) */
foreach (node n in c.graph.nodes)
if (n.localLabels.Contains("seed") && n.localLabels.Contains("shaft"))
{
inputShaft = n;
break;
}
foreach (arc a in inputShaft.arcs)
if (a.otherNode(inputShaft).localLabels.Contains("gear"))
{
temp = a.otherNode(inputShaft);
c.graph.nodes.Remove(temp);
c.graph.nodes.Insert(0, temp);
break;
}
gearcount = 1;
Boolean foundNextGear;
do
{
foundNextGear = false;
node gear = c.graph.nodes[gearcount - 1];
foreach (arc a in gear.arcsFrom)
if ((a.otherNode(gear).localLabels.Contains("gear")) || (a.otherNode(gear).localLabels.Contains("gear1")))
{
temp = a.otherNode(gear);
c.graph.nodes.Remove(temp);
c.graph.nodes.Insert(gearcount++, temp);
foundNextGear = true;
break;
}
if (!foundNextGear)
{
// this means that either that was the last gear or we need to traverse thru an idler shaft
foreach (arc a in gear.arcsFrom)
if (a.otherNode(gear).localLabels.Contains("shaft"))
{
node shaft = a.otherNode(gear);
foreach (arc aa in shaft.arcsFrom)
if ((aa.otherNode(shaft).localLabels.Contains("gear")) || (aa.otherNode(shaft).localLabels.Contains("gear1")))
{
temp = aa.otherNode(shaft);
c.graph.nodes.Remove(temp);
c.graph.nodes.Insert(gearcount++, temp);
foundNextGear = true;
break;
}
}
}
} while (foundNextGear);
}
public override double[] choose(option RC, candidate cand)
{ return null; }
public static void saveToXml(candidate[] candidates, string filename, string outputDir)
{
filename = Path.GetFileName(filename).TrimEnd(new char[] { '.', 'x', 'm', 'l' });
for (int i = 0; i != candidates.GetLength(0); i++)
{
string counter = i.ToString();
counter = counter.PadLeft(3, '0');
saveToXml(candidates[i], outputDir + filename + counter + ".xml");
}
}
public candidate[] GenerateArrayOfCandidates(int numToCandidates)
{
candidate[] candidates = new candidate[numToCandidates];
int[] numOfCalls = new int[numOfRuleSets];
for (int i = 0; i != numToCandidates; i++)
{
maxNumOfCalls.CopyTo(numOfCalls, 0);
candidate newCand = seed.copy();
RecognizeChooseApplyCycle(newCand, seed.activeRuleSetIndex, numOfCalls);
candidates[i] = newCand;
}
return candidates;
}
public static void runSearchProcess()
{
/* Here is where you code goes.
* You have access to the previous fields and properties.
* In general, I envision that you will declare three large objects
* at the beginning of this function (a generation approach, an evaluation
* approach, and a guidance approach) and initialize them with their
* important values. */
/*** here is an example ***/
output(null, null, "making new generation method", "initializing generation with data");
Generation.randomChoose GenerationApproach = new Generation.randomChoose(Program.seed,
Program.rulesets, 50, false, Program.settings.recompileRules, Program.settings.execDir,
Program.settings.compiledparamRules);
SearchIO.output("making new evaluation", 2);
Evaluation.EvaluateSwirls EvaluationApproach = new Evaluation.EvaluateSwirls();
output("making new guidance", 2);
Guidance.DoNothingButDisplay GuidanceApproach = new Guidance.DoNothingButDisplay();
/*start search */
iteration = 0;
int iterMax = 50;
int populationSize = 5;
candidate[] candidates = new candidate[populationSize];
do
{
iteration++;
output("", null, "generate", "entering generation",
"entering the generation:" + GenerationApproach.GetType().ToString());
candidates = GenerationApproach.GenerateArrayOfCandidates(populationSize);
SearchIO.output("leaving generation", 3);
output(null, null, "evaluate", "entering evaluation",
"entering the evaluation:" + EvaluationApproach.GetType().ToString());
EvaluationApproach.assignSwirlSizeToAllCandidates(candidates);
output("leaving evaluation", 3);
output("and now guidance", 2);
//object misc;
//GuidanceApproach.displayBiggest(candidates, out misc);
//miscObject = misc;
GuidanceApproach.displayBiggest(candidates);
/* Some sleep time (25 ms) for the thread will ensure that the display thread
* has time to update itself. This can also happen if the priority is set very
* low. Howver, this sleep statement does slow down the process. Comment out if
* there are many iteration (> 10^5). */
//Thread.Sleep(25);
/* Additonally, it may be useful to force a garbage collection at the end of each
* iteration. Although, since it is time consuming, check to see how memory is
* increasing in TaskManager. If it is unaffected by this, then comment out.
* It is typical for GraphSynth to require to 50 MB. Essentially, the sleep
statement should give the system time to garbage collect as well. */
//GC.Collect();
} while (!terminateRequest && iteration != iterMax); /* also check if population converged
* some additional boolean functions. */
addAndShowGraphDisplay(candidates[0].graph, "candidate 0");
addAndShowGraphDisplay(candidates[1].graph, "candidate 1");
addAndShowGraphDisplay(candidates[2].graph, "candidate 2");
addAndShowGraphDisplay(candidates[3].graph, "candidate 3");
addAndShowGraphDisplay(candidates[4].graph, "candidate 4");
candidate.saveToXml(candidates, "candidate", settings.outputDirectory);
}
private static bool isCurrentTheGoal(candidate current, userDefinedGoals udg)
{
double xP, y, z, theta1, theta2, theta3;
int gearcount = 0;
foreach (node n in current.graph.nodes)
{
if ((n.localLabels.Contains("gear")) || (n.localLabels.Contains("gear1")))
{
gearcount = gearcount + 1;
}
}
int i = gearcount;
xP = current.graph.nodes[gearcount].localVariables[3] - udg.outputLocation[0, 3];
y = current.graph.nodes[gearcount].localVariables[4] - udg.outputLocation[1, 3];
z = current.graph.nodes[gearcount].localVariables[5] - udg.outputLocation[2, 3];
theta1 = Math.Abs(current.graph.nodes[gearcount].localVariables[6]) - Math.Abs(udg.outputLocation[0, 2]);
theta2 = Math.Abs(current.graph.nodes[gearcount].localVariables[7]) - Math.Abs(udg.outputLocation[1, 2]);
theta3 = Math.Abs(current.graph.nodes[gearcount].localVariables[8]) - Math.Abs(udg.outputLocation[2, 2]);
double hVal = Math.Sqrt(xP * xP + y * y + z * z + theta1 * theta1 + theta2 * theta2 + theta3 * theta3);
if (hVal < .05)
{
return true;
}
else
{
return false;
}
}
public void assignSwirlSizeToAllCandidates(candidate[] candidates)
{
Random rnd = new Random();
foreach (candidate c in candidates)
c.f0 = calcSwirlSize(c);
}
/* A copy of a candidate is returned. Very similar to designGraph copy.
* We make sure to not do a shallow copy (ala Clone) since we are unsure
* how each candidate may be changed in the future. */
public candidate copy()
{
candidate copyOfCand = new candidate();
copyOfCand.currentState = this.currentState.copy();
foreach (designGraph d in prevStates)
copyOfCand.prevStates.Add(d.copy());
foreach (option rc in recipe)
{
option copiedRC = new option();
copiedRC.ruleSetIndex = rc.ruleSetIndex;
copiedRC.ruleNumber = rc.ruleNumber;
copiedRC.rule = rc.rule;
copiedRC.location = rc.location;
copyOfCand.recipe.Add(copiedRC);
}
foreach (double f in this.performanceParams)
copyOfCand.performanceParams.Add(f);
foreach (GenerationStatuses a in this.GenerationStatus)
copyOfCand.GenerationStatus.Add(a);
return copyOfCand;
}
public RecognizeChooseApply(designGraph _seed, ruleSet[] _rulesets, int[] _maxNumOfCalls, Boolean _display)
{
SearchIO.output("initializing generation:", 4);
this.numOfRuleSets = _rulesets.GetLength(0);
this.rulesets = new ruleSet[numOfRuleSets];
for (int i = 0; i != numOfRuleSets; i++)
rulesets[i] = _rulesets[i].copy();
SearchIO.output("There are " + numOfRuleSets + " rule sets.", 4);
this.seed = new candidate(_seed.copy(), numOfRuleSets);
SearchIO.output("Seed = " + seed.graph.name, 4);
maxNumOfCalls = _maxNumOfCalls;
this.display = _display;
SearchIO.output("It is " + display.ToString() + " that the SearchIO will be displayed.", 4);
}
public static void saveToXml(candidate c1, string filename)
{
StreamWriter candidateWriter = null;
try
{
candidateWriter = new StreamWriter(filename);
XmlSerializer candidateSerializer = new XmlSerializer(typeof(candidate));
candidateSerializer.Serialize(candidateWriter, c1);
}
catch (Exception ioe)
{
MessageBox.Show(ioe.ToString(), "XML Serialization Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
finally
{
if (candidateWriter != null) candidateWriter.Close();
}
}
/* Here we outline what an inherited class must contain. Basically it should have
* methods for the 2 types of decisions that are made - decisions on what option
* to invoke and decisions for the variables required for the process. */
/* Given the list of options and the candidate, determine what option to invoke.
* Return the integer index of this option from the list. */
public abstract int choose(List<option> options, candidate cand);
public override int choose(List<option> options, candidate cand)
{
return rnd.Next(-1, options.Count);
}
/* Given that the rule has now been chosen, determine the values needed by the * rule to properly apply it to the candidate, cand. The array of double is to * be determined by parametric apply rules written in complement C# files for * the ruleSet being used. */ public abstract double[] choose(option RC, candidate cand);
/* Here is the main Recognize, Choose, and Apply Generation Cycle. It accepts the host candidate
* (not graph), the index of what ruleSet to invoke, and an array of size equal to the number
* of ruleSets. At the end of the process, it returns the updated candidate. The three step
* process may, however exit at any of five places in the loop, these are described below.
* 1. the ruleSet invoked may not have any calls left. This will cause the GenerationStatus
* to be CycleLimit, and the process will execute what is stored in the 3rd position of
* generationSteps, ruleSet->nextGenerationStep[2], either Stop, Loop, GoToPrevious(ruleSet),
* GoToNext(ruleSet), or GoToRuleSet#
* 2. the choice operation has sent a STOP message, or more precisely a negative # or
* a number greater than the list of option. This results in a GenerationStatus of Choice
* and the execution of ruleSet->nextGenerationStep[1] (any of the options stated above).
* 3. there are no rules recognized for the graph. This results in a GenerationStatus of
* NoRules and the execution of ruleSet->nextGenerationStep[3] (any of the options above).
* 4. A trigger rule has been applied. This results in a GenerationStatus of TriggerRule
* and the execution of ruleSet->nextGenerationStep[4] (any of the options stated above).
* 5. the recognize, choose, and apply cycle performed as intended - no abnormal activites.
* This results in a GenerationStatus of Normal and the execution of
* ruleSet->nextGenerationStep[0] (any of the options stated above).*/
public void RecognizeChooseApplyCycle(candidate host, int ruleSetIndex, int[] numOfCallsLeft)
{
while ((ruleSetIndex >= 0) && (ruleSetIndex < numOfRuleSets))
{
host.activeRuleSetIndex = ruleSetIndex;
SearchIO.output("Active Rule Set = " + ruleSetIndex.ToString(), 4);
#region terminate immediately if there are no cycles left
if (numOfCallsLeft[ruleSetIndex] == 0)
{
/* it is possible that another ruleset intends to invoke this one, but your
* number of calls for this set has hit its limit. */
host.GenerationStatus[ruleSetIndex] = GenerationStatuses.CycleLimit;
ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.CycleLimit);
SearchIO.output("cycle limit reached", 4);
continue;
}
#endregion
#region ***** RECOGNIZE *****
SearchIO.output("begin RCA loop for RuleSet #" + ruleSetIndex.ToString(), 4);
List<option> options = rulesets[ruleSetIndex].recognize(host.graph);
SearchIO.output("There are " + options.Count.ToString() + " rule choices.", 4);
if (options.Count == 0)
{
/* There are no rules to recognize, exit here. */
host.GenerationStatus[ruleSetIndex] = GenerationStatuses.NoRules;
ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.NoRules);
continue;
}
if (SearchIO.terminateRequest) return;
#endregion
#region ***** CHOOSE *****
if (rulesets[ruleSetIndex].choiceMethod == choiceMethods.Automatic)
choice = 0;
else choice = choose(options, host);
SearchIO.output("Choice = #" + choice.ToString(), 4);
if (choice == -1)
{
host.undoLastRule();
if (display) SearchIO.addAndShowGraphDisplay(host.graph.copy(),
"Revert to after calling " + host.numRulesCalled + " rules");
continue;
}
if ((choice < 0) || (choice >= options.Count))
{
/* the overloaded choice function may want to communicate to the loop that it
* should finish the process. */
SearchIO.output("Choice received a STOP request", 4);
host.GenerationStatus[ruleSetIndex] = GenerationStatuses.Choice;
ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.Choice);
continue;
}
if (SearchIO.terminateRequest) return;
#endregion
#region ***** APPLY *****
host.saveCurrent();
options[choice].apply(host.graph, choose(options[choice], host));
host.addToRecipe(options[choice]);
SearchIO.output("Rule sucessfully applied", 4);
/* display state? */
if (display) SearchIO.addAndShowGraphDisplay(host.graph.copy(),
"After calling " + host.numRulesCalled + " rules");
if (SearchIO.terminateRequest) return;
#endregion
#region Check to see if loop is done
/* First thing we do is reduce the number of calls left. Note that if you start with
* a negative number, the process will continue to make it more negative - mimicking
* no cycle limit. It is safer to use the globalvar, maxRulesToApply though.*/
numOfCallsLeft[ruleSetIndex]--;
/* a significant change is made here in Version 1.1.2.0, it is actually the removal of
* code. We were checking the numOfCallsLeft here as well as the top, but it has been decided
* that it is ambiguous to check in both locations. Later, it may be determined that two
* independent cycle limits need to be imposed, but in the mean time, the following code will be
* commented out.
* if (numOfCallsLeft[ruleSetIndex] == 0)
* { /* there of no more calls on this ruleset allowed, the limit has been reached.
* SearchIO.output("The maximum num of calls has been reached", 4);
* host.GenerationStatus[ruleSetIndex] = GenerationStatuses.CycleLimit;
* ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.CycleLimit);
* }
* else */
if (options[choice].ruleNumber == rulesets[ruleSetIndex].triggerRuleNum)
{ /* your ruleset loops until a trigger rule and the trigger rule was just called. */
SearchIO.output("The trigger rule has been chosen.", 4);
host.GenerationStatus[ruleSetIndex] = GenerationStatuses.TriggerRule;
ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.TriggerRule);
}
else
{ /* Normal operation */
SearchIO.output("RCA loop executed normally.", 4);
host.GenerationStatus[ruleSetIndex] = GenerationStatuses.Normal;
ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.Normal);
}
#endregion
}
}
public static void runSearchProcess()
{
userDefinedGoals udg = new userDefinedGoals();
Form2 inputBox = new Form2(udg);
//inputBox.ShowDialog();
ruleSet.loadAndCompileSourceFiles(rulesets, Program.settings.recompileRules, Program.settings.compiledparamRules, Program.settings.execDir);
List<candidate> candidates = new List<candidate>();
candidate current = null;
candidate seedCandidate = new candidate(seed, Program.settings.numOfRuleSets);
Boolean found = false;
candidates.Add(seedCandidate);
GearEvaluator ge = new GearEvaluator(udg);
Guidance.PNormProportionalPopulationSelection GuidanceApproach
= new Guidance.PNormProportionalPopulationSelection(0, Guidance.optimize.minimize, true, true, 1);
int maxPop = 10000;
while (!found && (candidates.Count != 0))
{
current = candidates[0];
candidates.RemoveAt(0);
SearchIO.iteration = current.recipe.Count;
//RECOGNIZE
List<option> ruleChoices = rulesets[0].recognize(current.graph);
SearchIO.miscObject = candidates.Count;
//
if (current.recipe.Count >= 2)
{
found = isCurrentTheGoal(current, udg);
if (found == true)
{
ge.evalGT(current);
break;
}
}
//else current.f0 = double.PositiveInfinity;
for (int i = 0; i != ruleChoices.Count; i++)
{
candidate child = current.copy();
ruleChoices = rulesets[0].recognize(child.graph);
ruleChoices[i].apply(child.graph, null);
child.addToRecipe(ruleChoices[i]);
child.f0 = double.NaN;
child.f1 = double.NaN;
child.f2 = double.NaN;
ge.evalGT(child);
child.f3 = (child.f0)/100 + child.f1;
//1 efficiency
//2 mass
//3 combination
addChildToSortedCandList(candidates, child, 3);
//candidates.Add(child);
}
}
Program.addAndShowGraphDisplay(current.graph, "Here is your gear train!!!");
candidate.saveToXml(current, "testTuned", settings.outputDirectory);
}