private static void AbstractionClusters(FuzzyModel fm)
{
List <FuzzyNodeCluster> clustersToRemove = new List <FuzzyNodeCluster>();
List <FuzzyEdge> edgesToRemove = new List <FuzzyEdge>();
foreach (FuzzyNodeCluster fnc in fm.GetClusters())
{
if (fnc.GetInEdges().Count == 0 && fnc.GetOutEdges().Count == 0)
{
clustersToRemove.Add(fnc);
}
else if (fnc.GetNodesInCluster().Count == 1)
{
foreach (FuzzyEdge fei in fnc.GetInEdges())
{
foreach (FuzzyEdge feo in fnc.GetOutEdges())
{
FuzzyEdge newFe = new FuzzyEdge(fei.GetFromNode(), feo.GetToNode());
if (!fm.GetEdges().Contains(newFe))
{
fm.AddEdge(newFe);
}
}
edgesToRemove.Add(fei);
}
clustersToRemove.Add(fnc);
}
}
foreach (FuzzyNodeCluster fnc in clustersToRemove)
{
fm.RemoveCluster(fnc);
}
foreach (FuzzyEdge fe in edgesToRemove)
{
fm.RemoveEdge(fe);
}
}
public static FuzzyModel parseLogFile(string file)
{
FuzzyModel fm = new FuzzyModel();
List <XTrace> traces = getTracesXES(file);
string root = "start_node";
string end = "end_node";
fm.AddNode(root);
foreach (XTrace xt in traces)
{
fm.GetNode(root).IncreaseFrequencySignificance();
var xamTrace = xt.GetAttributes();
foreach (string key in xamTrace.Keys)
{
if (key != "concept:name")
{
fm.GetNode(root).AddSignificantAttribute(key, xamTrace[key].ToString());
}
}
string previousEvent = root;
string previousState = "";
double eventDuration = 0;
double traceDuration = 0;
double previousTime = 0;
foreach (XEvent xe in xt)
{
// find event name
XAttributeMap xam = (XAttributeMap)xe.GetAttributes();
string currentEvent;
string currentState = "";
if (xam.Keys.Contains <string>("lifecycle:transition"))
{
currentState = xam["lifecycle:transition"].ToString();
}
double currentTime = 0;
if (xam.Keys.Contains <string>("time:timestamp"))
{
currentTime = Convert.ToDateTime(xam["time:timestamp"].ToString()).ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
}
currentEvent = xam["concept:name"].ToString();
// if the event is new, add it to the graph
if (!fm.GetEvents().Contains(currentEvent))
{
FuzzyNode node = new FuzzyNode(currentEvent);
fm.AddNode(node);
// if it is not the first event in the trace, add edges
if (previousEvent != null)
{
FuzzyEdge e = new FuzzyEdge(fm.GetNode(previousEvent), node);
// if the edge is new add it to the list
if (!fm.GetNode(previousEvent).GetOutEdges().Contains(e))
{
fm.AddEdge(e);
}
// if it's not the start node, compute the duration of the transition
if (previousEvent != "start_node")
{
fm.GetEdge(e).AddDuration(currentTime - previousTime);
traceDuration += currentTime - previousTime;
}
fm.GetEdge(e).IncreaseFrequencySignificance();
}
fm.GetNode(currentEvent).IncreaseFrequencySignificance();
}
else
{
// if it is not the first event in the trace, add edges
if (previousEvent != null)
{
FuzzyEdge e = new FuzzyEdge(fm.GetNode(previousEvent), fm.GetNode(currentEvent));
// if the edge is new add it to the list
if (!fm.GetNode(previousEvent).GetOutEdges().Contains(e))
{
fm.AddEdge(e);
}
// if it's not the start node, compute the duration of the transition
if (previousEvent != "start_node")
{
fm.GetEdge(e).AddDuration(currentTime - previousTime);
traceDuration += currentTime - previousTime;
}
fm.GetEdge(e).IncreaseFrequencySignificance();
}
// if the event is the same but the state is different, compute the event duration
if (previousEvent == currentEvent && previousState != currentState)
{
if (previousState == "complete" && currentState == "start")
{
fm.GetNode(currentEvent).IncreaseFrequencySignificance();
}
eventDuration += currentTime - previousTime;
}
else
{
fm.GetNode(currentEvent).IncreaseFrequencySignificance();
}
}
// if the event is complete add its duration to the node
if (currentState == "complete")
{
fm.GetNode(currentEvent).AddDuration(eventDuration);
traceDuration += eventDuration;
eventDuration = 0;
}
// add the event attributes to the node
foreach (string key in xam.Keys)
{
if (key != "concept:name" && key != "lifecycle:transition")
{
if (key != "time:timestamp" && key.IndexOf("id", StringComparison.OrdinalIgnoreCase) < 0)
{
fm.GetNode(currentEvent).AddSignificantAttribute(key, xam[key].ToString());
}
fm.GetNode(currentEvent).AddAttribute(key, xam[key].ToString());
}
}
previousEvent = currentEvent;
previousState = currentState;
previousTime = currentTime;
}
if (!fm.GetEvents().Contains(end))
{
fm.AddNode(end);
fm.GetNode(end).IncreaseFrequencySignificance();
}
else
{
fm.GetNode(end).IncreaseFrequencySignificance();
}
FuzzyEdge fe = new FuzzyEdge(fm.GetNode(previousEvent), fm.GetNode(end));
if (!fm.GetEdges().Contains(fe))
{
fm.AddEdge(fe);
fm.GetEdge(fe).IncreaseFrequencySignificance();
}
else
{
fm.GetEdge(fe).IncreaseFrequencySignificance();
}
fm.GetNode(root).AddDuration(traceDuration);
}
foreach (XTrace xt in traces)
{
foreach (FuzzyNode fn in fm.GetNodes())
{
foreach (XEvent xe in xt)
{
if (xe.GetAttributes()["concept:name"].ToString().Equals(fn.GetLabel()))
{
fn.IncreaseCaseFrequencySignificance();
break;
}
}
}
foreach (FuzzyEdge fe in fm.GetEdges())
{
string previousEvent = "";
foreach (XEvent xe in xt)
{
string currentEvent = xe.GetAttributes()["concept:name"].ToString();
if (previousEvent.Equals(fe.GetFromNode().GetLabel()) && currentEvent.Equals(fe.GetToNode().GetLabel()))
{
fe.IncreaseCaseFrequencySignificance();
break;
}
previousEvent = currentEvent;
}
}
}
return(fm);
}
public static void EdgeFiltering(FuzzyModel fm, float edgeCutoff)
{
float utilityRatio = 1;
List <FuzzyEdge> toRemove = new List <FuzzyEdge>();
List <FuzzyEdge> toPreserve = new List <FuzzyEdge>();
foreach (FuzzyNode fn in fm.GetNodes())
{
Dictionary <FuzzyEdge, float> utilValues = new Dictionary <FuzzyEdge, float>();
Dictionary <FuzzyEdge, float> normUtilValues = new Dictionary <FuzzyEdge, float>();
// if only one edge brings to this node, it has to be preserved
if (fn.GetInEdges().Count > 1)
{
foreach (FuzzyEdge fe in fn.GetInEdges())
{
if (fe.GetFromNode().GetLabel() != "start_node")
{
float utility = utilityRatio * fe.GetFrequencySignificance();
utilValues.Add(fe, utility);
}
}
Console.WriteLine("Edges to {0}", fn.GetLabel());
// normalize utility
foreach (FuzzyEdge fe in utilValues.Keys)
{
float f = (utilValues[fe] - utilValues.Values.Min()) / (utilValues.Values.Max() - utilValues.Values.Min());
Console.WriteLine("{0} Utility value: {1}", fe.ToString(), f);
if (fe.GetFromNode().GetOutEdges().Count > 1)
{
normUtilValues.Add(fe, f);
}
else
{
toPreserve.Add(fe);
}
}
// filter edges
foreach (FuzzyEdge fe in normUtilValues.Keys)
{
if (normUtilValues[fe] > edgeCutoff)
{
toPreserve.Add(fe);
}
}
}
else
{
foreach (FuzzyEdge fe in fn.GetInEdges())
{
toPreserve.Add(fe);
}
}
utilValues = new Dictionary <FuzzyEdge, float>();
normUtilValues = new Dictionary <FuzzyEdge, float>();
if (fn.GetOutEdges().Count > 1)
{
foreach (FuzzyEdge fe in fn.GetOutEdges())
{
if (fe.GetToNode().GetLabel() != "end_node")
{
float utility = utilityRatio * fe.GetFrequencySignificance();
utilValues.Add(fe, utility);
}
}
Console.WriteLine("Edges from {0}", fn.GetLabel());
// normalize utility
foreach (FuzzyEdge fe in utilValues.Keys)
{
float f = (utilValues[fe] - utilValues.Values.Min()) / (utilValues.Values.Max() - utilValues.Values.Min());
Console.WriteLine("{0} Utility value: {1}", fe.ToString(), f);
//if (fe.GetToNode().GetInEdges().Count > 1)
//{
normUtilValues.Add(fe, f);
//}
}
// filter edges
foreach (FuzzyEdge fe in normUtilValues.Keys)
{
//if (normUtilValues.Count != 1)
//{
if (normUtilValues[fe] > edgeCutoff)
{
toPreserve.Add(fe);
}
//}
}
}
}
foreach (FuzzyEdge fe in fm.GetEdges())
{
if (!toPreserve.Contains(fe))
{
toRemove.Add(fe);
}
}
foreach (FuzzyEdge fe in toRemove)
{
fm.RemoveEdge(fe);
}
}
public static void ConflictResolution(FuzzyModel fm, float preserveThr, float ratioThr)
{
List <FuzzyEdge> toRemove = new List <FuzzyEdge>();
foreach (FuzzyEdge AB in fm.GetEdges())
{
FuzzyEdge BA = fm.GetEdge(AB.GetToNode(), AB.GetFromNode());
float relAB = 0;
float relBA = 0;
if (BA != null)
{
if (AB.Equals(BA))
{
toRemove.Add(AB);
}
if (toRemove.Contains(AB) || toRemove.Contains(BA))
{
continue;
}
FuzzyNode A = AB.GetFromNode();
FuzzyNode B = AB.GetToNode();
// compute relative significance of edge A->B
float sigAB = AB.GetFrequencySignificance();
float sigAX = 0;
foreach (FuzzyEdge AX in A.GetOutEdges())
{
sigAX += AX.GetFrequencySignificance();
}
float sigXB = 0;
foreach (FuzzyEdge XB in B.GetInEdges())
{
sigXB += XB.GetFrequencySignificance();
}
relAB = (0.5F * (sigAB / sigAX)) + (0.5F * (sigAB / sigXB));
Console.WriteLine("{0}, Relative significance: {1}", AB.ToString(), relAB);
// compute relative significance of edge B->A
float sigBA = BA.GetFrequencySignificance();
float sigBX = 0;
foreach (FuzzyEdge BX in B.GetOutEdges())
{
sigBX += BX.GetFrequencySignificance();
}
float sigXA = 0;
foreach (FuzzyEdge XA in A.GetInEdges())
{
sigXA += XA.GetFrequencySignificance();
}
relBA = (0.5F * (sigBA / sigBX)) + (0.5F * (sigBA / sigXA));
Console.WriteLine("{0}, Relative significance: {1}", BA.ToString(), relBA);
// Decide preservation
if (relAB < preserveThr || relBA < preserveThr)
{
float ofsAB = Math.Abs(relAB - relBA);
if (ofsAB < ratioThr)
{
toRemove.Add(AB);
toRemove.Add(BA);
}
else
{
if (relAB > relBA)
{
toRemove.Add(BA);
}
else
{
toRemove.Add(AB);
}
}
}
}
}
foreach (FuzzyEdge fe in toRemove)
{
fm.RemoveEdge(fe);
}
}
public static void ExportToJSON(FuzzyModel fm, string outputName)
{
string filename = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName + System.IO.Path.DirectorySeparatorChar + "Output" + System.IO.Path.DirectorySeparatorChar + outputName + ".json";
try
{
// Check if file already exists. If yes, delete it.
if (File.Exists(filename))
{
File.Delete(filename);
}
// Create a new file
using (StreamWriter sw = File.CreateText(filename))
{
sw.WriteLine("{");
sw.WriteLine(" \"FuzzyModel\" : {");
Console.WriteLine("Printing nodes...");
sw.WriteLine(" \"nodes\": [");
foreach (FuzzyNode fn in fm.GetNodes())
{
sw.WriteLine(" {");
sw.WriteLine(" \"label\" : \"" + fn.GetLabel() + "\",");
sw.WriteLine(" \"frequencySignificance\" : " + fn.GetFrequencySignificance() + ",");
sw.WriteLine(" \"caseFrequencySignificance\" : " + fn.GetCaseFrequencySignificance() + ",");
if (fn.GetLabel() != "end_node")
{
sw.WriteLine(" \"durations\" : [");
sw.WriteLine(" {");
Dictionary <string, double> durations = ComputeDurations(fn);
sw.WriteLine(" \"TotalDuration\" : " + durations["TotalDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MeanDuration\" : " + durations["MeanDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MedianDuration\" : " + durations["MedianDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MinDuration\" : " + durations["MinDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MaxDuration\" : " + durations["MaxDuration"].ToString().Replace(",", "."));
sw.WriteLine(" }");
sw.WriteLine(" ],");
}
sw.WriteLine(" \"attributes\" : [");
sw.WriteLine(" {");
foreach (string s in fn.GetSignificantAttributes().Keys)
{
Dictionary <string, double> attributesValues = ComputeOverallAttribute(s, fn.GetSignificantAttributes()[s]);
if (attributesValues.Keys.Count != 0)
{
sw.WriteLine(" \"" + s + "\" : [");
sw.WriteLine(" {");
foreach (string key in attributesValues.Keys)
{
if (key.Equals(attributesValues.Keys.Last <string>()))
{
sw.WriteLine(" \"" + key + "\" : \"" + attributesValues[key] + "\"");
sw.WriteLine(" }");
if (s.Equals(fn.GetSignificantAttributes().Keys.Last <string>()))
{
sw.WriteLine(" ]");
}
else
{
sw.WriteLine(" ],");
}
}
else
{
sw.WriteLine(" \"" + key + "\" : \"" + attributesValues[key] + "\",");
}
}
}
}
sw.WriteLine(" }");
sw.WriteLine(" ]");
if (fn == fm.GetNodes().Last <FuzzyNode>())
{
sw.WriteLine(" }");
}
else
{
sw.WriteLine(" },");
}
}
sw.WriteLine(" ],");
Console.WriteLine("Printing edges...");
sw.WriteLine(" \"edges\": [");
foreach (FuzzyEdge fe in fm.GetEdges())
{
sw.WriteLine(" {");
sw.WriteLine(" \"label\" : \"" + fe.ToString() + "\",");
sw.WriteLine(" \"fromNode\" : \"" + fe.GetFromNode().GetLabel() + "\",");
sw.WriteLine(" \"toNode\" : \"" + fe.GetToNode().GetLabel() + "\",");
if (fe.GetFromNode().GetLabel() != "start_node" && fe.GetToNode().GetLabel() != "end_node")
{
sw.WriteLine(" \"frequencySignificance\" : " + fe.GetFrequencySignificance() + ",");
sw.WriteLine(" \"caseFrequencySignificance\" : " + fe.GetCaseFrequencySignificance() + ",");
sw.WriteLine(" \"durations\" : [");
sw.WriteLine(" {");
Dictionary <string, double> durations = ComputeDurations(fe);
sw.WriteLine(" \"TotalDuration\" : " + durations["TotalDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MeanDuration\" : " + durations["MeanDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MedianDuration\" : " + durations["MedianDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MinDuration\" : " + durations["MinDuration"].ToString().Replace(",", ".") + ",");
sw.WriteLine(" \"MaxDuration\" : " + durations["MaxDuration"].ToString().Replace(",", "."));
sw.WriteLine(" }");
sw.WriteLine(" ]");
}
else
{
sw.WriteLine(" \"frequencySignificance\" : " + fe.GetFrequencySignificance());
}
if (fe == fm.GetEdges().Last <FuzzyEdge>())
{
sw.WriteLine(" }");
}
else
{
sw.WriteLine(" },");
}
}
sw.WriteLine(" ]");
sw.WriteLine(" }");
sw.WriteLine("}");
}
}
catch (Exception Ex)
{
Console.WriteLine(Ex.ToString());
}
}
