/* This is APPLY for the rule entitled: beginning rule3 */
public designGraph gearspeedbegrule3(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
double gearspeedrule3 = Lmapping.nodes[1].localVariables[1];
double radius1rule3 = Lmapping.nodes[1].localVariables[3];
double teeth1rule3 = Lmapping.nodes[1].localVariables[2];
/* obtaining values for old properties */
Rmapping.nodes[1].localVariables[0] = 0.0;
Rmapping.nodes[1].localVariables[1] = gearspeedrule3;
Rmapping.nodes[1].localVariables[2] = teeth1rule3;
Rmapping.nodes[1].localVariables[3] = radius1rule3;
/* setting old gear properties*/
Rmapping.nodes[0].localVariables[0] = gearspeedrule3;
/* setting shaft on right properties*/
double teeth2rule3 = Rmapping.nodes[2].localVariables[2];
double radius2rule3 = Rmapping.nodes[2].localVariables[3];
/*obtaining new gear properties from right*/
Rmapping.nodes[2].localVariables[0] = -(teeth1rule3/teeth2rule3);
Rmapping.nodes[2].localVariables[1] = -((gearspeedrule3 * radius1rule3)/radius2rule3);
/* setting new properties with calculations*/
/* put the mechanical advantage into the 0 slot under the gear label*/
/*slot 0- MA, slot 1 - speed, slot 2 - teeth(catalog), slot 3 - radius(catalog)*/
return host;
}
public designGraph copy()
{
/* at times we want to copy a graph and not refer to the same objects. This happens mainly
* (rather initially what inspired this function) when the seed graph is copied into a candidate.*/
int toIndex, fromIndex;
designGraph copyOfGraph = new designGraph();
copyOfGraph.name = name;
foreach (string label in globalLabels)
{
copyOfGraph.globalLabels.Add(label.ToString());
}
foreach (double v in globalVariables)
{
copyOfGraph.globalVariables.Add(v);
}
foreach (node origNode in nodes)
{
copyOfGraph.nodes.Add(origNode.copy());
}
foreach (arc origArc in arcs)
{
arc copyOfArc = origArc.copy();
toIndex = nodes.FindIndex(delegate(node a) { return(a == origArc.To); });
fromIndex = nodes.FindIndex(delegate(node b) { return(b == origArc.From); });
copyOfGraph.addArc(copyOfArc, fromIndex, toIndex);
}
return(copyOfGraph);
}
/* This is APPLY for the rule entitled: gearshaftgear */
public designGraph gearspeedgsg(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
double gearmagsg = Lmapping.nodes[0].localVariables[0];
double gearspeed1gsg = Lmapping.nodes[0].localVariables[1];
double radius1gsg = Lmapping.nodes[0].localVariables[3];
double teeth1gsg = Lmapping.nodes[0].localVariables[2];
/* obtaining values for old properties */
Rmapping.nodes[1].localVariables[0] = gearspeed1gsg;
/* setting shaft on right properties*/
Rmapping.nodes[0].localVariables[1] = gearspeed1gsg;
Rmapping.nodes[0].localVariables[2] = teeth1gsg;
Rmapping.nodes[0].localVariables[3] = radius1gsg;
Rmapping.nodes[0].localVariables[0] = gearmagsg;
/* setting old gear properties*/
double teeth2gsg = Rmapping.nodes[4].localVariables[2];
double radius2gsg = Rmapping.nodes[4].localVariables[3];
/*obtaining new gear properties from right*/
Rmapping.nodes[4].localVariables[0] = (-(teeth1gsg/teeth2gsg)) * gearmagsg;
Rmapping.nodes[4].localVariables[1] = -((gearspeed1gsg * radius1gsg)/radius2gsg);
/* setting new properties with calculations*/
return host;
}
public graphDisplay()
{
InitializeComponent();
this.MdiParent = Program.main;
graphControl1.LoadLibraries();
graph1 = new designGraph();
}
/// <summary>
/// Creates a random graph that takes two parameters: the number of nodes,
/// and the average degree. Note: that there is no guarantee that the graph
/// will be connected.
/// </summary>
/// <param name = "numNodes">The number of nodes.</param>
/// <param name = "aveDegree">The average degree.</param>
/// <returns></returns>
public static designGraph CreateRandomGraph(int numNodes, int aveDegree)
{
var randomGraph = new designGraph
{
name = "RandomGraph_with_" + numNodes + "_nodes_and_degree_of_" + aveDegree
};
var arcProb = (double)aveDegree / (numNodes + 1);
var rnd = new Random();
for (var i = 0; i != numNodes; i++)
{
randomGraph.addNode();
}
for (var i = 0; i != numNodes; i++)
{
for (var j = i + 1; j != numNodes; j++)
{
if ((double)rnd.Next(1000) / 1000 <= arcProb)
{
randomGraph.addArc(randomGraph.nodes[i], randomGraph.nodes[j]);
}
}
}
return(randomGraph);
}
public static void saveGraphToXml
(string filename, Netron.GraphLib.UI.GraphControl graphControl1, designGraph graph1)
{
graph1.updateFromGraphControl(graphControl1);
graph1.checkForRepeatNames();
saveGraphToXml(filename, graph1);
}
/* This is the recognize function called within the RCA generation. It is
* fairly straightforward method that basically invokes the more complex
* recognize function for each rule within it, and returns a list of
* options. */
public List <option> recognize(designGraph host)
{
List <designGraph> locations = new List <designGraph>();
List <option> options = new List <option>();
if (rules.Count == 0)
{
return(options);
}
for (int i = 0; i != rules.Count; i++)
{
locations = rules[i].recognize(host);
if (locations.Count > 0)
{
foreach (designGraph a in locations)
{
options.Add(new option());
options[options.Count - 1].ruleSetIndex = this.ruleSetIndex;
options[options.Count - 1].ruleNumber = i + 1;
options[options.Count - 1].rule = rules[i];
options[options.Count - 1].location = a;
if (this.choiceMethod == choiceMethods.Automatic)
{
return(options);
}
/* this is merely for efficiency - once we get one valid option for
* an Automatic ruleset we can exit and invoke that option. */
}
}
}
return(options);
}
public static void saveGraphToXml
(string filename, Netron.GraphLib.UI.GraphControl graphControl1, designGraph graph1)
{
graph1.updateFromGraphControl(graphControl1);
graph1.checkForRepeatNames();
saveGraphToXml(filename, graph1);
}
/// <summary>
/// Is the arc a free arc from this grammar rule?
/// </summary>
/// <param name = "a">A.</param>
/// <param name = "host">The host.</param>
/// <param name = "freeEndIdentifier">The free end identifier.</param>
/// <param name = "neighborNode">The neighbor node.</param>
/// <returns></returns>
public static Boolean arcIsFree(arc a, designGraph host, out sbyte freeEndIdentifier, out node neighborNode)
{
if (a.From != null && a.To != null &&
!host.nodes.Contains(a.From) && !host.nodes.Contains(a.To))
{
freeEndIdentifier = 0;
/* if the nodes on either end of the freeArc are pointing to previous nodes
* that were deleted in the first pushout then neighborNode is null (and as
* a result any rules using the neighborNodeLabel will not apply) and the
* freeEndIdentifier is zero. */
neighborNode = null;
return(true);
}
if (a.From != null && !host.nodes.Contains(a.From))
{
freeEndIdentifier = -1;
/* freeEndIdentifier set to -1 means that the From end of the arc must be the free end.*/
neighborNode = a.To;
return(true);
}
if (a.To != null && !host.nodes.Contains(a.To))
{
freeEndIdentifier = +1;
/* freeEndIdentifier set to +1 means that the To end of the arc must be the free end.*/
neighborNode = a.From;
return(true);
}
/* else, the arc is not a free arc after all and we simply break out
* of this loop and try the next arc. */
freeEndIdentifier = 0;
neighborNode = null;
return(false);
}
private void showNodeArcProperties(PropertyBag shapeProps, designGraph graph)
{
this.nodeArcProps.Enabled = true;
this.propertiesTabControl.SelectedIndex = 0;
try
{
if ((shapeProps.Owner.GetType()) == (typeof(Connection)))
{
arc temparc = graph.arcs.Find(delegate(arc b)
{ return (b.displayShape == shapeProps.Owner); });
if (temparc.Bag == null) temparc.initPropertiesBag();
this.nodeArcProps.SelectedObject = temparc.Bag;
}
else
{
node tempnode = graph.nodes.Find(delegate(node b)
{ return (b.displayShape == shapeProps.Owner); });
if (tempnode.Bag == null) tempnode.initPropertiesBag();
this.nodeArcProps.SelectedObject = tempnode.Bag;
}
}
catch
{
this.nodeArcProps.Enabled = false;
this.propertiesTabControl.SelectedIndex = 1;
}
}
public static designGraph openGraphFromXml(string filename)
{
StreamReader graphReader = null;
designGraph newDesignGraph = null;
try
{
graphReader = new StreamReader(filename);
XmlSerializer graphDeserializer = new XmlSerializer(typeof(designGraph));
newDesignGraph = (designGraph)graphDeserializer.Deserialize(graphReader);
SearchIO.output(Path.GetFileName(filename) + " successfully loaded.");
newDesignGraph.internallyConnectGraph();
if (newDesignGraph.name == null)
{
newDesignGraph.name = Path.GetFileName(filename).TrimEnd(new char[] { '.', 'x', 'm', 'l' });
}
}
catch (Exception ioe)
{ SearchIO.output("Error Opening Graph: " + ioe.ToString()); }
finally
{
if (graphReader != null)
{
graphReader.Close();
}
}
return(newDesignGraph);
}
/// <summary>
/// Initializes a new instance of the <see cref = "candidate" /> class.
/// </summary>
/// <param name = "_graph">The _graph.</param>
/// <param name = "numRuleSets">The num rule sets.</param>
public candidate(designGraph _graph, int numRuleSets)
{
graph = _graph;
for (var i = 0; i != numRuleSets; i++)
{
GenerationStatus.Add(GenerationStatuses.Unspecified);
}
}
/* if true then all arcs between the nodes in L must be in host and no more
* - again not a proper SUBSET
* if false then proper subset.
* this following function is the only to use induced and is only called early
* in the Location Found case, and only then when induced is true. As its name implies it
* simply checks to see if there are any arcs in the host between the nodes recognized. */
private Boolean noOtherArcsInHost(designGraph host, List<node> locatedNodes, List<arc> locatedArcs)
{
foreach (arc a in host.arcs)
{
if (!locatedArcs.Contains(a) && locatedNodes.Contains(a.From) && locatedNodes.Contains(a.To))
return false;
}
return true;
}
public graphDisplay(designGraph initGraph, string formTitle)
{
InitializeComponent();
this.MdiParent = Program.main;
graphControl1.LoadLibraries();
this.Text = formTitle;
if (initGraph == null) graph1 = new designGraph();
else graph1 = initGraph;
graph1.displayGraph(graphControl1, this.globalLabelsText);
}
/* Parametric application rules receive as input:
* 1. the location designGraph indicating the nodes&arcs of host that match with L (Lmapping)
* 2. the entire host graph (host)
* 3. the location of the nodes in the host that R matches to (Rmapping).
* 4. the parameters chosen by an agent for instantiating elements of Rmapping or host (parameters). */
/* This is APPLY for the rule entitled: beginning rule1*/
public designGraph gearspeedbegrule1(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
double gearspeedrule1 = Program.inputspeed;
/*taking the speed from the seed*/
/* setting it into the place on the new gear */
Rmapping.nodes[1].localVariables[1] = gearspeedrule1;
Rmapping.nodes[0].localVariables[0] = gearspeedrule1;
return host;
}
public node findNewNodeToConnect(designGraph R, designGraph Rmapping)
{
/* find R-L node that is to be connected with freeArc as well as old L-R node name*/
if ((RNodeName != null) && (RNodeName != ""))
{
/* take the RNodeName from within the rule and get the proper reference to the new node.
* If there is no RNodeName, then the embedding rule will set the reference to null. */
int index = R.nodes.FindIndex(delegate(node b) { return (b.name == RNodeName); });
return Rmapping.nodes[index];
}
else return null;
}
/* This is APPLY for the rule entitled: seedBurst2rule3 */
public designGraph distributeTo2NewRoots(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
for (int i = 1; i <= 2; i++)
{
Rmapping.nodes[i].localVariables.Add(Rmapping.nodes[0].localVariables[0] / 2);
//Rmapping.nodes[i].screenY = 0.0f;
//Rmapping.nodes[i].screenX = 0.0f;
}
Rmapping.nodes[0].localVariables[0] = 0.1;
return host;
}
public node findDeletedNode(designGraph L, designGraph Lmapping)
{
/* similarly, we can find the LNodeName (if one exists in this particular rule). Setting this
* up now saves time and space in the below recognition if-then's. */
if ((LNodeName != null) && (LNodeName != ""))
{
int index = L.nodes.FindIndex(delegate(node b) { return(b.name == LNodeName); });
return(Lmapping.nodes[index]);
}
else
{
return(null);
}
}
/* This is perhaps the whole reason previous states are used.
* Rules cannot be guaranteed to work in reverse as they work
* forward, so this simply resets the candidate to how it looked
* prior to calling the last rule. */
public void undoLastRule()
{
if (prevStates.Count > 0)
{
currentState = prevStates[prevStates.Count - 1];
prevStates.RemoveAt(prevStates.Count - 1);
recipe.RemoveAt(recipe.Count - 1);
for (int i = 0; i != performanceParams.Count; i++)
{
performanceParams[i] = 0.0;
}
age = 0;
}
}
public node findNewNodeToConnect(designGraph R, designGraph Rmapping)
{
/* find R-L node that is to be connected with freeArc as well as old L-R node name*/
if ((RNodeName != null) && (RNodeName != ""))
{
/* take the RNodeName from within the rule and get the proper reference to the new node.
* If there is no RNodeName, then the embedding rule will set the reference to null. */
int index = R.nodes.FindIndex(delegate(node b) { return(b.name == RNodeName); });
return(Rmapping.nodes[index]);
}
else
{
return(null);
}
}
/* here are parametric rules written as part of the ruleSet.
* these are compiled at runtime into a .dll indicated in the
* App.config file. */
#region Parametric Recognition Rules
/* Parametric recognition rules receive as input:
* 1. the left hand side of the rule (L)
* 2. the entire host graph (host)
* 3. the location of the nodes in the host that L matches to (locatedNodes).
* 4. the location of the arcs in the host that L matches to (locatedArcs). */
#endregion
#region Parametric Application Rules
/* Parametric application rules receive as input:
* 1. the location designGraph indicating the nodes&arcs of host that match with L (Lmapping)
* 2. the entire host graph (host)
* 3. the location of the nodes in the host that R matches to (Rmapping).
* 4. the parameters chosen by an agent for instantiating elements of Rmapping or host (parameters). */
/* This is APPLY for the rule entitled: swirlRule1 */
public designGraph slopeOfNewEdge(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
edge oldEdge = (edge)Rmapping.arcs[0];
vertex oldVertex0 = (vertex)Rmapping.nodes[0];
vertex oldVertex1 = (vertex)Rmapping.nodes[1];
double newAngle = System.Math.Atan2((oldVertex1.y - oldVertex0.y), (oldVertex1.x - oldVertex0.x)) - 0.4;
double newLength = 1.05 * oldEdge.length;
vertex newVertex = (vertex)Rmapping.nodes[2];
newVertex.x = oldVertex1.x + newLength * System.Math.Cos(newAngle);
newVertex.screenX = (float)newVertex.x;
newVertex.y = oldVertex1.y + newLength * System.Math.Sin(newAngle);
newVertex.screenY = (float)newVertex.y;
return host;
}
/// <summary>
/// Creates an empty location graph used in recognition.
/// </summary>
/// <param name="numNodes">The num nodes.</param>
/// <param name="numArcs">The num arcs.</param>
/// <param name="numHyperArcs">The num hyper arcs.</param>
/// <returns></returns>
public static designGraph CreateEmptyLocationGraph(int numNodes, int numArcs, int numHyperArcs = 0)
{
var emptyGraph = new designGraph();
for (var i = 0; i != numNodes; i++)
{
emptyGraph.nodes.Add(null);
}
for (var i = 0; i != numArcs; i++)
{
emptyGraph.arcs.Add(null);
}
for (var i = 0; i != numHyperArcs; i++)
{
emptyGraph.hyperarcs.Add(null);
}
return(emptyGraph);
}
public void apply(designGraph Lmapping, designGraph host, double[] parameters)
{
/* Update the global labels.*/
foreach (string a in L.globalLabels)
if (!R.globalLabels.Contains(a))
host.globalLabels.Remove(a); /* removing the labels in L but not in R...*/
foreach (string a in R.globalLabels)
if (!L.globalLabels.Contains(a))
host.globalLabels.Add(a.ToString()); /*...and adding the label in R but not in L.*/
foreach (double a in L.globalVariables) /* do the same now, for the variables. */
if (!R.globalVariables.Contains(a))
host.globalVariables.Remove(a); /* removing the labels in L but not in R...*/
foreach (double a in R.globalVariables)
if (!L.globalVariables.Contains(a))
host.globalVariables.Add(a); /*...and adding the label in R but not in L.*/
/* First set up the Rmapping, which is a list of nodes within the host
* that corresponds in length and position to the nodes in R, just as
* Lmapping contains lists of nodes and arcs in the order they are
* referred to in L. */
designGraph Rmapping = new designGraph();
foreach (node a in R.nodes) /* we do not know what these will point to yet, so just */
Rmapping.nodes.Add(null); /* make it of proper length at this point. */
foreach (arc a in R.arcs) /* DEBUG HINT: you should check Rmapping at the end of */
Rmapping.arcs.Add(null); /* the function - it should contain no nulls. */
removeLdiffKfromHost(Lmapping, host);
addRdiffKtoD(Lmapping, host, Rmapping);
/* these two lines correspond to the two "pushouts" of the double pushout algorithm.
* L <--- K ---> R this is from freeArc embedding (aka edNCE)
* | | | | this is from the parametric update
* | | | | |
* host <-- D ---> H1 ---> H2 ---> H3
* The first step is to create D by removing the part of L not found in K (the commonality).
* Second, we add the elements of R not found in K to D to create the updated host, H. Note,
* that in order to do this, we must know what subgraph of the host we are manipulating - this
* is the location mapping found by the recognize function. */
freeArcEmbedding(Lmapping, host, Rmapping);
/* however, there may still be a need to embed the graph with other arcs left dangling,
* as in the "edge directed Node Controlled Embedding approach", which considers the neighbor-
* hood of nodes and arcs of the recognized Lmapping. */
updateParameters(Lmapping, host, Rmapping, parameters);
}
public void showProperties(Netron.GraphLib.UI.GraphControl GC, designGraph graph1, object[] props)
{
graphControl = GC;
graph = graph1;
rule = null;
try
{
graph.updateFromGraphControl(graphControl);
if (graph.Bag == null) graph.initPropertiesBag();
this.graphRuleProps.SelectedObject = graph.Bag;
this.graphRulePropsTab.Text = "Graph Properties";
}
catch (Exception exc)
{
MessageBox.Show("The properties of the graph has thrown an exception and cannot be displayed.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
SearchIO.output(exc.Message, 2);
}
showDisplayProperties(graphControl, (Netron.GraphLib.PropertyBag)props[0]);
showNodeArcProperties((Netron.GraphLib.PropertyBag)props[0], graph);
}
public static void saveGraphToXml(string filename, designGraph graph1)
{
graph1.checkForRepeatNames();
StreamWriter graphWriter = null;
try
{
graphWriter = new StreamWriter(filename);
XmlSerializer graphSerializer = new XmlSerializer(typeof(designGraph));
graphSerializer.Serialize(graphWriter, graph1);
}
catch (Exception ioe)
{
MessageBox.Show(ioe.ToString(), "XML Serialization Error", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
finally
{
if (graphWriter != null) graphWriter.Close();
}
}
/// <summary>
/// This is the recognize function called within the RCA generation. It is
/// fairly straightforward method that basically invokes the more complex
/// recognize function for each rule within it, and returns a list of
/// options.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="InParallel">if set to <c>true</c> [in parallel].</param>
/// <param name="RelaxationTemplate">The relaxation template.</param>
/// <returns></returns>
public List <option> recognize(designGraph host, Boolean InParallel = true, Relaxation RelaxationTemplate = null)
{
var options = new List <option>();
if (rules.Count == 0)
{
return(options);
}
if (choiceMethod == choiceMethods.Automatic)
{
for (var i = 0; i != rules.Count; i++)
{
var ruleOpts = rules[i].recognize(host, InParallel, (generationAfterNoRules == nextGenerationSteps.Stop) ? RelaxationTemplate : null);
if (ruleOpts.Count > 0)
{
var r0 = ruleOpts[0];
r0.assignRuleInfo(i + 1, RuleSetIndex);
return(new List <option> {
r0
});
}
}
}
else if (InParallel)/* new parallel rule check */
{
options = rules.SelectMany((rule, ruleIndex) =>
rule.recognize(host, true, (generationAfterNoRules == nextGenerationSteps.Stop) ? RelaxationTemplate : null)
.Select(o => o.assignRuleInfo(ruleIndex + 1, RuleSetIndex))).AsParallel().ToList();
}
else /* do in series */
{
options = rules.SelectMany((rule, ruleIndex) =>
rule.recognize(host, false, (generationAfterNoRules == nextGenerationSteps.Stop) ? RelaxationTemplate : null)
.Select(o => o.assignRuleInfo(ruleIndex + 1, RuleSetIndex))).ToList();
}
for (var i = 0; i < options.Count; i++)
{
options[i].optionNumber = i;
}
return(options);
}
/// <summary>
/// Creates a complete graph where every node is connected to every
/// other node by an arc.
/// </summary>
/// <param name="numNodes">The number of nodes.</param>
/// <returns></returns>
public static designGraph CreateCompleteGraph(int numNodes)
{
var numArcs = numNodes * (numNodes - 1) / 2;
var completeGraph = new designGraph
{
name = "CompleteGraph_with_" + numNodes + "_nodes_and_" + numArcs + "_arcs"
};
for (var i = 0; i != numNodes; i++)
{
completeGraph.addNode();
}
for (var i = 0; i != numNodes; i++)
{
for (var j = i + 1; j != numNodes; j++)
{
completeGraph.addArc(completeGraph.nodes[i], completeGraph.nodes[j]);
}
}
return(completeGraph);
}
/* This is APPLY for the rule entitled: aftersgos */
public designGraph gearspeedas(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
double gearmaas = Lmapping.nodes[0].localVariables[0];
double gearspeedas = Lmapping.nodes[0].localVariables[1];
double radius1as = Lmapping.nodes[0].localVariables[3];
double teeth1as = Lmapping.nodes[0].localVariables[2];
/* obtaining values for old properties */
Rmapping.nodes[0].localVariables[1] = gearspeedas;
Rmapping.nodes[0].localVariables[2] = teeth1as;
Rmapping.nodes[0].localVariables[3] = radius1as;
Rmapping.nodes[0].localVariables[0] = gearmaas;
/* setting old gear properties*/
double teeth2as = Rmapping.nodes[1].localVariables[2];
double radius2as = Rmapping.nodes[1].localVariables[3];
/*obtaining new gear properties from right*/
Rmapping.nodes[1].localVariables[0] = (-(teeth1as / teeth2as)) * gearmaas;
Rmapping.nodes[1].localVariables[1] = -((gearspeedas * radius1as) / radius2as);
return host;
}
/* This is the recognize function called within the RCA generation. It is
* fairly straightforward method that basically invokes the more complex
* recognize function for each rule within it, and returns a list of
* options. */
public List<option> recognize(designGraph host)
{
List<designGraph> locations = new List<designGraph>();
List<option> options = new List<option>();
if (rules.Count == 0) return options;
for (int i = 0; i != rules.Count; i++)
{
locations = rules[i].recognize(host);
if (locations.Count > 0)
foreach (designGraph a in locations)
{
options.Add(new option());
options[options.Count - 1].ruleSetIndex = this.ruleSetIndex;
options[options.Count - 1].ruleNumber = i + 1;
options[options.Count - 1].rule = rules[i];
options[options.Count - 1].location = a;
if (this.choiceMethod == choiceMethods.Automatic) return options;
/* this is merely for efficiency - once we get one valid option for
* an Automatic ruleset we can exit and invoke that option. */
}
}
return options;
}
public void showProperties(Netron.GraphLib.UI.GraphControl GC, grammarRule rule1, object[] props)
{
graphControl = GC;
rule = rule1;
if (graphControl.Name == "graphControlLHS") graph = rule.L;
else graph = rule.R;
rule.updateFromGraphControl(graphControl);
try
{
this.graphRulePropsTab.Text = "Rule Properties";
if (rule.Bag == null) rule.initPropertiesBag();
this.graphRuleProps.SelectedObject = rule.Bag;
}
catch (Exception exc)
{
MessageBox.Show("The properties of the rule has thrown an exception and cannot be displayed.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
SearchIO.output(exc.Message, 2);
}
showDisplayProperties(graphControl, (Netron.GraphLib.PropertyBag)props[0]);
showRuleNodeArcProperties((Netron.GraphLib.PropertyBag)props[0], graph);
}
/* if allowArcDuplication is true then for each rule that matches with the arc the arc will be
* duplicated. */
public static Boolean arcIsFree(arc a, designGraph host, out sbyte freeEndIdentifier, node neighborNode)
{
if (a.From != null && a.To != null &&
!host.nodes.Contains(a.From) && !host.nodes.Contains(a.To))
{
freeEndIdentifier = 0;
/* if the nodes on either end of the freeArc are pointing to previous nodes
* that were deleted in the first pushout then neighborNode is null (and as
* a result any rules using the neighborNodeLabel will not apply) and the
* freeEndIdentifier is zero. */
neighborNode = null;
return true;
}
else if (a.From != null && !host.nodes.Contains(a.From))
{
freeEndIdentifier = -1;
/* freeEndIdentifier set to -1 means that the From end of the arc must be the free end.*/
neighborNode = a.To;
return true;
}
else if (a.To != null && !host.nodes.Contains(a.To))
{
freeEndIdentifier = +1;
/* freeEndIdentifier set to +1 means that the To end of the arc must be the free end.*/
neighborNode = a.From;
return true;
}
else
{
/* else, the arc is not a free arc after all and we simply break out
* of this loop and try the next arc. */
freeEndIdentifier = 0;
neighborNode = null;
return false;
}
}
public static void saveGraphToXml(string filename, designGraph graph1)
{
graph1.checkForRepeatNames();
StreamWriter graphWriter = null;
try
{
graphWriter = new StreamWriter(filename);
XmlSerializer graphSerializer = new XmlSerializer(typeof(designGraph));
graphSerializer.Serialize(graphWriter, graph1);
}
catch (Exception ioe)
{
MessageBox.Show(ioe.ToString(), "XML Serialization Error", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
finally
{
if (graphWriter != null)
{
graphWriter.Close();
}
}
}
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets, int[] _maxNumOfCalls)
: base(_seed, _rulesets, _maxNumOfCalls, false) { }
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets, int _maxRulesToApply)
: base(_seed, _rulesets, _maxRulesToApply, false) { }
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets, Boolean _display)
: base(_seed, _rulesets, -1, _display) { }
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets)
: base(_seed, _rulesets, -1, false) { }
/* a constructor like these are needed to invoke the main constructor in RecognizeChooseApply.cs */
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets, int _maxRulesToApply,
Boolean recompileRules, string execDir, string compiledparamRules)
: base(_seed, _rulesets, _maxRulesToApply, false, recompileRules, execDir,
compiledparamRules) { }
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets, int[] _maxNumOfCalls, Boolean _display,
Boolean recompileRules, string execDir, string compiledparamRules)
: base(_seed, _rulesets, _maxNumOfCalls, _display, recompileRules, execDir, compiledparamRules) { }
/// <summary>
/// Applies the option to the specified host. It is essentially
/// a shorthand instead of calling
/// option.rule.apply(option.location, host, parameters); we call
/// option.apply(host, parameters).
/// </summary>
/// <param name = "host">The host.</param>
/// <param name = "Parameters">The parameters.</param>
public void apply(designGraph host, double[] Parameters)
{
rule.apply(host, this, Parameters);
}
/// <summary>
/// Copies the specified make deep copy.
/// </summary>
/// <param name = "MakeDeepCopy">if set to <c>true</c> [make deep copy].</param>
/// <returns></returns>
public designGraph copy(Boolean MakeDeepCopy = true)
{
/* at times we want to copy a graph and not refer to the same objects. This happens mainly
* (rather initially what inspired this function) when the seed graph is copied into a candidate.*/
var copyOfGraph = new designGraph {
name = name
};
foreach (var label in globalLabels)
{
copyOfGraph.globalLabels.Add(label);
}
foreach (var v in globalVariables)
{
copyOfGraph.globalVariables.Add(v);
}
foreach (var origNode in nodes)
{
copyOfGraph.addNode(MakeDeepCopy ? origNode.copy() : origNode);
}
foreach (var origArc in arcs)
{
if (MakeDeepCopy)
{
var copyOfArc = origArc.copy();
var toIndex = nodes.FindIndex(a => (a == origArc.To));
var fromIndex = nodes.FindIndex(b => (b == origArc.From));
node fromNode = null;
if (fromIndex > -1)
{
fromNode = copyOfGraph.nodes[fromIndex];
}
node toNode = null;
if (toIndex > -1)
{
toNode = copyOfGraph.nodes[toIndex];
}
copyOfGraph.addArc(copyOfArc, fromNode, toNode);
}
else
{
copyOfGraph.arcs.Add(origArc);
}
}
foreach (var origHyperArc in hyperarcs)
{
if (MakeDeepCopy)
{
var copyOfHyperArc = origHyperArc.copy();
var attachedNodes = new List <node>();
foreach (var n in origHyperArc.nodes)
{
var index = nodes.FindIndex(a => (a == n));
attachedNodes.Add(copyOfGraph.nodes[index]);
}
copyOfGraph.addHyperArc(copyOfHyperArc, attachedNodes);
}
else
{
copyOfGraph.hyperarcs.Add(origHyperArc);
}
}
return(copyOfGraph);
}
public static void addAndShowGraphDisplay(designGraph graph, string title)
{
object[] paramValues = { graph, title };
SafeInvokeHelper.Invoke(main, "addAndShowGraphDisplay", paramValues);
}
public void apply(designGraph host, double[] parameters)
{
rule.apply(location, host, parameters);
}
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets, int _maxRulesToApply, Boolean _display)
: base(_seed, _rulesets, _maxRulesToApply, _display) { }
/* This is APPLY for the rule entitled: terminal rule */
public designGraph gearspeedterm(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
double gearmaterm = Lmapping.nodes[0].localVariables[0];
double gearspeedterm = Lmapping.nodes[0].localVariables[1];
double radius1term = Lmapping.nodes[0].localVariables[3];
double teeth1term = Lmapping.nodes[0].localVariables[2];
double gearma2term = Lmapping.nodes[1].localVariables[0];
double gearspeed2term = Lmapping.nodes[1].localVariables[1];
double radius2term = Lmapping.nodes[1].localVariables[3];
double teeth2term = Lmapping.nodes[1].localVariables[2];
/* obtaining values for old properties */
Rmapping.nodes[1].localVariables[1] = gearspeedterm;
Rmapping.nodes[1].localVariables[0] = gearmaterm;
/* setting shaft on right properties*/
Rmapping.nodes[0].localVariables[1] = gearspeedterm;
Rmapping.nodes[0].localVariables[2] = teeth1term;
Rmapping.nodes[0].localVariables[3] = radius1term;
Rmapping.nodes[0].localVariables[0] = gearmaterm;
Rmapping.nodes[4].localVariables[1] = gearspeed2term;
Rmapping.nodes[4].localVariables[2] = teeth2term;
Rmapping.nodes[4].localVariables[3] = radius2term;
Rmapping.nodes[4].localVariables[0] = gearma2term;
/* setting old gear properties*/
return host;
}
/* This is APPLY for the rules entitled: smallergearonshaft*/
public designGraph gearspeedsgs(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
double gearmasgs = Lmapping.nodes[0].localVariables[0];
double gearspeed1 = Lmapping.nodes[0].localVariables[1];
double radius1sgs = Lmapping.nodes[0].localVariables[3];
double teeth1sgs = Lmapping.nodes[0].localVariables[2];
/* obtaining values for old gear 1 properties */
double gearma2sgs = Lmapping.nodes[1].localVariables[0];
double gearspeed2 = Lmapping.nodes[1].localVariables[1];
double radius2sgs = Lmapping.nodes[1].localVariables[3];
double teeth2sgs = Lmapping.nodes[1].localVariables[2];
/* obtaining values for old gear 2 properties */
Rmapping.nodes[1].localVariables[0] = gearspeed1;
/* setting shaft on right gear 2 properties*/
Rmapping.nodes[0].localVariables[1] = gearspeed1;
Rmapping.nodes[0].localVariables[2] = teeth1sgs;
Rmapping.nodes[0].localVariables[3] = radius1sgs;
Rmapping.nodes[0].localVariables[0] = gearmasgs;
/* setting old gear 1 properties*/
Rmapping.nodes[5].localVariables[1] = gearspeed2;
Rmapping.nodes[5].localVariables[2] = teeth2sgs;
Rmapping.nodes[5].localVariables[3] = radius2sgs;
Rmapping.nodes[5].localVariables[0] = gearma2sgs;
/* setting old gear 2 properties*/
double teeth3sgs = Rmapping.nodes[4].localVariables[2];
double radius3sgs = Rmapping.nodes[4].localVariables[3];
/*obtaining new gear properties from right*/
Rmapping.nodes[4].localVariables[0] = (-(teeth1sgs/teeth3sgs))*gearmasgs;
Rmapping.nodes[4].localVariables[1] = gearspeed1;
/* setting new properties with calculations*/
return host;
}
/* if allowArcDuplication is true then for each rule that matches with the arc the arc will be
* duplicated. */
#endregion
#region Methods
internal static Boolean hyperArcIsFree(hyperarc dangleHyperArc, designGraph host, out List <node> neighborNodes)
{
neighborNodes = dangleHyperArc.nodes.Where(n => !host.nodes.Contains(n)).ToList();
return(neighborNodes.Count > 0);
}
/* This is APPLY for the rules entitled: singleidler*/
public designGraph gearspeedidler(designGraph Lmapping, designGraph host, designGraph Rmapping, double[] parameters)
{
double gearmaidle = Lmapping.nodes[0].localVariables[0];
double gearspeedidle = Lmapping.nodes[0].localVariables[1];
double radius1idle = Lmapping.nodes[0].localVariables[3];
double teeth1idle = Lmapping.nodes[0].localVariables[2];
/* obtaining values for old properties */
/*Shaft speed is already set to 0*/
Rmapping.nodes[0].localVariables[1] = gearspeedidle;
Rmapping.nodes[0].localVariables[2] = teeth1idle;
Rmapping.nodes[0].localVariables[3] = radius1idle;
Rmapping.nodes[0].localVariables[0] = gearmaidle;
/* setting old gear properties*/
double teeth2idle = Rmapping.nodes[3].localVariables[2];
double radius2idle = Rmapping.nodes[3].localVariables[3];
/*obtaining new gear properties from right*/
Rmapping.nodes[3].localVariables[0] = (-(teeth1idle/teeth2idle)) * gearmaidle;
Rmapping.nodes[3].localVariables[1] = -((gearspeedidle * radius1idle)/radius2idle);
/* setting new properties with calculations*/
return host;
}
public randomChooseWithUndo(designGraph _seed, ruleSet[] _rulesets, int[] _maxNumOfCalls, Boolean _display)
: base(_seed, _rulesets, _maxNumOfCalls, _display) { }
public void apply(designGraph host, double[] parameters)
{
rule.apply(location, host, parameters);
}
