/// <summary>
        ///     Resets the index of each node according to Deepth-First Search.
        /// </summary>
        /// <param name="node">Starting node to search.</param>
        /// <param name="childsProperty">Property to return child node.</param>
        /// <returns></returns>
        public static void RenumberIndicesOfBpmTree(this BpmGene node,
                                                    Func <BpmGene, IEnumerable <BpmGene> > childsProperty)
        {
            Debug.WriteLine("Renumbering the following gene: " + node);

            var counter = 0;

            var stack = new Stack <BpmGene>();

            node.Index = counter;
            stack.Push(node);
            while (stack.Count > 0)
            {
                var thisNode = stack.Pop();

                if (childsProperty(thisNode) != null)
                {
                    foreach (var child in childsProperty(thisNode))
                    {
                        child.Index = ++counter;
                        stack.Push(child);
                    }
                }
            }
        }
        /// <summary>
        ///     sucht und findet Blätter mit dem speziellen Index, ansonsten return null
        /// </summary>
        /// <param name="index">Gene index</param>
        /// <param name="gene">starting gene</param>
        /// <returns></returns>
        public static BpmGene FindLeaf(this BpmGene gene, int index)
        {
            if (gene.Index == index)
            {
                if (gene.GetType() == typeof(BpmnActivity))
                {
                    return(gene);
                }
                else
                {
                    return(null);
                }
            }

            // falsches blatt gefunden
            if (gene.Children == null || gene.Children.Count == 0)
            {
                return(null);
            }

            for (var i = gene.Children.Count - 1; i >= 0; i--)
            {
                if (gene.Children[i].Index <= index)
                {
                    return(gene.Children[i].FindLeaf(index));
                }
            }

            return(null);
        }
Esempio n. 3
0
            /// <summary>
            ///     counts the appearance of same activities in single nodes
            /// </summary>
            /// <param name="gene">gene to check</param>
            /// <param name="count">so far found appearances</param>
            /// <returns></returns>
            public static int CheckForMultipleEqualActivitiesInSameNode(BpmGene gene, int count = 0)
            {
                if (gene is BpmnActivity)
                {
                    return(count);
                }

                var list = new List <string>();

                foreach (var child in gene.Children)
                {
                    if (child is BpmnActivity)
                    {
                        if (list.Contains(((BpmnActivity)child).Name))
                        {
                            count++;
                        }
                        else
                        {
                            list.Add(((BpmnActivity)child).Name);
                        }
                    }
                    else
                    {
                        count += CheckForMultipleEqualActivitiesInSameNode(child);
                    }
                }

                return(count);
            }
Esempio n. 4
0
 private void CalculatePath(BpmnProcessAttribute bpa, BpmGene gene, List <BpmnActivity> path)
 {
     if (gene == null)
     {
         return;
     }
     if (gene is BpmnActivity)
     {
         path.Add(gene as BpmnActivity);
     }
     else if (gene is BpmnSeq || gene is BpmnAnd)
     {
         foreach (var child in gene.Children)
         {
             CalculatePath(bpa, child, path);
         }
     }
     else if (gene is BpmnXor)
     {
         if ((gene as BpmnXor).ToProcessAttribute().Equals(bpa))
         {
             if (gene.Children.Count > 0)
             {
                 CalculatePath(bpa, gene.Children[0], path);
             }
         }
         else
         {
             if (gene.Children.Count > 1)
             {
                 CalculatePath(bpa, gene.Children[1], path);
             }
         }
     }
 }
        /// <summary>
        ///     Count number of nodes in tree
        /// </summary>
        /// <param name="root">root node from tree</param>
        /// <param name="nodeType">node type looking for</param>
        /// <returns></returns>
        public static int CountSpecificNodes(this BpmGene root, Type nodeType)
        {
            if (root == null)
            {
                return(0);
            }

            var sum = 0;

            if (root.GetType() == nodeType)
            {
                sum++;
            }

            if (root is BpmnActivity)
            {
                return(sum);
            }

            if (root is BpmnAnd || root is BpmnSeq)
            {
                return(sum + root.Children.Sum(x => CountSpecificNodes(x, nodeType)));
            }

            // XOR
            return(sum + root.Children.Sum(x => CountSpecificNodes(x, nodeType)));
        }
 /// <summary>
 ///     Creates a new BPMN-XOR-Gateway
 /// </summary>
 /// <param name="index">i dof node</param>
 /// <param name="parent">parent node</param>
 /// <param name="decisionId">id of decision</param>
 /// <param name="decisionValue">value of decision</param>
 /// <param name="executionProbability">probability of execution</param>
 public BpmnXor(int index, BpmGene parent, string decisionId, string decisionValue,
                double executionProbability = 1.0) : base(index, parent)
 {
     DecisionId           = decisionId;
     DecisionValue        = decisionValue;
     ExecutionProbability = executionProbability;
 }
            private XmlElement Activity(BpmGene gene)
            {
                var Activity = doc.OwnerDocument.CreateElement("bpmndi", "BPMNShape", BpmndiUri);

                Activity.SetAttribute("id", "Task_" + gene.Id + "_di");
                Activity.SetAttribute("bpmnElement", "Task_" + gene.Id);
                return(Activity);
            }
            public void auto(BpmGene gene, XmlElement start, XmlElement end)
            {
                matrix[0][0] = Start(start);

                AddColumn();
                var d = AddGene(gene, 0, 1);

                AddColumn();
                matrix[0][d.width + 1] = End(end);

                SetPositions();
            }
 private static void ListActivities(BpmGene gene, List <BpmnActivity> list)
 {
     if (gene is BpmnActivity)
     {
         list.Add((BpmnActivity)gene);
     }
     else
     {
         foreach (var g in gene.Children)
         {
             ListActivities(g, list);
         }
     }
 }
        /// <summary>
        ///     Counts number of hops to root node, alias depth
        /// </summary>
        /// <param name="gene">the gene to calculate for</param>
        /// <returns></returns>
        public static int CalculateNodeDepth(this BpmGene gene)
        {
            var parent = gene;

            var count = 0;

            while (parent != null)
            {
                parent = parent.Parent;
                count++;
            }

            return(count);
        }
        private double CalculateTime(BpmnProcessAttribute bpa, BpmGene gene)
        {
            if (gene == null)
            {
                return(0);
            }
            if (gene is BpmnActivity)
            {
                return(DataHelper.ActivityHelper.Instance().GetTime((gene as BpmnActivity).Name));
            }
            if (gene is BpmnAnd)
            {
                var max = 0.0;

                foreach (var child in gene.Children)
                {
                    max = Math.Max(max, CalculateTime(bpa, child));
                }

                return(max);
            }
            if (gene is BpmnSeq)
            {
                var sum = 0.0;

                foreach (var child in gene.Children)
                {
                    sum += CalculateTime(bpa, child);
                }

                return(sum);
            }
            if ((gene as BpmnXor).ToProcessAttribute().Equals(bpa))
            {
                if (gene.Children == null || gene.Children.Count == 0)
                {
                    return(0);
                }
                else
                {
                    return(CalculateTime(bpa, gene.Children[0]));
                }
            }
            if (gene.Children.Count > 1)
            {
                return(CalculateTime(bpa, gene.Children[1]));
            }
            return(0);
        }
        // berechnen der Wahrscheinlichkeit, das Aktivität a & b im gleichen Prozess sind über die generierten Pfade und Pfadwahrscheinlichkeiten
        private static double CalculateProbabilities2ProcessActivities(BpmGene a, BpmGene b,
                                                                       List <Path> paths)
        {
            var probability = 0.0;

            foreach (var path in paths)
            {
                if (path.path.Contains(a) && path.path.Contains(b))
                {
                    probability += path.Probability;
                }
            }

            return(probability);
        }
