public void AddEventTest()
{
var a = new Activity("A", "nameA");
var exhaust = new ContradictionApproach(new HashSet<Activity>() {a,new Activity("B","nameB")});
exhaust.AddEvent("A", "1000");
Assert.IsTrue(exhaust.Graph.GetIncludedActivities().Contains(a));
}
public void ConditionNegativeTest()
{
var a = new Activity("A", "nameA");
var b = new Activity("B", "nameB");
var exhaust = new ContradictionApproach(new HashSet<Activity>() { a, b });
exhaust.AddEvent("B", "1000");
exhaust.Stop();
HashSet<Activity> con;
exhaust.Graph.Conditions.TryGetValue(a, out con);
Assert.IsFalse(con.Contains(b));
}
public void CreateNestsTest()
{
var dcrGraph = new DcrGraph();
var activityA = new Activity("A", "somename1") { Included = true, Pending = true };
var activityB = new Activity("B", "somename2") { Included = true };
var activityC = new Activity("C", "somename3") { Included = true };
var activityD = new Activity("D", "somename4") { Included = true };
var activityE = new Activity("E", "somename5") { Included = true, Pending = true };
var activityF = new Activity("F", "somename6") { Included = true };
var activityG = new Activity("G", "somename7") { Included = true };
dcrGraph.AddActivities(activityA, activityB, activityC, activityD, activityE, activityF, activityG);
dcrGraph.AddResponse(activityB.Id, activityC.Id); //inner nest condition
//From A to all inner
dcrGraph.AddIncludeExclude(false, activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityC.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityD.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityE.Id);
dcrGraph.AddIncludeExclude(false, activityA.Id, activityB.Id);
dcrGraph.AddIncludeExclude(false, activityD.Id, activityF.Id); //from in to out
dcrGraph.AddMileStone(activityF.Id, activityG.Id);
//From G to all inner and F
dcrGraph.AddCondition(activityG.Id, activityB.Id);
dcrGraph.AddCondition(activityG.Id, activityC.Id);
dcrGraph.AddCondition(activityG.Id, activityD.Id);
dcrGraph.AddCondition(activityG.Id, activityE.Id);
dcrGraph.AddCondition(activityG.Id, activityF.Id);
var exhaust = new ContradictionApproach(dcrGraph.Activities) { Graph = dcrGraph };
exhaust.Graph = ContradictionApproach.CreateNests(exhaust.Graph);
Assert.IsTrue(exhaust.Graph.Activities.Any(a => a.IsNestedGraph));
}
public void ExhaustiveWithBigDataLog()
{
var activities = new HashSet<Activity>();
for (char ch = 'A'; ch <= 'Z'; ch++)
{
activities.Add(new Activity("" + ch, "somename " + ch));
}
var rnd = new Random();
var inputLog = new Log();
var traceId = 1000;
var currentTrace = new LogTrace() {Id = traceId.ToString()};
while (inputLog.Traces.Count < 100000)
{
currentTrace.Add(new LogEvent(activities.ElementAt(rnd.Next(activities.Count)).Id, ""));
if (currentTrace.Events.Count == 8)
{
inputLog.AddTrace(currentTrace);
traceId++;
currentTrace = (new LogTrace() {Id = traceId.ToString()});
}
}
var exAl = new ContradictionApproach(activities);
foreach (var trace in inputLog.Traces)
{
exAl.AddTrace(trace);
}
Assert.IsTrue(true);
}
public void TestLogParserHospital()
{
var watch = new Stopwatch();
watch.Start();
var log =
XmlParser.ParseLog(
new LogStandard("http://www.xes-standard.org/", "trace",
new LogStandardEntry(DataType.String, "conceptName"), "event",
new LogStandardEntry(DataType.String, "ActivityCode"),
new LogStandardEntry(DataType.String, "conceptName"),
new LogStandardEntry(DataType.String, "org:group")), Properties.Resources.Hospital_log);
Console.WriteLine("Finished parsing " + log.Traces.Count + " traces. Took: " + watch.Elapsed);
Console.WriteLine("Alphabeth of size " + log.Alphabet.Count);
int occurences = 0;
//
log.Traces = new List<LogTrace>(log.Traces.Where(t => t.Events.Distinct().Count() < 8));
foreach (var character in log.Alphabet)
{
foreach (var other in log.Alphabet.Where(a => (a.IdOfActivity == character.IdOfActivity && a.Name != character.Name)))
{
//Console.WriteLine("Name: " + character.Name + ", " + character.IdOfActivity +" is not : "+ other.IdOfActivity);
occurences++;
}
}
Console.WriteLine("occurences of Id/Name-mismatch: " + occurences);
var actors = new HashSet<String>();
foreach (var name in log.Traces.SelectMany(trace => trace.Events.Select(a => a.ActorName)))
{
actors.Add(name);
}
foreach (var name in actors)
{
var tracesLength = log.Traces.Where(t => t.Events.Any(n => n.ActorName == name)).Select(a=> a.Events.Count);
Console.WriteLine(name + " : " + tracesLength.Count() + " traces, Longest trace = " + tracesLength.Max());
}
foreach (var trace in log.Traces.First().Events)
{
//Console.WriteLine("Example trace: " + log.Traces.First().Id);
//Console.Write("ID: " + trace.IdOfActivity + ", Name: " + trace.Name + " | ");
}
Console.WriteLine("\nPlease choose department to process mine:");
string department= Console.ReadLine();
var newLog = log.FilterByActor(department);
ContradictionApproach ex = new ContradictionApproach(new HashSet<Activity>(newLog.Alphabet.Select(logEvent => new Activity(logEvent.IdOfActivity,logEvent.Name))));
Console.WriteLine(ex.Graph);
var redundancy = new RedundancyRemover();
foreach (var trace in newLog.Traces)
{
ex.AddTrace(trace);
}
var redundancyRemoved = redundancy.RemoveRedundancy(ex.Graph);
Console.WriteLine(redundancyRemoved);
Console.WriteLine(QualityDimensionRetriever.Retrieve(redundancyRemoved, newLog));
Console.ReadLine();
}
public void TestOriginalLog()
{
var activities = new HashSet<Activity>();
for (char ch = 'A'; ch <= 'F'; ch++)
{
activities.Add(new Activity("" + ch, "" + ch));
}
var exAl = new ContradictionApproach(activities);
var trace1 = new LogTrace {Id = "1"};
trace1.AddEventsWithChars('A', 'B', 'E');
var trace2 = new LogTrace { Id = "2" };
trace2.AddEventsWithChars('A', 'C', 'F', 'A', 'B', 'B', 'F');
var trace3 = new LogTrace { Id = "3" };
trace3.AddEventsWithChars('A', 'C', 'E');
var trace4 = new LogTrace { Id = "4" };
trace4.AddEventsWithChars('A', 'D', 'F');
var trace5 = new LogTrace { Id = "5" };
trace5.AddEventsWithChars('A', 'B', 'F', 'A', 'B', 'E');
var trace6 = new LogTrace { Id = "6" };
trace6.AddEventsWithChars('A', 'C', 'F');
var trace7 = new LogTrace { Id = "7" };
trace7.AddEventsWithChars('A', 'B', 'F', 'A', 'C', 'F', 'A', 'C', 'E');
var trace8 = new LogTrace { Id = "8" };
trace8.AddEventsWithChars('A', 'B', 'B', 'B', 'F');
var trace9 = new LogTrace { Id = "9" };
trace9.AddEventsWithChars('A', 'B', 'B', 'E');
var trace10 = new LogTrace { Id = "10" };
trace10.AddEventsWithChars('A', 'C', 'F', 'A', 'C', 'E');
Log log = new Log() {Traces = {trace1, trace2, trace3, trace4, trace5, trace6, trace7, trace8, trace9, trace10}};
exAl.AddLog(log);
Console.WriteLine(exAl.Graph);
Console.WriteLine(QualityDimensionRetriever.Retrieve(exAl.Graph,log));
//Console.WriteLine(exAl.Graph.ExportToXml());
Console.ReadLine();
exAl.Graph = new RedundancyRemover().RemoveRedundancy(exAl.Graph);
Console.WriteLine(exAl.Graph);
Console.WriteLine(QualityDimensionRetriever.Retrieve(exAl.Graph, log));
Console.ReadLine();
exAl.Graph = ContradictionApproach.PostProcessing(exAl.Graph);
Console.WriteLine(exAl.Graph);
Console.WriteLine(QualityDimensionRetriever.Retrieve(exAl.Graph, log));
Console.ReadLine();
//using (StreamWriter sw = new StreamWriter("C:/Downloads/OrigGraph.xml"))
//{
// sw.WriteLine(exAl.Graph.ExportToXml());
//}
}
public void ExhaustiveTest()
{
var traceId = 1000;
var activities = new HashSet<Activity>();
for (char ch = 'A'; ch <= 'G'; ch++)
{
activities.Add(new Activity("" + ch, "somename " + ch));
}
var inputLog = new Log();
var currentTrace = new LogTrace() {Id = traceId++.ToString()};
inputLog.Traces.Add(currentTrace);
var exAl = new ContradictionApproach(activities);
int id = 0;
while (true)
{
var input = Console.ReadLine();
switch (input)
{
case "STOP":
exAl.Stop();
currentTrace = currentTrace.Copy();
currentTrace = new LogTrace() { Id = traceId++.ToString() };
inputLog.Traces.Add(currentTrace);
break;
case "AUTOLOG":
Console.WriteLine("Please input a termination index between 0 - 100 : \n");
var logGen = new LogGenerator9001(Convert.ToInt32(Console.ReadLine()), exAl.Graph);
Console.WriteLine("Please input number of desired traces to generate : \n");
List<LogTrace> log = logGen.GenerateLog(Convert.ToInt32(Console.ReadLine()));
foreach (var trace in log)
{
Console.WriteLine(trace);
}
break;
case "REDUNDANCY":
exAl.Graph = new RedundancyRemover().RemoveRedundancy(exAl.Graph);
break;
case "POST":
exAl.Graph = ContradictionApproach.PostProcessing(exAl.Graph);
break;
case "NESTED":
exAl.Graph = ContradictionApproach.CreateNests(exAl.Graph);
break;
case "CHANGE TRACE":
inputLog.Traces.Add(currentTrace);
var newId = Console.ReadLine();
currentTrace = inputLog.Traces.Find(x => x.Id == newId) ?? new LogTrace() { Id = newId};
break;
default:
if (exAl.Graph.GetActivities().Any(a => a.Id == input))
{
exAl.AddEvent(input, currentTrace.Id);
currentTrace.Add(new LogEvent(input, "somename" + input) {EventId = "" + id++});
}
break;
}
Console.WriteLine("Current trace id: " + currentTrace.Id);
Console.WriteLine(exAl.Graph);
//the quality probably suffers because the traces contains unfinished traces.
Console.WriteLine(QualityDimensionRetriever.Retrieve(exAl.Graph, inputLog));
}
}
public void TestFlowerModel()
{
var graph = new DcrGraph();
var trace = new LogTrace();
for (char ch = 'A'; ch <= 'D'; ch++)
{
graph.Activities.Add(new Activity("" + ch, "somename " + ch) {Included = true});
trace.AddEventsWithChars(ch);
}
var exhaustive =
new ContradictionApproach(new HashSet<Activity>
{
new Activity("A", "somenameA"),
new Activity("B", "somenameB"),
new Activity("C", "somenameC"),
new Activity("D", "somenameD")
});
exhaustive.Graph = graph;
exhaustive.AddTrace(trace);
Console.WriteLine(exhaustive.Graph);
exhaustive.Graph = new RedundancyRemover().RemoveRedundancy(exhaustive.Graph);
Console.WriteLine(exhaustive.Graph);
Console.WriteLine(QualityDimensionRetriever.Retrieve(exhaustive.Graph, new Log() {Traces = {trace}}));
Console.ReadLine();
}
public void TestQualityDimensionsRetriever()
{
var graph = new DcrGraph();
graph.AddActivity("A", "somename1");
graph.AddActivity("B", "somename2");
graph.AddActivity("C", "somename3");
//graph.AddActivity("D", "somename3");
graph.SetIncluded(true, "A"); // Start at A
graph.AddIncludeExclude(true, "A", "B");
graph.AddIncludeExclude(true, "B", "C");
graph.AddIncludeExclude(false, "C", "B");
graph.AddResponse("B", "C");
// Self-excludes
graph.AddIncludeExclude(false, "A", "A");
graph.AddIncludeExclude(false, "B", "B");
graph.AddIncludeExclude(false, "C", "C");
graph.AddCondition("A", "B");
graph.AddMileStone("A", "B");
var someLog =
new Log() { Traces =
new List<LogTrace>
{
new LogTrace('A', 'B', 'C'),
new LogTrace('A', 'C')
}
};
var res = QualityDimensionRetriever.Retrieve(graph, someLog);
Console.WriteLine(graph);
Console.WriteLine(res);
var graph2 = new DcrGraph();
graph2.AddActivity("A", "somename1");
graph2.AddActivity("B", "somename2");
graph2.AddActivity("C", "somename3");
graph2.SetIncluded(true, "A");
graph2.SetIncluded(true, "B");
graph2.SetIncluded(true, "C");
res = QualityDimensionRetriever.Retrieve(graph2, someLog);
Console.WriteLine(graph2);
Console.WriteLine(res);
var graph3 = new DcrGraph();
graph3.AddActivity("A", "somename1");
graph3.AddActivity("B", "somename2");
graph3.AddActivity("C", "somename3");
graph3.AddIncludeExclude(false, "A", "A");
graph3.AddIncludeExclude(false, "B", "B");
graph3.AddIncludeExclude(false, "C", "C");
graph3.AddIncludeExclude(false, "A", "B");
graph3.AddIncludeExclude(false, "B", "A");
graph3.AddIncludeExclude(false, "C", "A");
graph3.AddIncludeExclude(false, "C", "B");
graph3.AddIncludeExclude(false, "A", "C");
graph3.AddIncludeExclude(false, "B", "C");
graph3.AddResponse("A", "B");
graph3.AddResponse("A", "C");
graph3.AddResponse("B", "A");
graph3.AddResponse("B", "C");
graph3.AddResponse("C", "A");
graph3.AddResponse("C", "B");
graph3.AddCondition("A", "B");
graph3.AddCondition("A", "C");
graph3.AddCondition("B", "A");
graph3.AddCondition("B", "C");
graph3.AddCondition("C", "A");
graph3.AddCondition("C", "B");
graph3.AddMileStone("A", "B");
graph3.AddMileStone("A", "C");
graph3.AddMileStone("B", "A");
graph3.AddMileStone("B", "C");
graph3.AddMileStone("C", "A");
graph3.AddMileStone("C", "B");
res = QualityDimensionRetriever.Retrieve(graph3, someLog);
Console.WriteLine(graph3);
Console.WriteLine(res);
// "Original" test log
var activities = new HashSet<Activity>();
for (char ch = 'A'; ch <= 'F'; ch++)
{
activities.Add(new Activity("" + ch, "somename " + ch));
}
var exAl = new ContradictionApproach(activities);
var originalLog = new List<LogTrace>();
originalLog.Add(new LogTrace('A', 'B', 'E'));
originalLog.Add(new LogTrace('A', 'C', 'F', 'A', 'B', 'B', 'F'));
originalLog.Add(new LogTrace('A', 'C', 'E'));
originalLog.Add(new LogTrace('A', 'D', 'F'));
originalLog.Add(new LogTrace('A', 'B', 'F', 'A', 'B', 'E'));
originalLog.Add(new LogTrace('A', 'C', 'F'));
originalLog.Add(new LogTrace('A', 'B', 'F', 'A', 'C', 'F', 'A', 'C', 'E'));
originalLog.Add(new LogTrace('A', 'B', 'B', 'B', 'F'));
originalLog.Add(new LogTrace('A', 'B', 'B', 'E'));
originalLog.Add(new LogTrace('A', 'C', 'F', 'A', 'C', 'E'));
exAl.AddTrace(originalLog[0]);
exAl.AddTrace(originalLog[1]);
exAl.AddTrace(originalLog[2]);
exAl.AddTrace(originalLog[3]);
exAl.AddTrace(originalLog[4]);
exAl.AddTrace(originalLog[5]);
exAl.AddTrace(originalLog[6]);
exAl.AddTrace(originalLog[7]);
exAl.AddTrace(originalLog[8]);
exAl.AddTrace(originalLog[9]);
var log = new Log() {Traces = originalLog};
res = QualityDimensionRetriever.Retrieve(exAl.Graph, log);
Console.WriteLine(exAl.Graph);
Console.WriteLine(res);
Console.WriteLine("Removing redundancy::::::::::::::::::::::::::::::::::");
exAl.Graph = new RedundancyRemover().RemoveRedundancy(exAl.Graph);
res = QualityDimensionRetriever.Retrieve(exAl.Graph, log);
Console.WriteLine(exAl.Graph);
Console.WriteLine(res);
Console.ReadLine();
}
public List<long> DataTimingTest(int alphabeth, int traces, int traceLength, int timesToRun)
{
var activities = new HashSet<Activity>();
for (int i = 0; i < alphabeth; i++)
{
activities.Add(new Activity("" + i, "" + i));
}
var times = new List<long>();
for (int j = 0; j < timesToRun; j++)
{
var rnd = new Random();
var inputLog = new Log();
var traceId = 1000;
var currentTrace = new LogTrace() {Id = traceId.ToString()};
while (inputLog.Traces.Count < traces)
{
currentTrace.Add(new LogEvent(activities.ElementAt(rnd.Next(activities.Count)).Id, ""));
if (currentTrace.Events.Count == traceLength)
{
inputLog.AddTrace(currentTrace);
traceId++;
currentTrace = (new LogTrace() {Id = traceId.ToString()});
}
}
//
var watch = new Stopwatch();
watch.Start();
var exAl = new ContradictionApproach(activities);
foreach (var trace in inputLog.Traces)
{
exAl.AddTrace(trace);
}
watch.Stop();
times.Add(watch.ElapsedMilliseconds);
Console.Write(".");
}
return times;
}
public void RetrieveFitnessOnGraphMinedFromLog()
{
var log =
XmlParser.ParseLog(
new LogStandard("http://www.xes-standard.org/", "trace",
new LogStandardEntry(DataType.String, "conceptName"), "event",
new LogStandardEntry(DataType.String, "ActivityCode"),
new LogStandardEntry(DataType.String, "conceptName"),
new LogStandardEntry(DataType.String, "org:group")), Resources.Hospital_log);
log = log.FilterByActor("Special lab Genetic Metabolic Diseases"); //only in 1 small trace
ContradictionApproach ex = new ContradictionApproach(new HashSet<Activity>(log.Alphabet.Select(logEvent => new Activity(logEvent.IdOfActivity, logEvent.Name))));
foreach (var trace in log.Traces)
{
ex.AddTrace(trace);
}
//expecting fitness = 100%
var qd = UlrikHovsgaardAlgorithm.QualityMeasures.QualityDimensionRetriever.Retrieve(ex.Graph, log);
Assert.AreEqual(100d, qd.Fitness);
}
private void bw_DoWork(object sender, DoWorkEventArgs e)
{
Dispatcher.Invoke(() =>
{
if (IsTraceAdditionAllowed)
{
// Make a copy of Exhaustive Approach where all traces are finished, to avoid potential Response cycles
var exaustCopy = new ContradictionApproach(_contradictionApproach.Graph.GetActivities());
exaustCopy.AddLog(new Log {Traces = _entireLog.ToList()});
var redundancyRemovedGraph = _redundancyRemover.RemoveRedundancy(exaustCopy.Graph);
ContradictionApproach.PostProcessing(redundancyRemovedGraph);
}
else // Signifies that the program was initiated with a loaded graph
{
var redundancyRemovedGraph = _redundancyRemover.RemoveRedundancy(GraphToDisplay);
ContradictionApproach.PostProcessing(redundancyRemovedGraph);
}
});
}
private void SetUpWithAlphabet(int sizeOfAlphabet)
{
IsWaiting = true;
var a = 'A';
for (int i = 0; i < sizeOfAlphabet; i++)
{
var currId = "" + Convert.ToChar(a + i);
Activities.Add(new Activity(currId, string.Format("Activity {0}", currId)));
}
foreach (var activity in Activities)
{
ActivityButtons.Add(new ActivityNameWrapper(activity.Id));
}
_contradictionApproach = new ContradictionApproach(new HashSet<Activity>(Activities));
ContradictionApproach.PostProcessingResultEvent += UpdateGraphWithPostProcessingResult;
UpdateGraph();
IsWaiting = false;
}
private void SetUpWithLog(Log log)
{
IsWaiting = true;
// TODO: _contradictionApproach.AddLog(log); - then add to GUI list etc? - test effectiveness - probably same deal
Activities = new ObservableCollection<Activity>(log.Alphabet.Select(x => new Activity(x.IdOfActivity, x.Name){ Roles = x.ActorName }));
foreach (var activity in Activities)
{
ActivityButtons.Add(new ActivityNameWrapper(activity.Id));
}
_contradictionApproach = new ContradictionApproach(new HashSet<Activity>(Activities));
ContradictionApproach.PostProcessingResultEvent += UpdateGraphWithPostProcessingResult;
foreach (var logTrace in log.Traces)
{
AddFinishedTraceFromLog(logTrace);
}
RefreshLogTraces();
UpdateGraph();
IsWaiting = false;
}
public void Init()
{
Activities = new ObservableCollection<Activity>();
_contradictionApproach = new ContradictionApproach(new HashSet<Activity>(Activities));
ContradictionApproach.PostProcessingResultEvent += UpdateGraphWithPostProcessingResult;
_redundancyRemover = new RedundancyRemover();
_redundancyRemover.ReportProgress += ProgressMadeInRedundancyRemover;
ActivityButtons = new ObservableCollection<ActivityNameWrapper>();
EntireLog = new TrulyObservableCollection<LogTrace>();
PerformPostProcessing = false;
IsTraceAdditionAllowed = true;
var startOptionsViewModel = new StartOptionsWindowViewModel();
startOptionsViewModel.AlphabetSizeSelected += SetUpWithAlphabet;
startOptionsViewModel.LogLoaded += SetUpWithLog;
startOptionsViewModel.DcrGraphLoaded += SetUpWithGraph;
OpenStartOptionsEvent?.Invoke(startOptionsViewModel);
}