public void MakeHardDependencyMatrixFromSuccessorMatrix() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(hardCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); SuccessorMatrix successorMatrix = new SuccessorMatrix(wlog); //Act DependencyMatrix dependencyMatrix = new DependencyMatrix(successorMatrix); //Assert Assert.AreEqual(successorMatrix.Activities.Count, dependencyMatrix.L1LDependencyMatrix.Length); //Each dependency is in range <-1, 1> foreach (var dependency in dependencyMatrix.DirectDependencyMatrix) { Assert.IsTrue(dependency >= -1 && dependency <= 1); } Assert.IsTrue(dependencyMatrix.L1LDependencyMatrix[0] > 0.9 && dependencyMatrix.L1LDependencyMatrix[0] < 1); //Check L2L dependency on BCB and CBC Assert.IsTrue(dependencyMatrix.L2LDependencyMatrix[1, 2] > 0.9 && dependencyMatrix.L2LDependencyMatrix[1, 2] < 1); Assert.IsTrue(dependencyMatrix.L2LDependencyMatrix[2, 1] > 0.9 && dependencyMatrix.L2LDependencyMatrix[2, 1] < 1); }
/// <summary> /// Find long distance dependencies /// </summary> /// <param name="successorMatrix">Successor matrix</param> private void FindLongDistance(SuccessorMatrix successorMatrix) { for (var i = 0; i < Activities.Count; i++) { for (var j = 0; j < Activities.Count; j++) { // A >>>w B //var longDistanceValue = Convert.ToDouble(successorMatrix.LongDistanceMatrix[i, j]) / (successorMatrix.ActivityOccurrences[i] + 1); var longDistanceValue = Convert.ToDouble(2 * successorMatrix.LongDistanceMatrix[i, j]) / (successorMatrix.ActivityOccurrences[i] + successorMatrix.ActivityOccurrences[j] + 1) - Convert.ToDouble(2 * Math.Abs(successorMatrix.ActivityOccurrences[i] - successorMatrix.ActivityOccurrences[j])) / (successorMatrix.ActivityOccurrences[i] + successorMatrix.ActivityOccurrences[j] + 1); if (longDistanceValue >= Settings.LongDistanceThreshold) { var startActivity = successorMatrix.ActivityIndices[successorMatrix.StartActivities.First()]; var endActivity = successorMatrix.ActivityIndices[successorMatrix.EndActivities.First()]; if (PathExists(startActivity, endActivity, i) && PathExists(startActivity, endActivity, j) && PathExists(i, endActivity, j)) { LongDependencies.Add(new Tuple <int, int>(i, j)); } } } } }
public void MakeDependencyMatrixFromSuccessorMatrix() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(heuristicCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); SuccessorMatrix successorMatrix = new SuccessorMatrix(wlog); // Act DependencyMatrix dependencyMatrix = new DependencyMatrix(successorMatrix); // Assert Assert.AreEqual(successorMatrix.Activities.Count, dependencyMatrix.L1LDependencyMatrix.Length); for (int i = 0; i < 4; i++) { Assert.IsTrue(dependencyMatrix.L1LDependencyMatrix[i] == 0); } //1 self loop with dependency 0.8 Assert.IsTrue(dependencyMatrix.L1LDependencyMatrix[4] == 0.8); foreach (var dependency in dependencyMatrix.L2LDependencyMatrix) { Assert.IsTrue(dependency == 0); } //Each dependency is in range <-1, 1> foreach (var dependency in dependencyMatrix.DirectDependencyMatrix) { Assert.IsTrue(dependency >= -1 && dependency <= 1); } }
public void MakeSuccessorMatrixFromHardEventLogTest() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(hardCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var expectedSuccessor = MakeExpectedHardSuccessorMatrix(); var expectedL2L = MakeExpectedHardL2LMatrix(); var expectedLong = MakeExpectedLongDistance(); //Act SuccessorMatrix successorMatrix = new SuccessorMatrix(wlog); Assert.AreEqual(expectedSuccessor.GetLength(0), successorMatrix.Activities.Count); CollectionAssert.AreEqual(expectedSuccessor, successorMatrix.DirectMatrix); CollectionAssert.AreEqual(expectedL2L, successorMatrix.L2LMatrix); CollectionAssert.AreEqual(new int[] { 129, 130, 130, 57, 100, 57, 100, 43, 43 }, successorMatrix.ActivityOccurrences); CollectionAssert.AreEqual(expectedLong, successorMatrix.LongDistanceMatrix); Assert.AreEqual(1, successorMatrix.StartActivities.Count); Assert.AreEqual(1, successorMatrix.EndActivities.Count); Assert.AreEqual("a", successorMatrix.StartActivities.First()); Assert.AreEqual("i", successorMatrix.EndActivities.First()); }
/// <param name="successorMatrix">Successor matrix</param> public DependencyMatrix(SuccessorMatrix successorMatrix) { DirectDependencyMatrix = new double[successorMatrix.Activities.Count, successorMatrix.Activities.Count]; L2LDependencyMatrix = new double[successorMatrix.Activities.Count, successorMatrix.Activities.Count]; L1LDependencyMatrix = new double[successorMatrix.Activities.Count]; ComputeDependencyMatrix(successorMatrix); ComputeL2LDependencyMatrix(successorMatrix); }
public void SimpleDependencyGraphWithL1LLoop() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(heuristicCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var successorMatrix = new SuccessorMatrix(wlog); // Act HeuristicMinerSettings settings = new HeuristicMinerSettings { L1LThreshold = 0.7 }; DependencyGraph dependencyGraph = new DependencyGraph(successorMatrix, settings); // Assert Assert.AreEqual(successorMatrix.Activities.Count, dependencyGraph.Activities.Count); var start = successorMatrix.ActivityIndices[successorMatrix.StartActivities.First()]; var end = successorMatrix.ActivityIndices[successorMatrix.EndActivities.First()]; Assert.AreEqual(start, dependencyGraph.StartActivity); Assert.AreEqual(end, dependencyGraph.EndActivity); Assert.IsTrue(dependencyGraph.LongDependencies.Count == 0); //NO INPUT FOR START ACT Assert.IsTrue(dependencyGraph.InputActivities[start].Count == 0); //NO OUTPUT FOR END ACT Assert.IsTrue(dependencyGraph.OutputActivities[end].Count == 0); //ARCS CORRECT IN Assert.IsTrue(dependencyGraph.InputActivities[1].SetEquals(new HashSet <int> { 2, 3, 4 })); Assert.IsTrue(dependencyGraph.InputActivities[2].SetEquals(new HashSet <int> { 0 })); Assert.IsTrue(dependencyGraph.InputActivities[3].SetEquals(new HashSet <int> { 0 })); //SELF LOOP Assert.IsTrue(dependencyGraph.InputActivities[4].SetEquals(new HashSet <int> { 0, 4 })); //ARCS CORRECT OUT Assert.IsTrue(dependencyGraph.OutputActivities[0].SetEquals(new HashSet <int> { 2, 3, 4 })); Assert.IsTrue(dependencyGraph.OutputActivities[2].SetEquals(new HashSet <int> { 1 })); Assert.IsTrue(dependencyGraph.OutputActivities[3].SetEquals(new HashSet <int> { 1 })); //SELF LOOP Assert.IsTrue(dependencyGraph.OutputActivities[4].SetEquals(new HashSet <int> { 1, 4 })); }
/// <param name="successorMatrix">Direct succession matrix</param> /// <param name="heuristicsMinerSettings">Heuristic miner settings</param> public DependencyGraph(SuccessorMatrix successorMatrix, HeuristicMinerSettings heuristicsMinerSettings) { Activities = successorMatrix.Activities; ActivityIndices = successorMatrix.ActivityIndices; StartActivity = successorMatrix.ActivityIndices[successorMatrix.StartActivities.First()]; EndActivity = successorMatrix.ActivityIndices[successorMatrix.EndActivities.First()]; var dependencyMatrix = new DependencyMatrix(successorMatrix); Settings = heuristicsMinerSettings; CreateDependencyGraph(successorMatrix, dependencyMatrix); }
/// <param name="workflowLog">Workflow log</param> /// <param name="heuristicsMinerSettings">Heuristic miner settings</param> public CNet(WorkflowLog workflowLog, HeuristicMinerSettings heuristicsMinerSettings) { var successorMatrix = new SuccessorMatrix(workflowLog); var dependencyGraph = new DependencyGraph(successorMatrix, heuristicsMinerSettings); IndexToActivity = dependencyGraph.Activities; ActivityIndices = dependencyGraph.ActivityIndices; FillActivities(successorMatrix); PrepareBindings(dependencyGraph); FindBindings(dependencyGraph, workflowLog); }
/// <summary> /// Fill Activities based on successor matrix /// </summary> /// <param name="successorMatrix">Successor Matrix</param> private void FillActivities(SuccessorMatrix successorMatrix) { var startAct = successorMatrix.StartActivities.First(); var endAct = successorMatrix.EndActivities.First(); for (int i = 0; i < successorMatrix.ActivityOccurrences.Length; i++) { var freq = successorMatrix.ActivityOccurrences[i]; Activities.Add(new CPlace(i, freq)); } StartActivity = Activities[successorMatrix.ActivityIndices[startAct]]; EndActivity = Activities[successorMatrix.ActivityIndices[endAct]]; }
/// <summary> /// Compute length 2 loops dependency matrix /// </summary> /// <param name="successorMatrix">Successor matrix</param> private void ComputeL2LDependencyMatrix(SuccessorMatrix successorMatrix) { for (var i = 0; i < L2LDependencyMatrix.GetLength(0); i++) { for (var j = 0; j < L2LDependencyMatrix.GetLength(0); j++) { if (successorMatrix.L2LMatrix[i, j] > 0) { L2LDependencyMatrix[i, j] = Convert.ToDouble(successorMatrix.L2LMatrix[i, j] + successorMatrix.L2LMatrix[j, i]) / (successorMatrix.L2LMatrix[i, j] + successorMatrix.L2LMatrix[j, i] + 1); } } } }
public void MakeCNetEasyCustomSettings() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(heuristicCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var successorMatrix = new SuccessorMatrix(wlog); // Act HeuristicMinerSettings settings = new HeuristicMinerSettings { DependencyThreshold = 0.7, RelativeToBestThreshold = 0.15, L1LThreshold = 0.7 }; CNet causalNet = HeuristicMiner.MineCNet(wlog, settings); // Assert Assert.AreEqual(0, causalNet.StartActivity.Id); Assert.AreEqual(1, causalNet.EndActivity.Id); //ACTIVITY OCCURRENCE Assert.AreEqual(5, causalNet.Activities.Count); Assert.AreEqual(40, causalNet.Activities[0].Frequency); Assert.AreEqual(40, causalNet.Activities[1].Frequency); Assert.AreEqual(21, causalNet.Activities[2].Frequency); Assert.AreEqual(21, causalNet.Activities[3].Frequency); Assert.AreEqual(17, causalNet.Activities[4].Frequency); //Number of bindings Assert.AreEqual(0, causalNet.InputBindings[0].Count); //NEW ARC A->C Assert.AreEqual(5, causalNet.InputBindings[1].Count); Assert.AreEqual(1, causalNet.InputBindings[2].Count); Assert.AreEqual(1, causalNet.InputBindings[3].Count); //NEW ARC D->D Assert.AreEqual(2, causalNet.InputBindings[4].Count); //NEW ARC A->C Assert.AreEqual(5, causalNet.OutputBindings[0].Count); Assert.AreEqual(0, causalNet.OutputBindings[1].Count); Assert.AreEqual(1, causalNet.OutputBindings[2].Count); Assert.AreEqual(1, causalNet.OutputBindings[3].Count); //NEW ARC D->D Assert.AreEqual(2, causalNet.OutputBindings[4].Count); //A&B BIND FREQUENCY Assert.AreEqual(20, causalNet.OutputBindings[0].First(u => u.Activities.Count == 2).Frequency); Assert.AreEqual(20, causalNet.InputBindings[1].First(b => b.Activities.Count == 2).Frequency); }
/// <summary> /// Creates dependency graph based on the direct succession matrix and the dependency matrix /// </summary> /// <param name="successorMatrix">Direct succession matrix</param> /// <param name="dependencyMatrix">Dependency matrix</param> private void CreateDependencyGraph(SuccessorMatrix successorMatrix, DependencyMatrix dependencyMatrix) { //1. Unnecessary (We store activities in SuccessorMatrix) //2. Length 1 loops var l1L = FindL1Loops(dependencyMatrix); //3. Length 2 loops var l2L = FindL2Loops(dependencyMatrix); HashSet <Tuple <int, int> > strongFollowers = new HashSet <Tuple <int, int> >(); HashSet <Tuple <int, int> > strongCauses = new HashSet <Tuple <int, int> >(); if (Settings.AllTasksConnected) { //4. Each Task; the strongest follower strongFollowers = EachTaskStrongestFollower(dependencyMatrix); //5. Each Task; the strongest cause strongCauses = EachTaskStrongestCause(dependencyMatrix); //6. & 7. Find and remove weak outgoing connections for L2L RemoveWeak(dependencyMatrix, strongFollowers, l2L, false); //8. & 9. Find and remove weak incoming connections for L2L RemoveWeak(dependencyMatrix, strongCauses, l2L, true); } //10. Find extra accepted in & out connections var followers = FindExtra(strongFollowers, dependencyMatrix, false); var causes = FindExtra(strongCauses, dependencyMatrix, true); //12. Combine Hash-sets l1L.UnionWith(l2L); l1L.UnionWith(followers); l1L.UnionWith(causes); CreateGraph(l1L); if (Settings.UseLongDistance) { FindLongDistance(successorMatrix); } }
public void MakeCNetEasyDefaultSettings() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(heuristicCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var successorMatrix = new SuccessorMatrix(wlog); // Act CNet causalNet = HeuristicMiner.MineCNet(wlog); // Assert Assert.AreEqual(0, causalNet.StartActivity.Id); Assert.AreEqual(1, causalNet.EndActivity.Id); //ACTIVITY OCCURRENCE Assert.AreEqual(5, causalNet.Activities.Count); Assert.AreEqual(40, causalNet.Activities[0].Frequency); Assert.AreEqual(40, causalNet.Activities[1].Frequency); Assert.AreEqual(21, causalNet.Activities[2].Frequency); Assert.AreEqual(21, causalNet.Activities[3].Frequency); Assert.AreEqual(17, causalNet.Activities[4].Frequency); //Number of bindings Assert.AreEqual(0, causalNet.InputBindings[0].Count); Assert.AreEqual(4, causalNet.InputBindings[1].Count); Assert.AreEqual(1, causalNet.InputBindings[2].Count); Assert.AreEqual(1, causalNet.InputBindings[3].Count); Assert.AreEqual(1, causalNet.InputBindings[4].Count); Assert.AreEqual(4, causalNet.OutputBindings[0].Count); Assert.AreEqual(0, causalNet.OutputBindings[1].Count); Assert.AreEqual(1, causalNet.OutputBindings[2].Count); Assert.AreEqual(1, causalNet.OutputBindings[3].Count); Assert.AreEqual(1, causalNet.OutputBindings[4].Count); //A&B BIND FREQUENCY Assert.AreEqual(20, causalNet.OutputBindings[0].First(u => u.Activities.Count == 2).Frequency); Assert.AreEqual(20, causalNet.InputBindings[1].First(b => b.Activities.Count == 2).Frequency); }
/// <summary> /// Compute direct dependency matrix and length 1 loops dependency matrix /// </summary> /// <param name="successorMatrix">Successor matrix</param> private void ComputeDependencyMatrix(SuccessorMatrix successorMatrix) { for (var i = 0; i < DirectDependencyMatrix.GetLength(0); i++) { for (var j = 0; j < DirectDependencyMatrix.GetLength(0); j++) { if (i == j) { L1LDependencyMatrix[i] = Convert.ToDouble(successorMatrix.DirectMatrix[i, j]) / (successorMatrix.DirectMatrix[i, j] + 1); } else if (j < i) // The lower triangular matrix is the negative compliment of the upper one. { DirectDependencyMatrix[i, j] = -DirectDependencyMatrix[j, i]; } else { DirectDependencyMatrix[i, j] = Convert.ToDouble(successorMatrix.DirectMatrix[i, j] - successorMatrix.DirectMatrix[j, i]) / (successorMatrix.DirectMatrix[i, j] + successorMatrix.DirectMatrix[j, i] + 1); } } } }
public void MakeSuccessorMatrixFromEventLogTest() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(heuristicCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var expectedSuccessor = MakeExpectedSuccessorMatrix(); // Act SuccessorMatrix successorMatrix = new SuccessorMatrix(wlog); // Assert Assert.AreEqual(expectedSuccessor.GetLength(1), successorMatrix.Activities.Count); CollectionAssert.AreEqual(expectedSuccessor, successorMatrix.DirectMatrix); CollectionAssert.AreEqual(new int[5, 5], successorMatrix.L2LMatrix); CollectionAssert.AreEqual(new int[] { 40, 40, 21, 21, 17 }, successorMatrix.ActivityOccurrences); Assert.AreEqual(1, successorMatrix.StartActivities.Count); Assert.AreEqual(1, successorMatrix.EndActivities.Count); Assert.AreEqual("a", successorMatrix.StartActivities.First()); Assert.AreEqual("e", successorMatrix.EndActivities.First()); }
public void HardDependencyGraphDefaultSettings() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(hardCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var successorMatrix = new SuccessorMatrix(wlog); // Act DependencyGraph dependencyGraph = new DependencyGraph(successorMatrix); // Assert Assert.AreEqual(successorMatrix.Activities.Count, dependencyGraph.Activities.Count); var start = successorMatrix.ActivityIndices[successorMatrix.StartActivities.First()]; var end = successorMatrix.ActivityIndices[successorMatrix.EndActivities.First()]; Assert.AreEqual(start, dependencyGraph.StartActivity); Assert.AreEqual(end, dependencyGraph.EndActivity); Assert.IsTrue(dependencyGraph.LongDependencies.Count == 0); //1 IN ARC TO START ACT (SELF LOOP) Assert.IsTrue(dependencyGraph.InputActivities[start].Count == 1); //NO OUTPUT FOR END ACT Assert.IsTrue(dependencyGraph.OutputActivities[end].Count == 0); //IN Assert.IsTrue(dependencyGraph.InputActivities[1].SetEquals(new HashSet <int> { 0, 2 })); Assert.IsTrue(dependencyGraph.InputActivities[2].SetEquals(new HashSet <int> { 1 })); Assert.IsTrue(dependencyGraph.InputActivities[3].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.InputActivities[4].SetEquals(new HashSet <int> { 3, 7 })); Assert.IsTrue(dependencyGraph.InputActivities[5].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.InputActivities[6].SetEquals(new HashSet <int> { 5, 8 })); Assert.IsTrue(dependencyGraph.InputActivities[7].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.InputActivities[8].SetEquals(new HashSet <int> { 4 })); //OUT Assert.IsTrue(dependencyGraph.OutputActivities[0].SetEquals(new HashSet <int> { 0, 1 })); Assert.IsTrue(dependencyGraph.OutputActivities[1].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.OutputActivities[2].SetEquals(new HashSet <int> { 1, 7, 3 })); Assert.IsTrue(dependencyGraph.OutputActivities[3].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.OutputActivities[4].SetEquals(new HashSet <int> { 5, 8 })); Assert.IsTrue(dependencyGraph.OutputActivities[5].SetEquals(new HashSet <int> { 6 })); Assert.IsTrue(dependencyGraph.OutputActivities[7].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.OutputActivities[8].SetEquals(new HashSet <int> { 6 })); }
public void HardDependencyGraphNoL1L() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(hardCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var successorMatrix = new SuccessorMatrix(wlog); // Act HeuristicMinerSettings settings = new HeuristicMinerSettings { L1LThreshold = 1 }; DependencyGraph dependencyGraph = new DependencyGraph(successorMatrix, settings); // Assert Assert.AreEqual(successorMatrix.Activities.Count, dependencyGraph.Activities.Count); var start = successorMatrix.ActivityIndices[successorMatrix.StartActivities.First()]; var end = successorMatrix.ActivityIndices[successorMatrix.EndActivities.First()]; Assert.AreEqual(start, dependencyGraph.StartActivity); Assert.AreEqual(end, dependencyGraph.EndActivity); //1 NO SELF LOOP => 0 Assert.AreEqual(0, dependencyGraph.InputActivities[start].Count); //NO OUTPUT FOR END ACT Assert.AreEqual(0, dependencyGraph.OutputActivities[end].Count); //IN Assert.IsTrue(dependencyGraph.InputActivities[1].SetEquals(new HashSet <int> { 0, 2 })); Assert.IsTrue(dependencyGraph.InputActivities[2].SetEquals(new HashSet <int> { 1 })); Assert.IsTrue(dependencyGraph.InputActivities[3].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.InputActivities[4].SetEquals(new HashSet <int> { 3, 7 })); Assert.IsTrue(dependencyGraph.InputActivities[5].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.InputActivities[6].SetEquals(new HashSet <int> { 5, 8 })); Assert.IsTrue(dependencyGraph.InputActivities[7].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.InputActivities[8].SetEquals(new HashSet <int> { 4 })); //OUT Assert.IsTrue(dependencyGraph.OutputActivities[0].SetEquals(new HashSet <int> { 1 })); Assert.IsTrue(dependencyGraph.OutputActivities[1].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.OutputActivities[2].SetEquals(new HashSet <int> { 1, 7, 3 })); Assert.IsTrue(dependencyGraph.OutputActivities[3].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.OutputActivities[4].SetEquals(new HashSet <int> { 5, 8 })); Assert.IsTrue(dependencyGraph.OutputActivities[5].SetEquals(new HashSet <int> { 6 })); Assert.IsTrue(dependencyGraph.OutputActivities[7].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.OutputActivities[8].SetEquals(new HashSet <int> { 6 })); }
public void HardDependencyGraphNoL2LL1LWithoutAllTaskConnected() { // Arrange ImportedEventLog elog = CSVImport.MakeDataFrame(hardCsv); elog.SetActivity("act"); elog.SetCaseId("id"); WorkflowLog wlog = new WorkflowLog(elog); var successorMatrix = new SuccessorMatrix(wlog); // Act HeuristicMinerSettings settings = new HeuristicMinerSettings { L2LThreshold = 1, L1LThreshold = 1, AllTasksConnected = false }; DependencyGraph dependencyGraph = new DependencyGraph(successorMatrix, settings); // Assert Assert.AreEqual(successorMatrix.Activities.Count, dependencyGraph.Activities.Count); var start = successorMatrix.ActivityIndices[successorMatrix.StartActivities.First()]; var end = successorMatrix.ActivityIndices[successorMatrix.EndActivities.First()]; Assert.AreEqual(start, dependencyGraph.StartActivity); Assert.AreEqual(end, dependencyGraph.EndActivity); Assert.IsTrue(dependencyGraph.LongDependencies.Count == 0); //1 IN NO ARC A->A Assert.IsTrue(dependencyGraph.InputActivities[start].Count == 0); //NO OUTPUT FOR END ACT Assert.IsTrue(dependencyGraph.OutputActivities[end].Count == 0); //IN //NO BACK ARC FROM C->B and A->A Assert.IsTrue(dependencyGraph.InputActivities[1].SetEquals(new HashSet <int> { 0 })); //NO ARC FROM B->C Assert.IsTrue(dependencyGraph.InputActivities[2].SetEquals(new HashSet <int> { })); Assert.IsTrue(dependencyGraph.InputActivities[3].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.InputActivities[4].SetEquals(new HashSet <int> { 3, 7 })); Assert.IsTrue(dependencyGraph.InputActivities[5].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.InputActivities[6].SetEquals(new HashSet <int> { 5, 8 })); Assert.IsTrue(dependencyGraph.InputActivities[7].SetEquals(new HashSet <int> { 2 })); Assert.IsTrue(dependencyGraph.InputActivities[8].SetEquals(new HashSet <int> { 4 })); //OUT //NO ARC A->A Assert.IsTrue(dependencyGraph.OutputActivities[0].SetEquals(new HashSet <int> { 1 })); //NO ARC B->C Assert.IsTrue(dependencyGraph.OutputActivities[1].SetEquals(new HashSet <int> { })); //NO BACK ARC FROM C->B Assert.IsTrue(dependencyGraph.OutputActivities[2].SetEquals(new HashSet <int> { 7, 3 })); Assert.IsTrue(dependencyGraph.OutputActivities[3].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.OutputActivities[4].SetEquals(new HashSet <int> { 5, 8 })); Assert.IsTrue(dependencyGraph.OutputActivities[5].SetEquals(new HashSet <int> { 6 })); Assert.IsTrue(dependencyGraph.OutputActivities[7].SetEquals(new HashSet <int> { 4 })); Assert.IsTrue(dependencyGraph.OutputActivities[8].SetEquals(new HashSet <int> { 6 })); }
/// <summary> /// Dependency graph constructor with default settings /// </summary> /// <param name="successorMatrix"></param> public DependencyGraph(SuccessorMatrix successorMatrix) : this(successorMatrix, new HeuristicMinerSettings()) { }