Esempio n. 13
0
            /// <summary>
            ///     checks for too much equal activities in one gateway
            /// </summary>
            /// <param name="gene"></param>
            /// <returns></returns>
            public static int CheckForTooMuchActivities(BpmGene gene)
            {
                // TODO stimmt nicht
                if (gene is BpmnActivity)
                {
                    return(1);
                }

                var count = 0;

                foreach (var child in gene.Children)
                {
                    count += CheckForTooMuchActivities(child);
                }

                return(count);
            }
            private XmlElement And(BpmGene gene, bool open = true)
            {
                var And = doc.OwnerDocument.CreateElement("bpmndi", "BPMNShape", BpmndiUri);

                if (open)
                {
                    And.SetAttribute("id", "ParallelGateway_open_" + gene.Id + "_di");
                    And.SetAttribute("bpmnElement", "ParallelGateway_open_" + gene.Id);
                }
                else
                {
                    And.SetAttribute("id", "ParallelGateway_close_" + gene.Id + "_di");
                    And.SetAttribute("bpmnElement", "ParallelGateway_close_" + gene.Id);
                }

                return(And);
            }
        private bool CheckActivityAttributeCovering(BpmGene root)
        {
            var decisions = DataHelper.ActivityAttributeHelper.Instance().GetAll();

            foreach (var decision in decisions)
            {
                var decisionValues = DataHelper.ActivityAttributeHelper.Instance()
                                     .GetDecisionValues(decision.DecisionId);

                if (CheckActivityAttributeCovering(decision, decisionValues, root) == false)
                {
                    return(false);
                }
            }

            return(true);
        }
        /// <summary>
        ///     Calculates the index of the specified child in parents children
        /// </summary>
        /// <param name="parent">the parent where to look</param>
        /// <param name="child">the child which to look for</param>
        /// <returns></returns>
        public static int GetChildIndex(BpmGene parent, BpmGene child)
        {
            if (parent == null)
            {
                return(-1);
            }

            for (var i = 0; i < parent.Children.Count; i++)
            {
                if (parent.Children[i].Index == child.Index)
                {
                    return(i);
                }
            }

            return(-1);
        }
            private XmlElement Xor(BpmGene gene, bool open = true)
            {
                var Xor = doc.OwnerDocument.CreateElement("bpmndi", "BPMNShape", BpmndiUri);

                Xor.SetAttribute("isMarkerVisible", "true");

                if (open)
                {
                    Xor.SetAttribute("id", "ExclusiveGateway_open_" + gene.Id + "_di");
                    Xor.SetAttribute("bpmnElement", "ExclusiveGateway_open_" + gene.Id);
                }
                else
                {
                    Xor.SetAttribute("id", "ExclusiveGateway_close_" + gene.Id + "_di");
                    Xor.SetAttribute("bpmnElement", "ExclusiveGateway_close_" + gene.Id);
                }

                return(Xor);
            }
