private IProcedureFunctionChart CreateSchedulePfc(IModel model, string pfcName, double minutesPerTask, ExecutionEngineConfiguration eec)
{
// Start
// |
// + T1
// |
// Campaigns
// |
// + T2
//
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, pfcName);
pfc.ExecutionEngineConfiguration = eec;
pfc.CreateStep("Start", "", Guid.NewGuid());
pfc.CreateStep("Campaigns", "", Guid.NewGuid());
pfc.CreateTransition("T1", "", Guid.NewGuid());
pfc.CreateTransition("T2", "", Guid.NewGuid());
pfc.Bind(pfc.Nodes["Start"], pfc.Nodes["T1"]);
pfc.Bind(pfc.Nodes["T1"], pfc.Nodes["Campaigns"]);
pfc.Bind(pfc.Nodes["Campaigns"], pfc.Nodes["T2"]);
pfc.UpdateStructure();
return(pfc);
}
public static ProcedureFunctionChart CreateLoopTestPfc()
{
ProcedureFunctionChart pfc = new ProcedureFunctionChart(new Highpoint.Sage.SimCore.Model("Test model", Guid.NewGuid()), "SFC 1");
#region Create Nodes
A = pfc.CreateStep("Step_A", "", Guid.NewGuid());
B = pfc.CreateStep("Step_B", "", Guid.NewGuid());
C = pfc.CreateStep("Step_C", "", Guid.NewGuid());
nA = (IPfcNode)A;
nB = (IPfcNode)B;
nC = (IPfcNode)C;
#endregion Create Nodes
#region Create Structure
pfc.Bind(nA, nB);
pfc.Bind(nB, nC);
pfc.Bind(nB, nB);
#endregion Create Structure
return(pfc);
}
public void Test_InsertStepAndTransition()
{
Model model = new Model("SFC Test 1");
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, "SFC 1", "", Guid.NewGuid());
IPfcStepNode t0 = pfc.CreateStep("START", "", Guid.Empty);
IPfcStepNode t1 = pfc.CreateStep("FINISH", "", Guid.Empty);
pfc.Bind(t0, t1);
string structureString = PfcDiagnostics.GetStructure(pfc);
Console.WriteLine("Structure is \r\n" + structureString);
// Get reference to old successor
IPfcNode pfcNode = pfc.Nodes["T_000"];
IPfcNode oldSuccessorNode = pfcNode.SuccessorNodes[0];
// Add the step
IPfcStepNode newStep = pfc.CreateStep("STEP_1", "", Guid.Empty);
IPfcTransitionNode newTrans = pfc.CreateTransition();
// We are adding a step following a transition - binding is from selectedTrans-newStep-newTrans-oldSuccessorStep
pfc.Bind(pfcNode, newStep);
pfc.Bind(newStep, newTrans);
pfc.Bind(newTrans, oldSuccessorNode);
// Disconnect old successor
pfc.Unbind(pfcNode, oldSuccessorNode);
structureString = PfcDiagnostics.GetStructure(pfc);
Console.WriteLine("Structure is \r\n" + structureString);
Assert.IsTrue(structureString.Equals("{START-->[L_000(SFC 1.Root)]-->T_000}\r\n{T_000-->[L_002(SFC 1.Root)]-->STEP_1}\r\n{STEP_1-->[L_003(SFC 1.Root)]-->T_001}\r\n{T_001-->[L_004(SFC 1.Root)]-->FINISH}\r\n"));
}
public static Dictionary <IPfcNode, int> GetNodeDepths(ProcedureFunctionChart pfc)
{
Dictionary <IPfcNode, int> depths = new Dictionary <IPfcNode, int>();
//List<IPfcStepNode> nodes =
//Debug.Assert( nodes.Count == 1, "A PFC was passed into PFCAnalyst.GetNodeDepths(...) that had " + nodes.Count + " finish steps. This is illegal." );
IPfcNode node = pfc.GetFinishTransition( );
GetDepth(node, ref depths);
return(depths);
}
public static ProcedureFunctionChart CreateTestPfc5()
{
// Flip-flop pattern.
ProcedureFunctionChart pfc = new ProcedureFunctionChart(new Highpoint.Sage.SimCore.Model("Test model", Guid.NewGuid()), "SFC 1");
#region Create Nodes
char name = 'A';
A = pfc.CreateStep("Step_" + (name++), "", NextGuid());
B = pfc.CreateStep("Step_" + (name++), "", NextGuid());
C = pfc.CreateStep("Step_" + (name++), "", NextGuid());
D = pfc.CreateStep("Step_" + (name++), "", NextGuid());
E = pfc.CreateStep("Step_" + (name++), "", NextGuid());
F = pfc.CreateStep("Step_" + (name++), "", NextGuid());
nA = (IPfcNode)A;
nB = (IPfcNode)B;
nC = (IPfcNode)C;
nD = (IPfcNode)D;
nE = (IPfcNode)E;
nF = (IPfcNode)F;
#endregion Create Nodes
#region Create Structure
pfc.BindParallelDivergent(nA, new IPfcNode[] { nB, nC });
pfc.BindSeriesDivergent(nB, new IPfcNode[] { nD, nE });
pfc.BindSeriesDivergent(nC, new IPfcNode[] { nD, nE });
pfc.BindParallelConvergent(new IPfcNode[] { nD, nE }, nF);
PfcLinkElementList links = new PfcLinkElementList(pfc.Links);
links.Sort(new Comparison <IPfcLinkElement>(delegate(IPfcLinkElement a, IPfcLinkElement b) {
return(Comparer.Default.Compare(a.Name, b.Name));
}));
System.Reflection.BindingFlags bf = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.FlattenHierarchy | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
foreach (IPfcLinkElement link in links)
{
typeof(PfcElement).GetFields(bf);
typeof(PfcElement).GetField("m_guid", bf).SetValue((PfcElement)link, NextGuid()); // Totally cheating.
}
//pfc.Bind(nD, pfc.Nodes["T_005"]);
#endregion Create Structure
return(pfc);
}
public static int AssignWeightsForBroadestNonLoopingPath(ProcedureFunctionChart pfc)
{
pfc.Nodes.ForEach(n => n.NodeColor = NodeColor.White);
pfc.Links.ForEach(n => n.Priority = null);
PfcStep start = (PfcStep)pfc.GetStartSteps()[0];
int retval = WeightAssignmentPropagationForBroadestNonLoopingPath(start);
pfc.Links.ForEach(n => { if (n.Priority < 0)
{
n.Priority = int.MinValue - n.Priority;
}
});
return(retval);
}
private void _TestSerialization(ProcedureFunctionChart pfc, string shouldBe, string testName)
{
#region Store the Pfc to a file.
#region Create an XmlWriter
System.Text.StringBuilder sb = new System.Text.StringBuilder();
System.IO.StringWriter sw = new System.IO.StringWriter(sb);
XmlTextWriter writer = new XmlTextWriter(sw);
writer.Formatting = Formatting.Indented;
#endregion Create an XmlWriter
#region Write the PFC to the writer
writer.WriteStartDocument();
pfc.WriteXml(writer);
writer.WriteEndDocument();
writer.Flush();
writer.Close();
#endregion Write the PFC to the writer
XmlDocument doc = new XmlDocument();
doc.InnerXml = sb.ToString();
doc.Save(m_pfcTestFileName);
#endregion Store the Pfc to a file.
#region Load the Pfc from a file.
ProcedureFunctionChart pfc2 = new ProcedureFunctionChart();
FileStream fs = new FileStream(m_pfcTestFileName, FileMode.Open);
XmlReader tr = System.Xml.XmlReader.Create(fs);
pfc2.ReadXml(tr);
tr.Close();
fs.Close();
File.Delete(m_pfcTestFileName);
Console.WriteLine(PfcDiagnostics.GetStructure(pfc2));
#endregion Load the Pfc from a file.
string structureString = PfcDiagnostics.GetStructure(pfc2);
Console.WriteLine("After storing and reloading a " + testName + ", the reloaded structure is \r\n" + structureString);
Assert.AreEqual(StripCRLF(structureString), StripCRLF(shouldBe), "Structure should have been\r\n" + shouldBe + "\r\nbut it was\r\n" + structureString + "\r\ninstead.");
}
public static ProcedureFunctionChart CreateTestPfc4()
{
ProcedureFunctionChart pfc = new ProcedureFunctionChart(new Highpoint.Sage.SimCore.Model("Test model", Guid.NewGuid()), "SFC 1");
#region Create Nodes
char name = 'A';
A = pfc.CreateStep("Step_" + (name++), "", NextGuid());
B = pfc.CreateStep("Step_" + (name++), "", NextGuid());
C = pfc.CreateStep("Step_" + (name++), "", NextGuid());
D = pfc.CreateStep("Step_" + (name++), "", NextGuid());
E = pfc.CreateStep("Step_" + (name++), "", NextGuid());
nA = (IPfcNode)A;
nB = (IPfcNode)B;
nC = (IPfcNode)C;
nD = (IPfcNode)D;
nE = (IPfcNode)E;
#endregion Create Nodes
#region Create Structure
pfc.Bind(nA, nB);
pfc.Bind(nB, nE);
pfc.Bind(nA.SuccessorNodes[0], nC);
pfc.Bind(nC, nD);
pfc.Bind(nD, nE.PredecessorNodes[0]);
PfcLinkElementList links = new PfcLinkElementList(pfc.Links);
links.Sort(new Comparison <IPfcLinkElement>(delegate(IPfcLinkElement a, IPfcLinkElement b) {
return(Comparer.Default.Compare(a.Name, b.Name));
}));
System.Reflection.BindingFlags bf = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.FlattenHierarchy | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
foreach (IPfcLinkElement link in links)
{
typeof(PfcElement).GetFields(bf);
typeof(PfcElement).GetField("m_guid", bf).SetValue((PfcElement)link, NextGuid()); // Totally cheating.
}
#endregion Create Structure
return(pfc);
}
private void _TestStepToStepBinding()
{
string testName = "Step-to-Step binding, maintaining SFC Compliance";
Model model = new Model("SFC Test 1");
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, "SFC 1", "", Guid.NewGuid());
PfcStep s1 = (PfcStep)pfc.CreateStep("Alice", "", Guid.Empty);
PfcStep s2 = (PfcStep)pfc.CreateStep("Bob", "", Guid.Empty);
//SfcStep s3 = (SfcStep)pfc.CreateStep("Charlie", "", Guid.Empty);
pfc.Bind(s1, s2);
string structureString = PfcDiagnostics.GetStructure(pfc);
Console.WriteLine("After a " + testName + ", structure is \r\n" + structureString);
}
private void _TestTransitionToTransitionBinding()
{
string testName = "Transition-to-Transition binding, maintaining SFC Compliance";
Model model = new Model("SFC Test 1");
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, "SFC 1", "", Guid.NewGuid());
IPfcTransitionNode s1 = pfc.CreateTransition("Alice", "", Guid.Empty);
IPfcTransitionNode s2 = pfc.CreateTransition("Bob", "", Guid.Empty);
//IPfcTransitionNode s3 = pfc.CreateTransition("Charlie", "", Guid.Empty);
pfc.Bind(s1, s2);
string structureString = PfcDiagnostics.GetStructure(pfc);
Console.WriteLine("After a " + testName + ", structure is \r\n" + structureString);
}
private IPfcNode CreateNode(ProcedureFunctionChart pfc, string name, PfcElementType inType)
{
switch (inType)
{
case PfcElementType.Link:
break;
case PfcElementType.Transition:
return(pfc.CreateTransition("T_" + name, "", Guid.NewGuid()));
//break;
case PfcElementType.Step:
return(pfc.CreateStep("S_" + name, "", Guid.NewGuid()));
//break;
default:
break;
}
return(null);
}
public void Test_SynchronizerConstruct_Steps()
{
Model model = new Model("SFC Test 1");
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, "SFC 1", "", Guid.NewGuid());
IPfcStepNode t0 = pfc.CreateStep("S_Alice", "", Guid.Empty);
IPfcStepNode t1 = pfc.CreateStep("S_Bob", "", Guid.Empty);
IPfcStepNode t2 = pfc.CreateStep("S_Charley", "", Guid.Empty);
IPfcStepNode t3 = pfc.CreateStep("S_David", "", Guid.Empty);
IPfcStepNode t4 = pfc.CreateStep("S_Edna", "", Guid.Empty);
IPfcStepNode t5 = pfc.CreateStep("S_Frank", "", Guid.Empty);
IPfcStepNode t6 = pfc.CreateStep("S_Gary", "", Guid.Empty);
IPfcStepNode t7 = pfc.CreateStep("S_Hailey", "", Guid.Empty);
pfc.Synchronize(new IPfcStepNode[] { t0, t1, t2, t3 }, new IPfcStepNode[] { t4, t5, t6, t7 });
string structureString = PfcDiagnostics.GetStructure(pfc);
structureString = structureString.Replace("SFC 1.Root", "SFC 1.Root");
string shouldBe = "{S_Alice-->[L_000(SFC 1.Root)]-->T_000}\r\n{S_Bob-->[L_001(SFC 1.Root)]-->T_000}\r\n{S_Charley-->[L_002(SFC 1.Root)]-->T_000}\r\n{S_David-->[L_003(SFC 1.Root)]-->T_000}\r\n{T_000-->[L_004(SFC 1.Root)]-->S_Edna}\r\n{T_000-->[L_005(SFC 1.Root)]-->S_Frank}\r\n{T_000-->[L_006(SFC 1.Root)]-->S_Gary}\r\n{T_000-->[L_007(SFC 1.Root)]-->S_Hailey}\r\n";
Console.WriteLine("After a synchronization of steps, structure is \r\n" + structureString);
Assert.AreEqual(structureString, shouldBe, "Structure should have been\r\n" + shouldBe + "\r\nbut it was\r\n" + structureString + "\r\ninstead.");
if (m_runSFCs)
{
TestEvaluator testEvaluator = new TestEvaluator(new IPfcStepNode[] { t0, t1, t2, t3, t4, t5, t6, t7 });
pfc.Synchronize(new IPfcStepNode[] { t0, t1, t2, t3 }, new IPfcStepNode[] { t4, t5, t6, t7 });
testEvaluator.NextExpectedActivations = new IPfcStepNode[] { t0, t1, t2, t3, t4, t5, t6, t7 };
foreach (IPfcNode ilinkable in new IPfcStepNode[] { t0, t1, t2, t3 })
{
Console.WriteLine("Incrementing " + ilinkable.Name + ".");
//ilinkable.Increment();
throw new ApplicationException("PFCs are not currently executable.");
}
testEvaluator.NextExpectedActivations = new IPfcTransitionNode[] { }; // Ensure it's empty and all have fired.
}
}
public static List <IPfcNode> GetNodesOnBroadestNonLoopingPath(ProcedureFunctionChart pfc, bool restoreOldLinkPriorities = true)
{
Dictionary <PfcLink, int?> oldVal = null;
if (restoreOldLinkPriorities)
{
oldVal = new Dictionary <PfcLink, int?>();
pfc.Links.ForEach(n => oldVal.Add((PfcLink)n, ((PfcLink)n).Priority));
}
AssignWeightsForBroadestNonLoopingPath(pfc);
List <IPfcNode> retval = GetNodesOnPriorityPath(pfc);
if (restoreOldLinkPriorities)
{
foreach (PfcLink link in oldVal.Keys)
{
link.Priority = oldVal[link];
}
}
return(retval);
}
/// <summary>
/// Creates pfc execution contexts, one per action under the step that is currently running. Each
/// is given an instance count of zero, as a step can run its action only once, currently.
/// </summary>
/// <param name="parentContext">The parent context, that of the step that is currently running.</param>
/// <param name="kids">The procedure function charts that live in the actions under the step that is currently running.</param>
/// <param name="kidContexts">The pfc execution contexts that will correspond to the running of each of the child PFCs.</param>
protected virtual void CreateChildContexts(PfcExecutionContext parentContext, out IProcedureFunctionChart[] kids, out PfcExecutionContext[] kidContexts)
{
int kidCount = MyStep.Actions.Count;
kids = new ProcedureFunctionChart[kidCount];
kidContexts = new PfcExecutionContext[kidCount];
int i = 0;
foreach (KeyValuePair <string, IProcedureFunctionChart> kvp in MyStep.Actions)
{
IProcedureFunctionChart kid = kvp.Value;
kids[i] = kid;
Guid kidGuid = GuidOps.XOR(parentContext.Guid, kid.Guid);
while (parentContext.Contains(kidGuid))
{
kidGuid = GuidOps.Increment(kidGuid);
}
kidContexts[i] = new PfcExecutionContext(kid, kvp.Key, null, kidGuid, parentContext);
kidContexts[i].InstanceCount = 0;
i++;
}
}
public static ProcedureFunctionChart CreateOffsetParallelPFC()
{
ProcedureFunctionChart pfc = new ProcedureFunctionChart(null, "OffsetParallelPfc");
IPfcStepNode start = pfc.CreateStep("Start", "", Guid.Empty);
IPfcStepNode finish = pfc.CreateStep("Finish", "", Guid.Empty);
char name = 'A';
A = pfc.CreateStep("Step_" + (name++), "", NextGuid());
B = pfc.CreateStep("Step_" + (name++), "", NextGuid());
C = pfc.CreateStep("Step_" + (name++), "", NextGuid());
D = pfc.CreateStep("Step_" + (name++), "", NextGuid());
E = pfc.CreateStep("Step_" + (name++), "", NextGuid());
F = pfc.CreateStep("Step_" + (name++), "", NextGuid());
G = pfc.CreateStep("Step_" + (name++), "", NextGuid());
nA = (IPfcNode)A;
nB = (IPfcNode)B;
nC = (IPfcNode)C;
nD = (IPfcNode)D;
nE = (IPfcNode)E;
nF = (IPfcNode)F;
nG = (IPfcNode)G;
pfc.Bind(start, nA);
pfc.Bind(nA, nB);
pfc.Bind(nB, nE);
pfc.Bind(nE, nF);
pfc.Bind(nF, nG);
pfc.Bind(nG, finish);
pfc.Bind(((PfcTransition)((PfcStep)nA).SuccessorNodes[0]), nC);
pfc.Bind(nC, ((PfcTransition)((PfcStep)nE).SuccessorNodes[0]));
pfc.Bind(((PfcTransition)((PfcStep)nB).SuccessorNodes[0]), nD);
pfc.Bind(nD, ((PfcTransition)((PfcStep)nF).SuccessorNodes[0]));
pfc.UpdateStructure();
return(pfc);
}
private void _TestSimpleLink(PfcElementType inType, PfcElementType outType, string shouldBe)
{
string testName = "Simple link from " + inType.ToString() + " to " + outType.ToString();
Model model = new Model(testName);
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, "SFC 1", "", Guid.NewGuid());
IPfcNode n0, n1;
n0 = CreateNode(pfc, "Alice", inType);
n1 = CreateNode(pfc, "Bob", outType);
pfc.Bind(n0, n1);
string structureString = PfcDiagnostics.GetStructure(pfc);
Console.WriteLine("After a " + testName + ", structure is \r\n" + structureString);
Assert.AreEqual(StripCRLF(structureString), StripCRLF(shouldBe), "Structure should have been\r\n" + shouldBe + "\r\nbut it was\r\n" + structureString + "\r\ninstead.");
if (m_testSerializationToo)
{
_TestSerialization(pfc, shouldBe, testName);
}
}
public static ProcedureFunctionChart CreateTestPfc()
{
ProcedureFunctionChart pfc = new ProcedureFunctionChart(new Highpoint.Sage.SimCore.Model("Test model", Guid.NewGuid()), "SFC 1");
((PfcElementFactory)pfc.ElementFactory).SetRepeatable(Guid.Empty); // Ensures Guids are repeatable.
#region Create Nodes
char name = 'A';
A = pfc.CreateStep("Step_" + (name++), "", NextGuid());
B = pfc.CreateStep("Step_" + (name++), "", NextGuid());
C = pfc.CreateStep("Step_" + (name++), "", NextGuid());
D = pfc.CreateStep("Step_" + (name++), "", NextGuid());
E = pfc.CreateStep("Step_" + (name++), "", NextGuid());
F = pfc.CreateStep("Step_" + (name++), "", NextGuid());
G = pfc.CreateStep("Step_" + (name++), "", NextGuid());
H = pfc.CreateStep("Step_" + (name++), "", NextGuid());
I = pfc.CreateStep("Step_" + (name++), "", NextGuid());
J = pfc.CreateStep("Step_" + (name++), "", NextGuid());
K = pfc.CreateStep("Step_" + (name++), "", NextGuid());
L = pfc.CreateStep("Step_" + (name++), "", NextGuid());
M = pfc.CreateStep("Step_" + (name++), "", NextGuid());
N = pfc.CreateStep("Step_" + (name++), "", NextGuid());
O = pfc.CreateStep("Step_" + (name++), "", NextGuid());
P = pfc.CreateStep("Step_" + (name), "", NextGuid());
nA = (IPfcNode)A;
nB = (IPfcNode)B;
nC = (IPfcNode)C;
nD = (IPfcNode)D;
nE = (IPfcNode)E;
nF = (IPfcNode)F;
nG = (IPfcNode)G;
nH = (IPfcNode)H;
nI = (IPfcNode)I;
nJ = (IPfcNode)J;
nK = (IPfcNode)K;
nL = (IPfcNode)L;
nM = (IPfcNode)M;
nN = (IPfcNode)N;
nO = (IPfcNode)O;
nP = (IPfcNode)P;
#endregion Create Nodes
#region Create Structure
pfc.Bind(nA, nB);
pfc.BindSeriesDivergent(nB, new IPfcNode[] { nC, nF });
pfc.Bind(nC, nD);
pfc.Bind(nD, nE);
pfc.Bind(nF, nG);
pfc.BindParallelDivergent(nG, new IPfcNode[] { nH, nI, nP });
pfc.Bind(nH, nJ);
pfc.Bind(nI, nK);
pfc.BindParallelConvergent(new IPfcNode[] { nJ, nK, nP }, nL);
pfc.Bind(nL, nM);
pfc.BindSeriesConvergent(new IPfcNode[] { nE, nM }, nN);
pfc.Bind(nN, nO);
pfc.Bind(nB, nN);
#endregion Create Structure
pfc.UpdateStructure();
return(pfc);
}
public static ProcedureFunctionChart CreateTestPfc3()
{
ProcedureFunctionChart pfc = new ProcedureFunctionChart(new Highpoint.Sage.SimCore.Model("Test model", Guid.NewGuid()), "SFC 1");
#region Create Nodes
char name = 'A';
A = pfc.CreateStep("Step_" + (name++), "", NextGuid());
B = pfc.CreateStep("Step_" + (name++), "", NextGuid());
C = pfc.CreateStep("Step_" + (name++), "", NextGuid());
D = pfc.CreateStep("Step_" + (name++), "", NextGuid());
E = pfc.CreateStep("Step_" + (name++), "", NextGuid());
F = pfc.CreateStep("Step_" + (name++), "", NextGuid());
G = pfc.CreateStep("Step_" + (name++), "", NextGuid());
H = pfc.CreateStep("Step_" + (name++), "", NextGuid());
I = pfc.CreateStep("Step_" + (name++), "", NextGuid());
J = pfc.CreateStep("Step_" + (name++), "", NextGuid());
K = pfc.CreateStep("Step_" + (name++), "", NextGuid());
L = pfc.CreateStep("Step_" + (name++), "", NextGuid());
nA = (IPfcNode)A;
nB = (IPfcNode)B;
nC = (IPfcNode)C;
nD = (IPfcNode)D;
nE = (IPfcNode)E;
nF = (IPfcNode)F;
nG = (IPfcNode)G;
nH = (IPfcNode)H;
nI = (IPfcNode)I;
nJ = (IPfcNode)J;
nK = (IPfcNode)K;
nL = (IPfcNode)L;
#endregion Create Nodes
#region Create Structure
pfc.BindParallelDivergent(nA, new IPfcNode[] { nB, nC, nD, nE });
pfc.BindParallelDivergent(nB, new IPfcNode[] { nF, nG });
pfc.BindParallelDivergent(nE, new IPfcNode[] { nJ, nK });
pfc.BindParallelConvergent(new IPfcNode[] { nF, nG }, nH);
pfc.BindParallelConvergent(new IPfcNode[] { nC, nD }, nI);
pfc.BindParallelConvergent(new IPfcNode[] { nH, nI, nJ, nK }, nL);
PfcLinkElementList links = new PfcLinkElementList(pfc.Links);
links.Sort(new Comparison <IPfcLinkElement>(delegate(IPfcLinkElement a, IPfcLinkElement b) {
return(Comparer.Default.Compare(a.Name, b.Name));
}));
System.Reflection.BindingFlags bf = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.FlattenHierarchy | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
foreach (IPfcLinkElement link in links)
{
typeof(PfcElement).GetFields(bf);
typeof(PfcElement).GetField("m_guid", bf).SetValue((PfcElement)link, NextGuid()); // Totally cheating.
}
#endregion Create Structure
return(pfc);
}
public static ProcedureFunctionChart CreateRandomPFC(int nSteps, int seed)
{
Guid mask = GuidOps.FromString(string.Format("{0}, {1}", nSteps, seed));
Guid seedGuid = GuidOps.FromString(string.Format("{0}, {1}", seed, nSteps));
int rotate = 3;
GuidGenerator guidGen = new GuidGenerator(seedGuid, mask, rotate);
PfcElementFactory pfcef = new PfcElementFactory(guidGen);
ProcedureFunctionChart pfc = new ProcedureFunctionChart(new Highpoint.Sage.SimCore.Model("Test model", Guid.NewGuid()), "Name", "", guidGen.Next(), pfcef);
IPfcStepNode start = pfc.CreateStep("Start", "", Guid.Empty);
IPfcStepNode step1 = pfc.CreateStep("Step1", "", Guid.Empty);
IPfcStepNode finish = pfc.CreateStep("Finish", "", Guid.Empty);
pfc.Bind(start, step1);
pfc.Bind(step1, finish);
Console.WriteLine("Seed = {0}.", seed);
Random r = new Random(seed);
while (pfc.Steps.Count < nSteps)
{
double steeringValue = r.NextDouble();
if (steeringValue < .5)
{
// Insert a step in series.
IPfcLinkElement link = pfc.Links[r.Next(0, pfc.Links.Count - 1)];
IPfcStepNode stepNode = pfc.CreateStep();
pfc.Bind(link.Predecessor, stepNode);
pfc.Bind(stepNode, link.Successor);
//Console.WriteLine("Inserted {0} between {1} and {2}.", stepNode.Name, link.Predecessor.Name, link.Successor.Name);
link.Detach();
}
else if (steeringValue < .666)
{
// Insert a step in parallel.
for (int i = 0; i < 50; i++) // Try, but give up if don't find suitable step.
{
IPfcStepNode target = pfc.Steps[r.Next(0, pfc.Steps.Count - 1)];
if (target.PredecessorNodes.Count == 1 && target.SuccessorNodes.Count == 1)
{
IPfcStepNode stepNode = pfc.CreateStep();
pfc.Bind(target.PredecessorNodes[0], stepNode);
pfc.Bind(stepNode, target.SuccessorNodes[0]);
//Console.WriteLine("Inserted {0} parallel to {1}.", stepNode.Name, target.Name);
break;
}
}
}
else if (steeringValue < .833)
{
// Insert a branch
for (int i = 0; i < 50; i++) // Try, but give up if don't find suitable step.
{
IPfcStepNode step = pfc.Steps[r.Next(0, pfc.Steps.Count - 1)];
if (step.PredecessorNodes.Count == 1 && step.SuccessorNodes.Count == 1)
{
IPfcStepNode entryStep = pfc.CreateStep(step.Name + "_IN", null, Guid.Empty);
IPfcStepNode exitStep = pfc.CreateStep(step.Name + "_OUT", null, Guid.Empty);
IPfcStepNode leftStep = pfc.CreateStep(step.Name + "_LFT", null, Guid.Empty);
IPfcStepNode rightStep = pfc.CreateStep(step.Name + "_RGT", null, Guid.Empty);
pfc.Bind(step.PredecessorNodes[0], entryStep);
pfc.Bind(entryStep, leftStep);
pfc.Bind(entryStep, rightStep);
pfc.Bind(leftStep, exitStep);
pfc.Bind(rightStep, exitStep);
pfc.Bind(exitStep, step.SuccessorNodes[0]);
pfc.Unbind(step.PredecessorNodes[0], step);
pfc.Unbind(step, step.SuccessorNodes[0]);
//Console.WriteLine("Inserted a branch in place of {0}.", step.Name);
break;
}
}
}
else
{
for (int i = 0; i < 50; i++) // Try, but give up if don't find suitable step.
{
IPfcTransitionNode trans = pfc.Transitions[r.Next(0, pfc.Transitions.Count - 1)];
if (trans.PredecessorNodes.Count == 1 && trans.SuccessorNodes.Count == 1)
{
IPfcStepNode successor = (IPfcStepNode)trans.SuccessorNodes[0];
IPfcStepNode subject = pfc.CreateStep();
pfc.Bind(trans, subject);
pfc.Bind(subject, successor);
pfc.Unbind(trans, successor);
IPfcStepNode loopback = pfc.CreateStep();
pfc.Bind(subject, loopback);
pfc.Bind(loopback, subject);
//Console.WriteLine("Inserted {0} between {1} and {2}, and created a branchback around it using {3}.",
// subject.Name, trans.PredecessorNodes[0].Name, successor.Name, loopback.Name);
break;
}
}
//// insert a loopback
//IPfcStepNode step;
//do { step = pfc.Steps[r.Next(0, pfc.Steps.Count - 1)]; } while (step == start || step == finish);
//IPfcStepNode newNode = pfc.CreateStep();
//pfc.Bind(step, newNode);
//pfc.Bind(newNode, step);
//Console.WriteLine("Inserted a loopback around {0} using new step, {1}.", step.Name, newNode.Name);
}
//IPfcStepNode origin = pfc.Steps[r.Next(0, pfc.Steps.Count - 1)];
//if (origin.Equals(finish)) continue;
//if (r.NextDouble() < .2) {
// IPfcStepNode stepNode = pfc.CreateStep();
// IPfcNode target = origin.SuccessorNodes[r.Next(0, origin.SuccessorNodes.Count - 1)];
// // Insert a step in series.
// pfc.Bind(origin, stepNode);
// pfc.Bind(stepNode, target);
// pfc.Unbind(origin, target);
// Console.WriteLine("Inserting {0} between {1} and {2}.",
// stepNode.Name, origin.Name, target.Name);
//} else if (r.NextDouble() < .55) {
// // Insert a step in parallel
// if (origin.PredecessorNodes.Count == 1 && origin.SuccessorNodes.Count == 1) {
// origin = origin.PredecessorNodes[0];
// target = origin.SuccessorNodes[0];
// pfc.Bind(origin, stepNode);
// pfc.Bind(stepNode, target);
// Console.WriteLine("Inserting {0} parallel to {1} - between {2} and {3}.",
// stepNode.Name, parallelTo.Name, origin.Name, target.Name);
// }
//} else {
// // Insert a loopback or branchforward.
// IPfcNode target = null;
// string parallelType = null;
// if (!origin.PredecessorNodes.Contains(start) && r.NextDouble() < .5) {
// target = origin;
// parallelType = "loopback";
// } else if (origin.SuccessorNodes.Count==1 && origin.PredecessorNodes==1) {
// target = origin.SuccessorNodes[r.Next(0, origin.SuccessorNodes.Count - 1)];
// parallelType = "branch forward";
// }
// if (target != null) {
// IPfcStepNode stepNode = pfc.CreateStep();
// pfc.Bind(origin, stepNode);
// pfc.Bind(stepNode, target);
// Console.WriteLine("Inserting {0} around {1} to {2}, with {3} on the new alternate path.",
// parallelType, origin.Name, target.Name, stepNode.Name);
// }
//}
}
return(pfc);
}
private void _TestComplexLink(LinkSuperType superType, PfcElementType inType, PfcElementType outType, string shouldBe)
{
string testName = superType.ToString() + " from " + inType.ToString() + " to " + outType.ToString();
Model model = new Model(testName);
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, "SFC 1", "", Guid.NewGuid());
IPfcNode n0, n1, n2, n3, n4;
switch (superType)
{
case LinkSuperType.ParallelConvergent:
n0 = CreateNode(pfc, "Alice", inType);
n1 = CreateNode(pfc, "Bob", inType);
n2 = CreateNode(pfc, "Charley", inType);
n3 = CreateNode(pfc, "David", inType);
n4 = CreateNode(pfc, "Edna", outType);
pfc.BindParallelConvergent(new IPfcNode[] { n0, n1, n2, n3 }, n4);
break;
case LinkSuperType.SeriesConvergent:
n0 = CreateNode(pfc, "Alice", inType);
n1 = CreateNode(pfc, "Bob", inType);
n2 = CreateNode(pfc, "Charley", inType);
n3 = CreateNode(pfc, "David", inType);
n4 = CreateNode(pfc, "Edna", outType);
pfc.BindSeriesConvergent(new IPfcNode[] { n0, n1, n2, n3 }, n4);
break;
case LinkSuperType.ParallelDivergent:
n0 = CreateNode(pfc, "Alice", inType);
n1 = CreateNode(pfc, "Bob", outType);
n2 = CreateNode(pfc, "Charley", outType);
n3 = CreateNode(pfc, "David", outType);
n4 = CreateNode(pfc, "Edna", outType);
pfc.BindParallelDivergent(n0, new IPfcNode[] { n1, n2, n3, n4 });
break;
case LinkSuperType.SeriesDivergent:
n0 = CreateNode(pfc, "Alice", inType);
n1 = CreateNode(pfc, "Bob", outType);
n2 = CreateNode(pfc, "Charley", outType);
n3 = CreateNode(pfc, "David", outType);
n4 = CreateNode(pfc, "Edna", outType);
pfc.BindSeriesDivergent(n0, new IPfcNode[] { n1, n2, n3, n4 });
break;
default:
break;
}
string structureString = PfcDiagnostics.GetStructure(pfc);
Console.WriteLine("After a " + testName + ", structure is \r\n" + structureString);
Assert.AreEqual(StripCRLF(structureString), StripCRLF(shouldBe), "Structure should have been\r\n" + shouldBe + "\r\nbut it was\r\n" + structureString + "\r\ninstead.");
if (m_testSerializationToo)
{
_TestSerialization(pfc, shouldBe, testName);
}
}
public void Test_InsertStepIntoLoop()
{
string testName = "PFC with loop gets the loop extended";
/*
* START
* |
* |---- +T1
* | | |
* | STEP1
* | | |
* | T2+ +T3
* ----| |
* FINISH
*
* TO
*
* START
* |
* |---- +T1
* | | |
* | STEP1
* | | |
* | T4+ +T3
* | | |
* | STEP2 FINISH
* | |
* | T2+
* -----
*
*/
IModel model = new Model(testName);
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, testName);
IPfcNode startStep = pfc.CreateStep("START", string.Empty, Guid.NewGuid());
IPfcNode step1 = pfc.CreateStep("STEP1", string.Empty, Guid.NewGuid());
IPfcNode step2 = pfc.CreateStep("STEP2", string.Empty, Guid.NewGuid());
IPfcNode finishStep = pfc.CreateStep("FINISH", string.Empty, Guid.NewGuid());
IPfcNode t1 = pfc.CreateTransition("T1", string.Empty, Guid.NewGuid());
IPfcNode t2 = pfc.CreateTransition("T2", string.Empty, Guid.NewGuid());
IPfcNode t3 = pfc.CreateTransition("T3", string.Empty, Guid.NewGuid());
IPfcNode t4 = pfc.CreateTransition("T4", string.Empty, Guid.NewGuid());
pfc.Bind(startStep, t1);
pfc.Bind(t1, step1);
pfc.Bind(step1, t2);
pfc.Bind(step1, t3);
pfc.Bind(t2, step1);
pfc.Bind(t3, finishStep);
Console.WriteLine(PfcDiagnostics.GetStructure(pfc));
Console.WriteLine();
/* Connect new step (step2) to existing transition (t2) */
pfc.Bind(step2, t2);
/* Connect existing step (step1) to new transition (t3)*/
pfc.Bind(step1, t4);
/* Connect new transition (t3) to new step (step2)*/
pfc.Bind(t4, step2);
/* Unbind existing step (step1) and existing transition (t2) */
pfc.Unbind(step1, t2);
string result = PfcDiagnostics.GetStructure(pfc);
Console.WriteLine(result);
Assert.IsTrue(result.Equals("{START-->[L_000(SFC 1.Root)]-->T1}\r\n{T1-->[L_001(SFC 1.Root)]-->STEP1}\r\n{STEP1-->[L_003(SFC 1.Root)]-->T3}\r\n{T2-->[L_004(SFC 1.Root)]-->STEP1}\r\n{T3-->[L_005(SFC 1.Root)]-->FINISH}\r\n{STEP2-->[L_006(SFC 1.Root)]-->T2}\r\n{STEP1-->[L_007(SFC 1.Root)]-->T4}\r\n{T4-->[L_008(SFC 1.Root)]-->STEP2}\r\n"));
}
public void Test_RemoveStep()
{
string testName = "PFC With Simultaneous Branch";
IModel model = new Model(testName);
/*
* START
* + {T1}
* STEP1
* + (T2)
* STEP2 STEP3
* | + (T3)
* | STEP4
* + (T4)
* STEP5
* + (T5)
* FINISH
*/
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, testName);
IPfcNode startStep = pfc.CreateStep("START", string.Empty, Guid.NewGuid());
IPfcNode step1 = pfc.CreateStep("STEP1", string.Empty, Guid.NewGuid());
IPfcNode step2 = pfc.CreateStep("STEP2", string.Empty, Guid.NewGuid());
IPfcNode step3 = pfc.CreateStep("STEP3", string.Empty, Guid.NewGuid());
IPfcNode step4 = pfc.CreateStep("STEP4", string.Empty, Guid.NewGuid());
IPfcNode step5 = pfc.CreateStep("STEP5", string.Empty, Guid.NewGuid());
IPfcNode finishStep = pfc.CreateStep("FINISH", string.Empty, Guid.NewGuid());
IPfcNode t1 = pfc.CreateTransition("T1", string.Empty, Guid.NewGuid());
IPfcNode t2 = pfc.CreateTransition("T2", string.Empty, Guid.NewGuid());
IPfcNode t3 = pfc.CreateTransition("T3", string.Empty, Guid.NewGuid());
IPfcNode t4 = pfc.CreateTransition("T4", string.Empty, Guid.NewGuid());
IPfcNode t5 = pfc.CreateTransition("T4", string.Empty, Guid.NewGuid());
pfc.Bind(startStep, t1);
pfc.Bind(t1, step1);
pfc.Bind(step1, t2);
pfc.Bind(t2, step2);
pfc.Bind(t2, step3);
pfc.Bind(step2, t4);
pfc.Bind(step3, t3);
pfc.Bind(t3, step4);
pfc.Bind(step4, t4);
pfc.Bind(t4, step5);
pfc.Bind(step5, t5);
pfc.Bind(t5, finishStep);
/* Delete Step4 and T3*/
// Need to delete the predecessor transition
IPfcTransitionNode predecessorTrans = (IPfcTransitionNode)step4.PredecessorNodes[0];
Assert.IsTrue(predecessorTrans.Name == t3.Name, "The predecessor trans should be T3");
IPfcStepNode predecessorStep = (IPfcStepNode)predecessorTrans.PredecessorNodes[0];
Assert.IsTrue(predecessorStep.Name == step3.Name, "The predecessor step should be STEP3");
IPfcTransitionNode successorTrans = (IPfcTransitionNode)step4.SuccessorNodes[0];
Assert.IsTrue(successorTrans.Name == t4.Name, "The successor trans should be T4");
// Connect the predecessor step to the successor transition
pfc.Bind(predecessorStep, successorTrans);
// Unbind the existing path from the predecessor step to the successor transition
pfc.Unbind(predecessorStep, predecessorTrans);
pfc.Unbind(predecessorTrans, step4);
pfc.Unbind(step4, successorTrans);
// Delete the predecessor transition
pfc.Delete(predecessorTrans);
// Delete step
pfc.Delete(step4);
Assert.IsTrue(pfc.Transitions[t3.Name] == null, "T3 Should be Deleted");
Assert.IsTrue(pfc.Steps[step4.Name] == null, "Step4 Should be Deleted");
}
public static ProcedureFunctionChart CreateStandardPFC(int number)
{
ProcedureFunctionChart pfc = null;
switch (number)
{
case 2:
pfc = CreateTestPfc();
break;
case 3:
pfc = CreateTestPfc2();
break;
case 4:
pfc = CreateTestPfc3();
break;
case 5:
pfc = CreateTestPfc4();
break;
case 6: // A Flip-flop PFC.
pfc = CreateTestPfc5();
break;
case 82:
pfc = CreateRandomPFC(8, 1076501454);
break;
case 83:
pfc = CreateRandomPFC(15, 1443487589);
break;
case 84:
pfc = CreateRandomPFC(15, 919145039);
break;
case 85:
pfc = CreateRandomPFC(15, 1915039786);
break;
case 86:
pfc = CreateRandomPFC(14, 1576245265);
break;
case 87:
pfc = CreateRandomPFC(14, 1359939537);
break;
case 88:
pfc = CreateRandomPFC(12, 3666920);
break;
case 89:
pfc = CreateRandomPFC(12, 1688960816);
break;
case 90:
pfc = CreateRandomPFC(12, 1444166439);
break;
case 91:
pfc = CreateRandomPFC(12, 84258233);
break;
case 92:
pfc = CreateRandomPFC(7, 1174395592);
break;
case 93:
pfc = CreateRandomPFC(7, 1479576831);
break;
case 94:
pfc = CreateRandomPFC(7, 1514213606);
break;
case 95:
pfc = CreateRandomPFC(7, 953319173);
break;
case 96:
pfc = CreateRandomPFC(7, 376952253);
break;
case 97:
pfc = CreateRandomPFC(7, 1020353150);
break;
case 98:
pfc = CreateRandomPFC(7, 585340845);
break;
default:
break;
}
return(pfc);
}
/// <summary>
/// Returns the actions under this Step as a procedure function chart.
/// </summary>
/// <returns>A procedure function chart containing the actions under this Step.</returns>
public ProcedureFunctionChart ToProcedureFunctionChart()
{
return(ProcedureFunctionChart.CreateFromStep(this, false));
}
/// <summary>
/// Gets the nodes on the already-established priority path. At a branch, the link with the highest priority
/// is followed.
/// </summary>
/// <param name="pfc">The PFC.</param>
/// <returns></returns>
public static List <IPfcNode> GetNodesOnPriorityPath(ProcedureFunctionChart pfc)
{
// Do a breadth-first traversal, determining the sequence of operation steps executed in each unit.
List <IPfcNode> sequence = new List <IPfcNode>();
Queue <IPfcNode> working = new Queue <IPfcNode>();
pfc.Nodes.ForEach(n => n.NodeColor = NodeColor.White);
IPfcNode starter = pfc.GetStartSteps()[0];
starter.NodeColor = NodeColor.Gray;
working.Enqueue(starter);
IPfcNode current;
while (working.Count() > 0)
{
current = working.Dequeue();
if (s_diagnostics)
{
Console.WriteLine("Dequeueing {0}, leaving {1} elements in queue.", current.Name, working.Count());
}
Debug.Assert(current.NodeColor == NodeColor.Gray);
if (current.Successors.Count() == 0)
{
current.NodeColor = NodeColor.Black; // It's the last one.
sequence.Add(current);
if (s_diagnostics)
{
Console.WriteLine("\tIt's the last one in the queue.");
}
}
else
{
// If it's a step node, then it's a pass-in, or it's a serial convergence.
// Either way, we only need one predecessor to be black. And it will be.
if (current is IPfcStepNode || current.PredecessorNodes.TrueForAll(n => n.NodeColor == NodeColor.Black))
{
if (s_diagnostics)
{
Console.WriteLine("\tAdvancing.");
}
current.NodeColor = NodeColor.Black;
// We can advance.
if (current.SuccessorNodes.Count() == 1 || current is IPfcTransitionNode)
{
// Single follower, or parallel divergence, all successors are enqueued.
foreach (IPfcNode next in current.SuccessorNodes)
{
if (next.NodeColor == NodeColor.White)
{
next.NodeColor = NodeColor.Gray;
if (s_diagnostics)
{
Console.WriteLine("\t\tEnqueueing {0}.", next.Name);
}
working.Enqueue(next);
}
}
}
else // Serial divergence - enqueue only the highest priority node.
{
IPfcNode next = current.Successors.OrderByDescending(n => n.Priority).First().Successor;
if (next.NodeColor == NodeColor.White)
{
next.NodeColor = NodeColor.Gray;
if (s_diagnostics)
{
Console.WriteLine("\t\tEnqueueing {0}.", next.Name);
}
working.Enqueue(next);
}
//System.Diagnostics.Debug.Assert(next.SuccessorNodes.Count() < 2); // Duality violation, if not.
}
current.NodeColor = NodeColor.Black;
if (s_diagnostics)
{
Console.WriteLine("\t->Logging execution of {0}.", current.Name);
}
sequence.Add(current);
}
else
{
working.Enqueue(current); // All preds are not black. Must try again later.
}
}
}
return(sequence);
}
private IProcedureFunctionChart CreateRecipePfc(IModel model, string pfcName, double minutesPerTask, ExecutionEngineConfiguration eec)
{
// Start
// |
// +T1 ----
// | | |
// ------- |
// | |
// Step1 |
// | |
// +T2 |
// | |
// Step2 |
// | |
// ------- |
// T3+ +T4 |
// | |---
// Finish
// |
// T5+
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, pfcName);
pfc.ExecutionEngineConfiguration = eec;
pfc.CreateStep("Start", "", Guid.NewGuid());
pfc.CreateStep("Step1", "", Guid.NewGuid());
pfc.CreateStep("Step2", "", Guid.NewGuid());
pfc.CreateStep("Finish", "", Guid.NewGuid());
pfc.CreateTransition("T1", "", Guid.NewGuid());
pfc.CreateTransition("T2", "", Guid.NewGuid());
pfc.CreateTransition("T3", "", Guid.NewGuid());
pfc.CreateTransition("T4", "", Guid.NewGuid());
pfc.CreateTransition("T5", "", Guid.NewGuid());
pfc.Bind(pfc.Nodes["Start"], pfc.Nodes["T1"]);
pfc.Bind(pfc.Nodes["T1"], pfc.Nodes["Step1"]);
pfc.Bind(pfc.Nodes["Step1"], pfc.Nodes["T2"]);
pfc.Bind(pfc.Nodes["T2"], pfc.Nodes["Step2"]);
pfc.Bind(pfc.Nodes["Step2"], pfc.Nodes["T3"]);
pfc.Bind(pfc.Nodes["Step2"], pfc.Nodes["T4"]);
pfc.Bind(pfc.Nodes["T4"], pfc.Nodes["Step1"]);
pfc.Bind(pfc.Nodes["T3"], pfc.Nodes["Finish"]);
pfc.Bind(pfc.Nodes["Finish"], pfc.Nodes["T5"]);
pfc.Steps.ForEach(delegate(IPfcStepNode psn) {
psn.LeafLevelAction = new PfcAction(delegate(PfcExecutionContext pfcec, StepStateMachine ssm) {
StringBuilder sb = (StringBuilder)pfcec["StringBuilder"];
string stepName = pfc.Name + "." + psn.Name;
IExecutive exec = psn.Model.Executive;
sb.AppendLine(string.Format("{0} : {1} is running its intrinsic action.", exec.Now, stepName));
exec.CurrentEventController.SuspendUntil(exec.Now + TimeSpan.FromMinutes(minutesPerTask));
});
});
pfc.Transitions["T1"].ExpressionExecutable
= new Highpoint.Sage.Graphs.PFC.Execution.ExecutableCondition(
delegate(object userData, Highpoint.Sage.Graphs.PFC.Execution.TransitionStateMachine tsm) {
IDictionary graphContext = userData as IDictionary;
string countKey = pfc.Guid.ToString() + ".Count";
if (!((IDictionary)graphContext).Contains(countKey))
{
((IDictionary)graphContext).Add(countKey, 1);
}
else
{
graphContext[countKey] = 1;
}
return(DEFAULT_EXECUTABLE_EXPRESSION(graphContext, tsm));
});
pfc.Transitions["T3"].ExpressionExecutable
= new Highpoint.Sage.Graphs.PFC.Execution.ExecutableCondition(
delegate(object userData, Highpoint.Sage.Graphs.PFC.Execution.TransitionStateMachine tsm) {
IDictionary graphContext = userData as IDictionary;
string countKey = pfc.Guid.ToString() + ".Count";
return(DEFAULT_EXECUTABLE_EXPRESSION(graphContext, tsm) && (((int)graphContext[countKey]) > 5));
});
pfc.Transitions["T4"].ExpressionExecutable
= new Highpoint.Sage.Graphs.PFC.Execution.ExecutableCondition(
delegate(object userData, Highpoint.Sage.Graphs.PFC.Execution.TransitionStateMachine tsm) {
IDictionary graphContext = userData as IDictionary;
string countKey = pfc.Guid.ToString() + ".Count";
if ((DEFAULT_EXECUTABLE_EXPRESSION(graphContext, tsm) && (((int)graphContext[countKey]) <= 5)))
{
graphContext[countKey] = ((int)graphContext[countKey]) + 1;
return(true);
}
else
{
return(false);
}
});
pfc.UpdateStructure();
return(pfc);
}
/// <summary>
/// Refreshes the Participant Directory to contain only the ExpressionElements in the specified PFC.
/// Performed via a Mark-and-Sweep algorithm.
/// </summary>
/// <param name="pfc">The PFC.</param>
internal void Refresh(ProcedureFunctionChart pfc)
{
foreach (ExpressionElement ee in m_nameMap.Values)
{
ee.Marked = false;
_Debug.Assert(m_guidMap.ContainsValue(ee));
}
foreach (ExpressionElement ee in m_guidMap.Values)
{
_Debug.Assert(ee.Marked == false);
_Debug.Assert(m_nameMap.ContainsValue(ee));
}
foreach (IPfcNode node in pfc.Steps)
{
if (m_nameMap.ContainsKey(node.Name))
{
m_nameMap[node.Name].Marked = true;
}
}
// PCB20080725: Was this. Changed to the following, to key on name.
//foreach (IPfcTransitionNode trans in pfc.Transitions) {
// foreach (ExpressionElement ee in trans.Expression.Elements) {
// ee.Marked = true;
// }
//}
foreach (IPfcTransitionNode trans in pfc.Transitions)
{
foreach (ExpressionElement ee in trans.Expression.Elements)
{
if (ee is Macro)
{
m_nameMap[ee.Name.Trim('\'')].Marked = true;
}
else if (ee.Name != string.Empty)
{
m_nameMap[ee.Name].Marked = true;
}
}
}
List <ExpressionElement> rejects = new List <ExpressionElement>();
foreach (ExpressionElement ee in m_nameMap.Values)
{
if (!ee.Marked)
{
rejects.Add(ee);
}
ee.Marked = false;
}
foreach (ExpressionElement ee in rejects)
{
m_nameMap.Remove(ee.Name);
m_guidMap.Remove(ee.Guid);
}
}
/// <summary>
/// Returns the actions under this Step as a procedure function chart.
/// </summary>
/// <param name="autoFlatten">if set to <c>true</c>, flattens each PFC under this step and its actions and their steps' actions.</param>
/// <returns>A procedure function chart containing the actions under this Step.</returns>
public ProcedureFunctionChart ToProcedureFunctionChart(bool autoFlatten)
{
return(ProcedureFunctionChart.CreateFromStep(this, autoFlatten));
}
public void TestSequencers()
{
Model model = new Model("MyTestModel");
ProcedureFunctionChart pfc = new ProcedureFunctionChart(model, "RootPfc");
pfc.ExecutionEngineConfiguration = new ExecutionEngineConfiguration();
// Start
// |
// + T_Start
// |
// =====================================
// | | | | |
// Step0 Step1 Step2 Step3 Step4
// | | | | |
// =====================================
// |
// + Finis
//
// (We want to run these in order "Step3", "Step1", "Step4", "Step2", "Step0")
#region Create PFC
IPfcStepNode start = pfc.CreateStep("Start", null, Guid.NewGuid());
IPfcTransitionNode startTrans = pfc.CreateTransition("T_Start", null, Guid.NewGuid());
pfc.Bind(start, startTrans);
IPfcTransitionNode finis = pfc.CreateTransition("Finish", null, Guid.NewGuid());
for (int i = 0; i < 5; i++)
{
IPfcStepNode step = pfc.CreateStep("Step" + i, null, Guid.NewGuid());
pfc.Bind(startTrans, step);
pfc.Bind(step, finis);
}
#endregion Create PFC
Guid sequencerKey = Guid.NewGuid();
string[] stepSeq = new string[] { "Step4", "Step3", "Step2", "Step1", "Step0" };
for (int n = 0; n < 10; n++)
{
Console.WriteLine("\r\n\r\n========================================================\r\nStarting test iteration # " + n + ":\r\n");
stepSeq = Shuffle(stepSeq);
Console.WriteLine("Expecting sequence " + StringOperations.ToCommasAndAndedList(new List <string>(stepSeq)));
int j = 0;
StringBuilder sb = new StringBuilder();
foreach (string stepNodeName in stepSeq)
{
IPfcStepNode step = pfc.Steps[stepNodeName];
step.Precondition = new Sequencer(sequencerKey, j++).Precondition;
step.LeafLevelAction = new PfcAction(delegate(PfcExecutionContext pfcec, StepStateMachine ssm) { sb.Append("Running " + ssm.MyStep.Name + " "); });
}
model.Executive.RequestEvent(
new ExecEventReceiver(pfc.Run),
DateTime.MinValue,
0.0,
new PfcExecutionContext(pfc, "PFCEC", null, Guid.NewGuid(), null), ExecEventType.Detachable);
pfc.Model.Start();
Console.Out.Flush();
string tgtString = string.Format(@"Running {0} Running {1} Running {2} Running {3} Running {4} ",
stepSeq[0], stepSeq[1], stepSeq[2], stepSeq[3], stepSeq[4]);
System.Diagnostics.Debug.Assert(sb.ToString().Equals(tgtString));
pfc.Model.Executive.Reset();
Console.WriteLine("========================================================");
}
}