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 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 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 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 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);
}