Esempio n. 18
0
            /// <summary>
            ///     counts appearances of concatenating same gateways with having multiple children SEQ(SEQ(xxx))
            /// </summary>
            /// <param name="gene"></param>
            /// <param name="count"></param>
            /// <returns></returns>
            public static int CheckForConcatenatingGatewaysWithSingleChild(BpmGene gene, int count = 0)
            {
                if (gene is BpmnActivity)
                {
                    return(count);
                }

                if (gene.Children.Count == 1 && gene.Children[0].GetType() == gene.GetType())
                {
                    return(count + 1);
                }

                foreach (var child in gene.Children)
                {
                    count += CheckForConcatenatingGatewaysWithSingleChild(child);
                }

                return(count);
            }
Esempio n. 19
0
            /// <summary>
            ///     counts appearances of empty gateways
            /// </summary>
            /// <param name="gene"></param>
            /// <param name="count"></param>
            /// <returns></returns>
            public static int CheckForEmptyGateways(BpmGene gene, int count = 0)
            {
                if (gene is BpmnActivity)
                {
                    return(count);
                }

                if (gene.Children.Count == 0)
                {
                    return(count + 1);
                }

                foreach (var child in gene.Children)
                {
                    count += CheckForEmptyGateways(child);
                }

                return(count);
            }
Esempio n. 20
0
            public PathSplitter(BpmGenome genome)
            {
                _root = genome.RootGene;

                if (DataHelper.ActivityAttributeHelper.Instance().GetAll().Count <= 0)
                {
                    List <BpmnActivity> path = TreeHelper.ListActivities(genome);
                    paths.Add(new Path {
                        Probability = 1, path = path
                    });
                }

                foreach (var bpa in DataHelper.ActivityAttributeHelper.Instance().GetAll())
                {
                    var path = new List <BpmnActivity>();
                    CalculatePath(bpa, _root, path);
                    paths.Add(new Path {
                        Probability = bpa.DecisionProbability, path = path
                    });
                }
            }
Esempio n. 21
0
            /// <summary>
            ///     checks for concatenating xors inside each other
            /// </summary>
            /// <param name="gene"></param>
            /// <param name="maxNumberOfXors"></param>
            /// <param name="count"></param>
            /// <returns></returns>
            public static int CheckForSeveralXorsInLine(BpmGene gene, int maxNumberOfXors, int count = 0)
            {
                var parent = gene;

                for (var i = 0; i < maxNumberOfXors; i++)
                {
                    if (parent == null)
                    {
                        break;
                    }

                    if (parent is BpmnXor)
                    {
                        parent = parent.Parent;
                    }
                    else
                    {
                        break;
                    }

                    if (i == 2)
                    {
                        count++;
                    }
                }

                if (parent is BpmnActivity)
                {
                    return(count);
                }

                foreach (var child in gene.Children)
                {
                    count += CheckForSeveralXorsInLine(child, maxNumberOfXors);
                }

                return(count);
            }
