public void ToStringTest() { var event1 = new Event("A"); var node = new EventNode(event1, 0.8); Assert.AreEqual("A", node.ToString()); }
/// <summary> /// Constructor for a tree node /// </summary> /// <param name="inductiveMiner"></param> /// <param name="operation">node operation</param> /// <param name="associatedEvent"></param> /// <param name="right"></param> /// <param name="left"></param> /// <author>Thomas Meents, Bernd Nottbeck</author> public InductiveMinerTreeNode(InductiveMiner inductiveMiner, OperationsEnum operation, Event associatedEvent = null, InductiveMinerTreeNode right = null, InductiveMinerTreeNode left = null) { Operation = operation; LeftLeaf = left; RightLeaf = right; Event = associatedEvent; petriNet = inductiveMiner.IMPetriNet; }
/// <summary> /// Constructor for an graph node object /// </summary> /// <param name="name">associated event</param> /// <author>Bernd Nottbeck</author> public InductiveMinerGraphNode(Event name) { threshHold = MinerSettings.GetAsDouble("InductiveThresholdSlider"); Name = name; FollowerList = new List<InductiveMinerRow>(); EventualFollowerList = new List<InductiveMinerRow>(); }
private EventLog createEventLogFrom(string sourceFile) { //The Method should return a list with EventLogs! EventLog eventLog = new EventLog(Path.GetFileName(sourceFile)); Case caseFound = new Case(); Event eventFound = new Event(); String theActualElement = ""; XmlTextReader reader = new XmlTextReader(sourceFile); while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: // The node is an element. theActualElement = reader.Name.ToLower(); if (reader.Name.ToLower().Equals("processinstance")) { //A new Case starts caseFound = new Case(reader.GetAttribute("id")); } else if (reader.Name.ToLower().Equals("audittrailentry")) { //A new transition starts eventFound = new Event(); } break; case XmlNodeType.Text: //Display the text in each element. if (theActualElement.Equals("workflowmodelelement")) { eventFound.Name = reader.Value; } else if (theActualElement.Equals("timestamp")) { eventFound.Information.Add("TIMESTAMP", reader.Value); } break; case XmlNodeType.EndElement: //Display the end of the element. if (reader.Name.ToLower().Equals("processinstance")) { //The case ends in the mxml file and the case must put to the eventlog eventLog.Cases.Add(caseFound); } else if (reader.Name.ToLower().Equals("audittrailentry")) { //The transition ends here caseFound.EventList.Add(eventFound); } break; } } return eventLog; }
public void EventNodeTest() { var event1 = new Event("A"); var node = new EventNode(event1, 0.8); Assert.AreEqual("A", node.InnerEvent.Name); Assert.AreEqual(0.8, node.Adjacency); Assert.IsNotNull(node.ListOfFollowers); }
public void EventConstructorTest1() { Event e = new Event(); Assert.AreEqual("", e.Name); e.Name = "1234Test"; Assert.AreEqual("1234Test", e.Name); if (e.Information.Count != 0) Assert.Fail("Event Information.Count != 0"); }
/// <summary> /// Initialize the InductiveMiner instance. /// </summary> /// <param name="field">Corresponding field</param> /// <author>Krystian Zielonka, Thomas Meents, Bernd Nottbeck</author> public InductiveMiner(Field field) { _field = field; DirectRowList = new List<InductiveMinerRow>(); EventDictionary = new Dictionary<Event, InductiveMinerGraphNode>(); IMPetriNet = new PetriNet(_field.Infotext); StartEvent = new Event("StartEvent"); EndEvent = new Event("EndEvent"); EventuallyRowList = new List<InductiveMinerRow>(); }
public void FindNodeTest() { var event1 = new Event("A"); var event2 = new Event("B"); var event3 = new Event("C"); var eventNode = new EventNode(event1, 0.8, new List<EventNode> { new EventNode(event2, 0.8, new List<EventNode> { new EventNode(event3, 0.8) }) }); Assert.AreEqual("C", eventNode.FindNode("C").InnerEvent.Name); Assert.IsNull(eventNode.FindNode("D")); }
public void EventFollowsEventTest() { EventLog log = ExampleData.EventLogExample.OneCaseEventLog(); Event first = new Event(); Event second = new Event(); foreach (Case cases in log.Cases) { first = cases.EventList.First(); second = cases.EventList.Last(); break; } Assert.IsTrue(log.EventFollowsEvent(first, second) == 1,"Count: " + log.EventFollowsEvent(first, second)); }
/// <summary> /// Constructor for a tree node´used duringt the cutting process. /// </summary> /// <param name="petriNet"></param> /// <param name="graphNode"></param> /// <param name="startEvent"></param> public InductiveMinerTreeNode(PetriNet petriNet, InductiveMinerGraphNode graphNode, Event startEvent) { GraphNode = graphNode; Operation = GraphNode.FollowerList.Count == 0 ? OperationsEnum.isLeaf : OperationsEnum.isUnkown; Event = GraphNode.Name; LeftLeaf = null; RightLeaf = null; this.startEvent = startEvent; visitedNodes = new HashSet<InductiveMinerGraphNode>(); visitedLoopCheckNodes = new HashSet<InductiveMinerGraphNode>(); this.petriNet = petriNet; newStart = new InductiveMinerGraphNode(new Event("NewStart")); DivideAndConquer(); }
public void EventEqualsTest() { Event e = new Event("Test"); Event e2 = new Event("Test2"); Event e3 = new Event("Test2"); if (e.Equals(e2)) { Assert.Fail("Event.equals check failed!"); } if (!e2.Equals(e3)) { Assert.Fail("Event.equals check failed!"); } }
public void CreateDependencyGraphTest() { var field = new Field { EventLog = EventLogExample.ThreeCaseEventLog() }; var miner = new HeuristicMiner(field); var event1 = new Event("A"); var event2 = new Event("B"); var event3 = new Event("C"); var eventList = new List<Event> { event1, event2, event3 }; var matrix = new[,] { { 0.0, 0.8, 0.0 }, { 0.0, 0.0, 0.8 }, { 0.0, 0.0, 0.0 } }; var actual = miner.CreateDependencyGraph(eventList, matrix, 0.5, 0.0, 0, 10); var expected = new EventNode(event1, 0.8, new List<EventNode> { new EventNode(event2, 0.8, new List<EventNode> { new EventNode(event3, 0.8) }) }); Assert.AreEqual(expected.InnerEvent, actual.InnerEvent); Assert.AreEqual(expected.ListOfFollowers[0].InnerEvent, actual.ListOfFollowers[0].InnerEvent); Assert.AreEqual(expected.ListOfFollowers[0].ListOfFollowers[0].InnerEvent, actual.ListOfFollowers[0].ListOfFollowers[0].InnerEvent); }
public void CaseAddEventTest1() { List<Event> eventList = new List<Event> {new Event("A")}; //create Case and add event a Case ca = new Case("CaseName", eventList); //add event b ca.CreateEvent("B"); //add event c ca.EventList.Add(new Event("C")); //add event d Event eventD = new Event {Name = "D"}; ca.EventList.Add(eventD); foreach (Event e in ca.EventList) { if (e.Name.Equals("A")) { } else if (e.Name.Equals("B")) { } else if (e.Name.Equals("C")) { } else if (e.Name.Equals("D")) { } else { Assert.Fail("Event not in case"); } } }
/// <summary> /// Returns how often e1 is followed by e2. /// </summary> /// <param name="event1">The first event</param> /// <param name="event2">The second event, which must follow the first event directly</param> /// <returns>The count of what IndexesOfPair returns.</returns> /// <author>Jannik Arndt</author> public int EventFollowsEventCount(Event event1, Event event2) { return IndexesOfPair(event1, event2).Count; }
/// <summary> /// Count how often e2 follows e1. /// </summary> /// <param name="event1"></param> /// <param name="event2"></param> /// <returns></returns> /// <author>Jannik Arndt</author> public int EventFollowsEvent(Event event1, Event event2) { return Cases.Sum(Case => Case.EventFollowsEventCount(event1, event2)); }
/// <summary> /// Calculates whether b and c (both followers of a) are in an XOR-relation. /// </summary> /// <param name="a">First event</param> /// <param name="b">Second event</param> /// <param name="c">Third event</param> /// <param name="log">The current event log</param> /// <returns></returns> /// <author>Jannik Arndt</author> public bool IsXorRelation(Event a, Event b, Event c, EventLog log) { return !IsAndRelation(a, b, c, log); }
/// <summary> /// Calculates whether b and c (both followers of a) are in an AND-relation. /// </summary> /// <param name="a">Event a</param> /// <param name="b">Event b</param> /// <param name="c">Event c</param> /// <param name="log">The current event log</param> /// <returns>Returns a result bigger than 0.1</returns> /// <author>Jannik Arndt</author> public bool IsAndRelation(Event a, Event b, Event c, EventLog log) { var result = Convert.ToDouble(log.EventFollowsEvent(b, c) + log.EventFollowsEvent(c, b)) / Convert.ToDouble(log.EventFollowsEvent(a, b) + log.EventFollowsEvent(a, c) + 1); return result > 0.1; }
/// <summary> /// Calculates the adjacency of two events in a given EventLog. Called by CreateAdjacencyMatrix() /// </summary> /// <param name="event1">First Event</param> /// <param name="event2">Second Event</param> /// <param name="log">The EventLog to be searched</param> /// <returns>The adjacency of two events in an eventlog</returns> /// <author>Jannik Arndt</author> public double GetAdjacency(Event event1, Event event2, EventLog log) { if (event1 == null) throw new ArgumentNullException("event1", "The given arguments are not valid"); if (event2 == null) throw new ArgumentNullException("event2", "The given arguments are not valid"); if (log == null) throw new ArgumentNullException("log", "The given arguments are not valid"); var event1ToEvent2 = log.EventFollowsEvent(event1, event2); var event2ToEvent1 = log.EventFollowsEvent(event2, event1); return Convert.ToDouble(event1ToEvent2 - event2ToEvent1) / Convert.ToDouble(event1ToEvent2 + event2ToEvent1 + 1); }
public void ToStringTest() { Event ev = new Event { Name = "Event" }; Assert.IsTrue(ev.Name == ev.ToString()); }
/// <summary> /// Checks the DirectRowList if a row from event A to event B exists. If not a new row is created, else the directly follow count is increased by one. /// </summary> /// <param name="fromEvent">From event A</param> /// <param name="toEvent">To event B</param> /// <author>Bernd Nottbeck</author> protected void CheckAddRowEventDic(Event fromEvent, Event toEvent) { if (!EventDictionary.ContainsKey(toEvent)) EventDictionary.Add(toEvent, new InductiveMinerGraphNode(toEvent)); InductiveMinerRow currentRow; var query = from SearchRow in DirectRowList where SearchRow.FromNode == EventDictionary[fromEvent] && SearchRow.ToNode == EventDictionary[toEvent] select SearchRow; currentRow = query.FirstOrDefault(); if (currentRow != null) { currentRow.Count++; } else { DirectRowList.Add(new InductiveMinerRow(EventDictionary[fromEvent], EventDictionary[toEvent])); } }
/// <summary> /// Reads the Events from the Database and returns a DataSet. /// </summary> /// <returns>A list of Fact-objects.</returns> /// <author>Jannik Arndt, Bernd Nottbeck</author> public List<List<Case>> GetFacts(string sqlcode) { var listOfFacts = new List<List<Case>>(); try { // Loads a list of all facts and then converts it into fact-, case- and event-objects. Open(); var factDataTable = GetFactDataTable(sqlcode); var currentFactID = ""; var currentCaseID = ""; List<Case> currentFact = null; Case currentCase = null; // iterate over the FactDataTable: object with the same fact_id will be combined into one fact-object. foreach (DataRow row in factDataTable.Rows) { // 1. Did a new fact start? if (currentFactID != row[ColumnNameFactID].ToString()) { // save the current one if (currentFact != null) listOfFacts.Add(currentFact); // and create a new one currentFactID = row[ColumnNameFactID].ToString(); currentFact = new List<Case>(); } // 2. Did a new case start? if (currentCaseID != row[ColumnNameCaseID].ToString()) { currentCaseID = row[ColumnNameCaseID].ToString(); currentCase = new Case(currentCaseID); currentCase.AdditionalData.Add(ColumnNameFactID, row[ColumnNameFactID].ToString()); if (Settings.Default.JoinAllDimensions) foreach (var dimension in DBWorker.MetaData.ListOfFactDimensions) if (!dimension.IsEmptyDimension) currentCase.AdditionalData.Add(dimension.ToTable, row[dimension.ToTable].ToString()); if (currentFact != null) currentFact.Add(currentCase); } // 3. create an event and add it to the case var currentEvent = new Event(row[DBWorker.MetaData.EventClassifier].ToString()); foreach (var columnName in DBWorker.MetaData.ListOfEventsTableColumnNames) currentEvent.Information.Add(columnName, row[columnName].ToString()); if (currentCase != null) currentCase.EventList.Add(currentEvent); } // since the last case and fact are not saved yet, we need to do this now. listOfFacts.Add(currentFact); return listOfFacts; } finally { Close(); } }
public void EventConstructorTest2() { Event e = new Event("Test"); Assert.AreEqual("Test", e.Name); }
public void EventFollowsEventCountTest() { Case ca = new Case(); Event ev1 = new Event {Name = "first"}; Event ev2 = new Event {Name = "second"}; ca.EventList.Add(ev1); ca.EventList.Add(ev2); Assert.IsTrue(ca.EventFollowsEventCount(ev1, ev2)==1,"Count: " + ca.EventFollowsEventCount(ev1,ev2)); }
/// <summary> /// Constructor, which set the following parameter. /// </summary> /// <param name="innerEvent">The InnerEvent</param> /// <param name="adjacency">The Adjacency</param> /// <param name="listOfFollowers">List of followers</param> public EventNode(Event innerEvent, double adjacency, List<EventNode> listOfFollowers = null) { InnerEvent = innerEvent; Adjacency = adjacency; ListOfFollowers = listOfFollowers ?? new List<EventNode>(); }
/// <summary> /// Returns a list of integers, which are the indexes of each occurrence of Event e1 and Event e2 directly following each other. /// </summary> /// <param name="event1">The first event</param> /// <param name="event2">The second event, which must follow the first event directly</param> /// <returns>A list of indexes</returns> /// <author>Jannik Arndt</author> public List<int> IndexesOfPair(Event event1, Event event2) { return Enumerable.Range(0, EventList.Count - 1).Where(i => EventList[i].Name == event1.Name && EventList[i + 1].Name == event2.Name).ToList(); }
/// <summary> /// Checks the eventuallyRowList if a row from event A to event B exists. If not a new row is created, else the directly follow count is increased by one. /// </summary> /// <param name="fromEvent">From event A</param> /// <param name="toEvent">To event B</param> /// <author>Bernd Nottbeck, Krystian Zielonka </author> protected void CheckAddRowEventualFollowsDic(Event fromEvent, Event toEvent) { if (!EventDictionary.ContainsKey(toEvent)) throw new Exception("Something is wrong! Key Missing in event dictionary"); InductiveMinerRow currentRow; var query = from SearchRow in EventuallyRowList where SearchRow.FromNode == EventDictionary[fromEvent] && SearchRow.ToNode == EventDictionary[toEvent] select SearchRow; currentRow = query.FirstOrDefault(); if (currentRow != null) { currentRow.Count++; } else { EventuallyRowList.Add(new InductiveMinerRow(EventDictionary[fromEvent], EventDictionary[toEvent])); } }
/// <summary> /// Creates a new Event and adds it to a <see cref="Case"/>. /// </summary> /// <param name="name">The Name of the new event</param> public Event CreateEvent(String name) { Event item = new Event(name); EventList.Add(item); return item; }
public void GetHashCodeTest() { Event ev = new Event { Name = "Event" }; Assert.IsTrue(ev.Name.GetHashCode() == ev.GetHashCode()); }
/// <summary> /// This method creates an event log with one case. /// </summary> /// <autor>Thomas Meents</autor> public static EventLog OneCaseEventLog() { Event firstEvent = new Event("first"); Event secondEvent = new Event("second"); List<Event> listOfEvents = new List<Event> { firstEvent, secondEvent }; Case ca = new Case("ExampleCase", listOfEvents); EventLog eventLog = new EventLog(); eventLog.Cases.Add(ca); return eventLog; }
public void IndexesOfPairTest() { Case ca = new Case(); Event ev1 = new Event { Name = "first" }; Event ev2 = new Event { Name = "second" }; ca.EventList.Add(ev1); ca.EventList.Add(ev2); List<int> list = ca.IndexesOfPair(ev1, ev2); Assert.IsTrue(list.Count==1); }