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())
{
}