Esempio n. 22
0
            /// <summary>
            ///     checks wheter xors have more than 2 children
            /// </summary>
            /// <param name="gene"></param>
            /// <returns></returns>
            public static bool CheckForBpmnXorFailture(BpmGene gene)
            {
                if (gene == null || gene is BpmnActivity)
                {
                    return(true);
                }

                if (gene is BpmnAnd || gene is BpmnSeq || gene is BpmnXor && gene.Children.Count <= 2)
                {
                    foreach (var geneForCheck in gene.Children)
                    {
                        var check = CheckForBpmnXorFailture(geneForCheck);

                        if (!check)
                        {
                            return(false);
                        }
                    }

                    return(true);
                }
                return(false);
            }
        public static double CalculateLongestTime(BpmGene rootGene)
        {
            if (rootGene is BpmnSeq)
            {
                var time = 0.0;

                rootGene.Children.ForEach(x => time += CalculateLongestTime(x));

                return(time);
            }

            if (rootGene is BpmnAnd)
            {
                if (rootGene.Children.Count <= 0)
                {
                    return(0);
                }

                return(rootGene.Children.Max(x => CalculateLongestTime(x)));
            }

            return(DataHelper.ActivityHelper.Instance().GetTime((rootGene as BpmnActivity).Name));
        }
        private static XmlElement GeneToXml(XmlElement process, BpmGene gene, XmlElement incomingSequence)
        {
            if (gene is BpmnActivity)
            {
                var activity = process.OwnerDocument.CreateElement("bpmn", "task", BpmnUri);
                activity.SetAttribute("id", "Task_" + gene.Id);
                activity.SetAttribute("name", (gene as BpmnActivity).Name);
                process.AppendChild(activity);

                var incoming = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                incoming.InnerText = incomingSequence.GetAttribute("id");
                activity.AppendChild(incoming);

                incomingSequence.SetAttribute("targetRef", activity.GetAttribute("id"));

                var outgoing = process.OwnerDocument.CreateElement("bpmn", "outgoing", BpmnUri);
                outgoing.InnerText = "SequenceFlow_" + Guid.NewGuid();
                activity.AppendChild(outgoing);

                var sequenceFlow = process.OwnerDocument.CreateElement("bpmn", "sequenceFlow", BpmnUri);
                sequenceFlow.SetAttribute("id", outgoing.InnerText);
                sequenceFlow.SetAttribute("sourceRef", activity.GetAttribute("id"));
                process.AppendChild(sequenceFlow);

                return(sequenceFlow);
            }
            if (gene is BpmnAnd)
            {
                var attributeName = "ParallelGateway_";
                var localName     = "parallelGateway";

                // Open Gateway
                var gatewayOpen = process.OwnerDocument.CreateElement("bpmn", localName, BpmnUri);
                gatewayOpen.SetAttribute("id", attributeName + "open_" + gene.Id);
                process.AppendChild(gatewayOpen);

                // Gateway open incoming
                var gatewayOpenIncoming = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                gatewayOpenIncoming.InnerText = incomingSequence.GetAttribute("id");
                gatewayOpen.AppendChild(gatewayOpenIncoming);

                // Incoming Sequence
                incomingSequence.SetAttribute("targetRef", gatewayOpen.GetAttribute("id"));

                // Close Gateway
                var gatewayClose = process.OwnerDocument.CreateElement("bpmn", localName, BpmnUri);
                gatewayClose.SetAttribute("id", attributeName + "close_" + gene.Id);
                process.AppendChild(gatewayClose);

                // Gateway close outgoing
                var gatewayCloseOutgoing = process.OwnerDocument.CreateElement("bpmn", "outgoing", BpmnUri);
                gatewayCloseOutgoing.InnerText = "SequenceFlow_" + Guid.NewGuid();
                gatewayClose.AppendChild(gatewayCloseOutgoing);

                // Outgoing Sequence
                var sequenceFlow = process.OwnerDocument.CreateElement("bpmn", "sequenceFlow", BpmnUri);
                sequenceFlow.SetAttribute("id", gatewayCloseOutgoing.InnerText);
                sequenceFlow.SetAttribute("sourceRef", gatewayClose.GetAttribute("id"));
                process.AppendChild(sequenceFlow);

                foreach (var child in gene.Children)
                {
                    // Gateway open outgoing
                    var gatewayOpenOutgoing = process.OwnerDocument.CreateElement("bpmn", "outgoing", BpmnUri);
                    gatewayOpenOutgoing.InnerText = "SequenceFlow_" + Guid.NewGuid();
                    gatewayOpen.AppendChild(gatewayOpenOutgoing);

                    // Gateway open outgoing sequence
                    var innerSequenceFlow = process.OwnerDocument.CreateElement("bpmn", "sequenceFlow", BpmnUri);
                    innerSequenceFlow.SetAttribute("id", gatewayOpenOutgoing.InnerText);
                    innerSequenceFlow.SetAttribute("sourceRef", gatewayOpen.GetAttribute("id"));
                    process.AppendChild(innerSequenceFlow);

                    innerSequenceFlow = GeneToXml(process, child, innerSequenceFlow);

                    // gateway close incoming
                    var gatewayCloseIncoming = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                    gatewayCloseIncoming.InnerText = innerSequenceFlow.GetAttribute("id");
                    gatewayClose.AppendChild(gatewayCloseIncoming);

                    // gateway close incoming sequence
                    innerSequenceFlow.SetAttribute("targetRef", gatewayClose.GetAttribute("id"));
                }

                return(sequenceFlow);
            }
            if (gene is BpmnXor)
            {
                var attributeName = "ExclusiveGateway_";
                var localName     = "exclusiveGateway";

                // Open Gateway
                var gatewayOpen = process.OwnerDocument.CreateElement("bpmn", localName, BpmnUri);
                gatewayOpen.SetAttribute("id", attributeName + "open_" + gene.Id);
                process.AppendChild(gatewayOpen);

                // add name/id to gateway
                gatewayOpen.SetAttribute("name", "v[" + (gene as BpmnXor).ToProcessAttribute().DecisionId + "]");

                // Gateway open incoming
                var gatewayOpenIncoming = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                gatewayOpenIncoming.InnerText = incomingSequence.GetAttribute("id");
                gatewayOpen.AppendChild(gatewayOpenIncoming);

                // Incoming Sequence
                incomingSequence.SetAttribute("targetRef", gatewayOpen.GetAttribute("id"));

                // Close Gateway
                var gatewayClose = process.OwnerDocument.CreateElement("bpmn", localName, BpmnUri);
                gatewayClose.SetAttribute("id", attributeName + "close_" + gene.Id);
                process.AppendChild(gatewayClose);

                // Gateway close outgoing
                var gatewayCloseOutgoing = process.OwnerDocument.CreateElement("bpmn", "outgoing", BpmnUri);
                gatewayCloseOutgoing.InnerText = "SequenceFlow_" + Guid.NewGuid();
                gatewayClose.AppendChild(gatewayCloseOutgoing);

                // Outgoing Sequence
                var sequenceFlow = process.OwnerDocument.CreateElement("bpmn", "sequenceFlow", BpmnUri);
                sequenceFlow.SetAttribute("id", gatewayCloseOutgoing.InnerText);
                sequenceFlow.SetAttribute("sourceRef", gatewayClose.GetAttribute("id"));
                process.AppendChild(sequenceFlow);

                #region XOR-if

                // Gateway open outgoing
                var gatewayOpenOutgoingIf = process.OwnerDocument.CreateElement("bpmn", "outgoing", BpmnUri);
                gatewayOpenOutgoingIf.InnerText = "SequenceFlow_" + Guid.NewGuid();
                gatewayOpen.AppendChild(gatewayOpenOutgoingIf);

                // Gateway open outgoing sequence
                var innerSequenceFlowIf = process.OwnerDocument.CreateElement("bpmn", "sequenceFlow", BpmnUri);
                innerSequenceFlowIf.SetAttribute("id", gatewayOpenOutgoingIf.InnerText);
                innerSequenceFlowIf.SetAttribute("sourceRef", gatewayOpen.GetAttribute("id"));
                process.AppendChild(innerSequenceFlowIf);

                // add name/decision to sequenceFlow
                innerSequenceFlowIf.SetAttribute("name", "==" + (gene as BpmnXor).ToProcessAttribute().DecisionValue);

                if (gene.Children == null || gene.Children.Count == 0 || gene.Children[0] == null)
                {
                    // gateway close incoming
                    var gatewayCloseIncomingIf = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                    gatewayCloseIncomingIf.InnerText = innerSequenceFlowIf.GetAttribute("id");
                    gatewayClose.AppendChild(gatewayCloseIncomingIf);

                    // gateway close incoming sequence
                    innerSequenceFlowIf.SetAttribute("targetRef", gatewayClose.GetAttribute("id"));
                }
                else
                {
                    innerSequenceFlowIf = GeneToXml(process, gene.Children[0], innerSequenceFlowIf);

                    // gateway close incoming
                    var gatewayCloseIncomingIf = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                    gatewayCloseIncomingIf.InnerText = innerSequenceFlowIf.GetAttribute("id");
                    gatewayClose.AppendChild(gatewayCloseIncomingIf);

                    // gateway close incoming sequence
                    innerSequenceFlowIf.SetAttribute("targetRef", gatewayClose.GetAttribute("id"));
                }

                #endregion

                #region XOR-else

                // Gateway open outgoing
                var gatewayOpenOutgoingElse = process.OwnerDocument.CreateElement("bpmn", "outgoing", BpmnUri);
                gatewayOpenOutgoingElse.InnerText = "SequenceFlow_" + Guid.NewGuid();
                gatewayOpen.AppendChild(gatewayOpenOutgoingElse);

                // Gateway open outgoing sequence
                var innerSequenceFlowElse = process.OwnerDocument.CreateElement("bpmn", "sequenceFlow", BpmnUri);
                innerSequenceFlowElse.SetAttribute("id", gatewayOpenOutgoingElse.InnerText);
                innerSequenceFlowElse.SetAttribute("sourceRef", gatewayOpen.GetAttribute("id"));
                process.AppendChild(innerSequenceFlowElse);

                // add name/decision to sequenceFlow
                innerSequenceFlowElse.SetAttribute("name", "<>" + (gene as BpmnXor).ToProcessAttribute().DecisionValue);

                if (gene.Children == null || gene.Children.Count < 2 || gene.Children[1] == null)
                {
                    // gateway close incoming
                    var gatewayCloseIncomingElse = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                    gatewayCloseIncomingElse.InnerText = innerSequenceFlowElse.GetAttribute("id");
                    gatewayClose.AppendChild(gatewayCloseIncomingElse);

                    // gateway close incoming sequence
                    innerSequenceFlowElse.SetAttribute("targetRef", gatewayClose.GetAttribute("id"));
                }
                else
                {
                    innerSequenceFlowElse = GeneToXml(process, gene.Children[1], innerSequenceFlowElse);

                    // gateway close incoming
                    var gatewayCloseIncomingElse = process.OwnerDocument.CreateElement("bpmn", "incoming", BpmnUri);
                    gatewayCloseIncomingElse.InnerText = innerSequenceFlowElse.GetAttribute("id");
                    gatewayClose.AppendChild(gatewayCloseIncomingElse);

                    // gateway close incoming sequence
                    innerSequenceFlowElse.SetAttribute("targetRef", gatewayClose.GetAttribute("id"));
                }

                #endregion

                return(sequenceFlow);
            }
            foreach (var child in gene.Children)
            {
                incomingSequence = GeneToXml(process, child, incomingSequence);
            }

            return(incomingSequence);
        }
Esempio n. 25
0
            private static void ValidateGenome(BpmGene gene, ref int failures,
                                               HashSet <BpmnObject> currentAvailableInput,
                                               HashSet <BpmnProcessAttribute> currentCoveredAttributes, int pathId, int numberOfPaths, int passedXors)
            {
                if (gene == null)
                {
                    return;
                }

                if (gene is BpmnActivity)
                {
                    var matchingAttributes =
                        DataHelper.CoverHelper.Instance().CoveredAttributes(((BpmnActivity)gene).Name);

                    var tmp = failures;

                    failures += currentCoveredAttributes.Count(x => !matchingAttributes.Contains(x));

                    if (tmp != failures)
                    {
                        return;
                    }

                    var input = DataHelper.ActivityInputHelper.Instance().RequiredInputObjects((BpmnActivity)gene);

                    failures += input.Count(x => !currentAvailableInput.Contains(x));

                    var output = DataHelper.ActivityOutputHelper.Instance().ProvidedOutputObjects((BpmnActivity)gene);
                    currentAvailableInput.UnionWith(output);

                    return;
                }

                if (gene is BpmnSeq)
                {
                    foreach (var child in gene.Children)
                    {
                        ValidateGenome(child, ref failures, currentAvailableInput, currentCoveredAttributes, pathId,
                                       numberOfPaths, passedXors);
                    }
                }

                if (gene is BpmnAnd)
                {
                    var preAndAvailableInput  = new HashSet <BpmnObject>(currentAvailableInput);
                    var postAndAvailableInput = new HashSet <BpmnObject>(currentAvailableInput);

                    foreach (var child in gene.Children)
                    {
                        var cloneCurrentAvailableInput    = new HashSet <BpmnObject>(preAndAvailableInput);
                        var cloneCurrentCoveredAttributes = new HashSet <BpmnProcessAttribute>(currentCoveredAttributes);
                        ValidateGenome(child, ref failures, cloneCurrentAvailableInput, cloneCurrentCoveredAttributes,
                                       pathId, numberOfPaths, passedXors);
                        postAndAvailableInput.UnionWith(cloneCurrentAvailableInput);
                    }

                    currentAvailableInput.UnionWith(postAndAvailableInput);
                }

                if (gene is BpmnXor)
                {
                    var xor = gene as BpmnXor;

                    // found XOR, follow decision by pathId and passedXors
                    var decisionBase = Convert.ToString(pathId, 2).PadLeft((int)Math.Log(numberOfPaths, 2), '0');
                    var decision     = decisionBase[passedXors] - '0'; // dirty trick
                    var attribute    = new BpmnProcessAttribute(xor.DecisionId, xor.DecisionValue,
                                                                DataHelper.ActivityAttributeHelper.Instance()
                                                                .GetDecisionProbability(xor.DecisionId, xor.DecisionValue));

                    passedXors++;

                    var ifCase = new HashSet <BpmnProcessAttribute>();
                    ifCase.Add(attribute);
                    var elseCase = new HashSet <BpmnProcessAttribute>(currentCoveredAttributes);
                    elseCase.Remove(attribute);

                    if (decision == 0)
                    {
                        ValidateGenome(gene.Children.ElementAtOrDefault(decision), ref failures, currentAvailableInput,
                                       ifCase, pathId, numberOfPaths, passedXors);
                    }

                    if (decision == 1)
                    {
                        ValidateGenome(gene.Children.ElementAtOrDefault(decision), ref failures, currentAvailableInput,
                                       elseCase, pathId, numberOfPaths, passedXors);
                    }
                }
            }
Esempio n. 26
0
            /// <summary>
            ///     Generates a valid random BpmnGenome.
            /// </summary>
            /// <returns>random tree.</returns>
            public static void GenerateRandomValidBpmGenome(int maxDepth, BpmGene parent, BpmGenome genome,
                                                            double executionProbability = 1)

            {
                if (parent is BpmnXor && parent.Children.Count > 2)
                {
                    Debug.WriteLine("halt stop! BpmnXor error");
                }

                BpmnXor xor = null;

                var allDecisions = DataHelper.ActivityAttributeHelper.Instance().GetAll();

                if (allDecisions.Count > 0)
                {
                    var selected = allDecisions.ElementAt(TreeHelper.RandomGenerator.Next(allDecisions.Count));
                    xor = new BpmnXor(-1, parent, selected.DecisionId, selected.DecisionValue);
                }

                // Choose a random gene from all available
                var gateways = new List <BpmGene>();

                if (xor != null)
                {
                    gateways.Add(xor);
                }
                gateways.Add(new BpmnAnd(-1, parent));
                gateways.Add(new BpmnSeq(-1, parent));

                var activities = new List <BpmnActivity>();

                foreach (var model in DataHelper.ActivityHelper.Instance().Models)
                {
                    activities.Add(new BpmnActivity(-1, parent, model.name));
                }

                var randomGene = ChooseRandomBpmnGene(gateways, activities);

                // Create genome if parent is null.
                if (parent == null)
                {
                    genome.RootGene = randomGene;

                    GenerateRandomValidBpmGenome(maxDepth - 1, randomGene, genome);
                }
                // Handle Gateways
                else if ((parent is BpmnAnd || parent is BpmnSeq || parent is BpmnXor) && maxDepth > 1)
                {
                    // Handle the deeper levels in the tree
                    if (parent is BpmnAnd)
                    {
                        // Add the random gene to parents children
                        parent.Children.Add(randomGene);
                        randomGene.Parent = parent;

                        // Choose a random number inclusive lower bound, exclusive upper bound.
                        var numberOfChildren = TreeHelper.RandomGenerator.Next(2, Math.Max(2, activities.Count));
                        // Recursive call for randomly chosen number.
                        for (var i = numberOfChildren - parent.Children.Count; i > 0; i--)
                        {
                            GenerateRandomValidBpmGenome(maxDepth - 1, randomGene, genome);
                        }
                    }
                    else if (parent is BpmnSeq)
                    {
                        // Add the random gene to parents children
                        parent.Children.Add(randomGene);
                        randomGene.Parent = parent;

                        // Choose a random number inclusive lower bound, exclusive upper bound.
                        var numberOfChildren = TreeHelper.RandomGenerator.Next(2, Math.Max(2, activities.Count));
                        // Recursive call for randomly chosen number.
                        for (var i = numberOfChildren - parent.Children.Count; i > 0; i--)
                        {
                            GenerateRandomValidBpmGenome(maxDepth - 1, randomGene, genome);
                        }
                    }
                    // BPMN-XOR
                    else if (parent is BpmnXor)
                    {
                        // TODO: At the moment only one Decision available.
                        // Get all available decision values.
                        var descitionValues =
                            DataHelper.ActivityAttributeHelper.Instance()
                            .GetDecisionValues(
                                DataHelper.ActivityAttributeHelper.Instance().GetAll().FirstOrDefault().DecisionId);
                        // Choos a random decision value.
                        var rand = TreeHelper.RandomGenerator.Next(descitionValues.Count);
                        // Get the probability of the randomly chosen value.
                        var randomExecProb =
                            DataHelper.ActivityAttributeHelper.Instance()
                            .GetDecisionProbability(
                                DataHelper.ActivityAttributeHelper.Instance().GetAll().FirstOrDefault().DecisionId,
                                descitionValues.ElementAt(rand));

                        if (parent.Children.Count < 2)
                        {
                            // Add the random gene to parents children
                            parent.Children.Add(randomGene);
                            randomGene.Parent = parent;
                        }

                        if (parent.Children.Count < 2)
                        {
                            GenerateRandomValidBpmGenome(maxDepth, parent, genome, randomExecProb);
                        }

                        GenerateRandomValidBpmGenome(maxDepth, randomGene, genome, randomExecProb);
                    }
                }
                else if ((parent is BpmnAnd || parent is BpmnSeq || parent is BpmnXor) && maxDepth == 1)
                {
                    if (parent is BpmnXor && parent.Children.Count < 2)
                    {
                        // Reached the maximum number of hirarchies. Leafs only can be Actions.
                        var activity = activities[TreeHelper.RandomGenerator.Next(activities.Count - 1)];

                        parent.Children.Add(activity);
                        activity.Parent = parent;
                    }
                }

                if (genome.RootGene.Children != null && maxDepth < 1)
                {
                    genome.RootGene.RenumberIndicesOfBpmTree(gen => gen.Children);
                }
            }
Esempio n. 27
0
            /// <summary>
            ///     generates a random valid bpm genome, using the greedy-algo.
            ///     activities creating new objects are prefered over the rest
            /// </summary>
            /// <param name="maxDepth"></param>
            /// <param name="parent"></param>
            /// <param name="availableBpmnObjects"></param>
            /// <param name="currentAttributesToCover"></param>
            /// <returns></returns>
            /// <exception cref="ArgumentNullException"></exception>
            public static BpmGene GenerateRandomValidBpmGenome2(int maxDepth, BpmGene parent,
                                                                HashSet <BpmnObject> availableBpmnObjects = null,
                                                                HashSet <BpmnProcessAttribute> currentAttributesToCover = null)
            {
                if (parent == null)
                {
                    availableBpmnObjects     = DataHelper.ObjectHelper.Instance().GetProcessInput();
                    currentAttributesToCover = DataHelper.ActivityAttributeHelper.Instance().GetAll();
                }

                if (availableBpmnObjects == null || currentAttributesToCover == null)
                {
                    throw new ArgumentNullException(nameof(availableBpmnObjects) + " or " +
                                                    nameof(currentAttributesToCover));
                }

                var currentDepth = parent.CalculateNodeDepth();

                BpmGene randomGene = null;

                do
                {
                    if (currentDepth == maxDepth)
                    {
                        randomGene = GenerateRandomActivity(availableBpmnObjects, currentAttributesToCover);
                    }
                    else
                    {
                        randomGene = GenerateRandomBpmGene(availableBpmnObjects, currentAttributesToCover);
                    }
                } while (parent == null && randomGene == null);

                if (randomGene == null)
                {
                    return(null);
                }

                randomGene.Parent = parent;

                if (randomGene is BpmnActivity)
                {
                    var output = DataHelper.ActivityOutputHelper.Instance()
                                 .ProvidedOutputObjects((BpmnActivity)randomGene);
                    availableBpmnObjects.UnionWith(output);
                }

                var numberOfChildren = randomGene.GetType().CalculateRandomNumberOfChildren();

                if (randomGene is BpmnXor && numberOfChildren > 0)
                {
                    // randomly xor created
                    var xor = randomGene as BpmnXor;

                    // divide attributes by this ID and Value
                    var selectiveAttribute = new BpmnProcessAttribute(xor.DecisionId, xor.DecisionValue,
                                                                      xor.ExecutionProbability);

                    var attributesIfCase   = new HashSet <BpmnProcessAttribute>();
                    var attributesElseCase = new HashSet <BpmnProcessAttribute>();

                    // divide attributes into two buckets for ongoing process
                    foreach (var attribute in currentAttributesToCover)
                    {
                        if (selectiveAttribute.DecisionId.Equals(attribute.DecisionId) &&
                            !selectiveAttribute.DecisionValue.Equals(attribute.DecisionValue))
                        {
                            attributesElseCase.Add(attribute);
                        }
                        else
                        {
                            attributesIfCase.Add(attribute);
                        }
                    }

                    // create new sets of bpmnobjects for both cases
                    var availableBpmnObjectsIf   = new HashSet <BpmnObject>(availableBpmnObjects);
                    var availableBpmnObjectsElse = new HashSet <BpmnObject>(availableBpmnObjects);

                    // add the first child
                    var randomSubtreeIf = GenerateRandomValidBpmGenome2(maxDepth, randomGene, availableBpmnObjectsIf,
                                                                        attributesIfCase);
                    xor.Children.Add(randomSubtreeIf);

                    if (numberOfChildren > 1)
                    {
                        // add a second child
                        var randomSubtreeElse = GenerateRandomValidBpmGenome2(maxDepth, randomGene,
                                                                              availableBpmnObjectsElse,
                                                                              attributesElseCase);
                        xor.Children.Add(randomSubtreeElse);
                    }

                    // collect the available objects from both paths
                    // TODO possible logic error, if both paths do not create the same output
                    availableBpmnObjects.UnionWith(availableBpmnObjectsIf);
                    availableBpmnObjects.UnionWith(availableBpmnObjectsElse);
                }

                if (randomGene is BpmnSeq || randomGene is BpmnAnd)
                {
                    for (var i = 0; i < numberOfChildren; i++)
                    {
                        var availableBpmnObjectsChild = new HashSet <BpmnObject>(availableBpmnObjects);

                        var createdSubTree = GenerateRandomValidBpmGenome2(maxDepth, randomGene,
                                                                           availableBpmnObjectsChild, currentAttributesToCover);

                        if (createdSubTree == null)
                        {
                            Debug.WriteLine("halt");
                        }
                        randomGene.Children.Add(createdSubTree);

                        if (randomGene is BpmnSeq)
                        {
                            availableBpmnObjects.UnionWith(availableBpmnObjectsChild);
                        }
                    }
                }

                if (parent == null)
                {
                    randomGene.RenumberIndicesOfBpmTree(gene => gene.Children);
                }

                return(randomGene);
            }
            private Dimension AddGene(BpmGene gene, int x, int y)
            {
                if (gene is BpmnAnd)
                {
                    var dim = new Dimension();

                    var and = And(gene);
                    matrix[x][y] = and;

                    AddColumn();

                    AddRow(gene.Children.Count - 1);

                    foreach (var child in gene.Children)
                    {
                        var d = AddGene(child, x + dim.height, y + 1);
                        dim.width   = Math.Max(dim.width, d.width);
                        dim.height += d.height;
                    }

                    AddColumn();

                    var and2 = And(gene, false);
                    matrix[x][y + 1 + dim.width] = and2;

                    dim.width += 2;

                    return(dim);
                }
                if (gene is BpmnXor)
                {
                    var dim = new Dimension();

                    var xor = Xor(gene);
                    matrix[x][y] = xor;

                    AddColumn();

                    AddRow(1);

                    if (gene.Children == null || gene.Children.Count == 0)
                    {
                        // nothind to do
                    }
                    else if (gene.Children.Count == 1)
                    {
                        // only one child -> first the empty one
                        dim.height += 1; // add empty row for straight line

                        // now the regular genes
                        var d = AddGene(gene.Children[0], x + dim.height, y + 1);
                        dim.width   = Math.Max(dim.width, d.width);
                        dim.height += d.height;
                    }
                    else if (gene.Children[0] != null && gene.Children[1] != null)
                    {
                        // if
                        var d1 = AddGene(gene.Children[0], x + dim.height, y + 1);
                        dim.width   = Math.Max(dim.width, d1.width);
                        dim.height += d1.height;

                        // else
                        var d2 = AddGene(gene.Children[1], x + dim.height, y + 1);
                        dim.width   = Math.Max(dim.width, d2.width);
                        dim.height += d2.height;
                    }
                    else
                    {
                        // if == null && else != null
                        // only one child -> first the empty one
                        dim.height += 1; // add empty row for straight line

                        // now the regular genes
                        var d = AddGene(gene.Children[0], x + dim.height, y + 1);
                        dim.width   = Math.Max(dim.width, d.width);
                        dim.height += d.height;
                    }

                    AddColumn();

                    var xor2 = Xor(gene, false);
                    matrix[x][y + 1 + dim.width] = xor2;

                    dim.width += 2;

                    return(dim);
                }
                if (gene is BpmnSeq)
                {
                    var dim = new Dimension();

                    foreach (var child in gene.Children)
                    {
                        var d = AddGene(child, x, y + dim.width);
                        dim.width += d.width;
                        dim.height = Math.Max(dim.height, d.height);

                        AddColumn();
                    }

                    return(dim);
                }
                var activity = Activity(gene);

                matrix[x][y] = activity;

                return(new Dimension {
                    width = 1, height = 1
                });
            }
Esempio n. 29
0
 public BpmnSeq(int index, BpmGene parent) : base(index, parent)
 {
 }
Esempio n. 30
0
 public BpmnSeq(int index, BpmGene parent, double executionProbability) : base(index, parent)
 {
     ExecutionProbability = executionProbability;
 }