diff --git a/examples/dcr_examples.py b/examples/dcr_examples.py new file mode 100644 index 0000000000..31d5f9ec3d --- /dev/null +++ b/examples/dcr_examples.py @@ -0,0 +1,88 @@ +import pm4py +import os + +def execute_discover(): + """ + example script to discover dcr graph from event log + """ + + log = pm4py.read_xes(os.path.join("..","tests","input_data","running-example.xes")) + + #return the graph and the log abstraction used for mining + graph, _ = pm4py.discover_dcr(log) + print(graph) + +def execute_discover_roles(): + """ + example script to discover dcr graph with orginazational information + """ + log = pm4py.read_xes(os.path.join("..","tests","input_data","running-example.xes")) + # is initaitad with the set of wanted post process types after the original discover miner + # if no standard default group key is present, but org:resource is present, can specify + graph, _ = pm4py.discover_dcr(log, post_process={'distributed'}, group_key='org:resource') + print(graph) + +def execute_dcr_conformance(): + """ + example script of how to call and check for conformance of dcr graph + """ + log = pm4py.read_xes(os.path.join("..","tests","input_data","receipt.xes")) + + # is initaitad with the set of wanted post process types after the original discover miner + # if no standard default group key is present, but org:resource is present, can specify to mine org:resource as distributed + graph_base, _ = pm4py.discover_dcr(log) + graph_roles, _ = pm4py.discover_dcr(log, post_process={'distributed'}) + + #DisCoveR discovers a perfect fitting graph from event log + conf_res_base = pm4py.conformance_dcr(log, graph_base, return_diagnostics_dataframe=True) + print(conf_res_base) + + log.replace("Group 1",float("nan")) + + #if distributed are present in the graph, will then by default check conformance for correct assignment of distributed to activities + #dropped a role, cause deviation + conf_res_roles = pm4py.conformance_dcr(log, graph_base, return_diagnostics_dataframe=True) + print("both runs") + print(conf_res_roles) + +def execute_dcr_alignment(): + """ + run of the alignment of dcr graphs + + """ + log = pm4py.read_xes(os.path.join("..","tests","input_data","running-example.xes")) + + #discover base dcr graph, does not support dcr graphs with distributed + graph, _ = pm4py.discover_dcr(log) + + align_res = pm4py.optimal_alignment_dcr(log, graph,return_diagnostics_dataframe=True) + print(align_res) + + #work with the visualization + align_res = pm4py.optimal_alignment_dcr(log, graph) + + #works with view_alignments() + pm4py.view_alignments(log, align_res, format='svg') + +def execute_import_export(): + """ + import and export of dcr graphs + """ + from pm4py.objects.dcr.exporter.exporter import Variants + log = pm4py.read_xes(os.path.join("..","tests","input_data","running-example.xes")) + graph, _ = pm4py.discover_dcr(log) + + #currently only support the base dcr graph + pm4py.write_dcr_xml(graph,path=os.path.join("..","tests","test_output_data","dcr.xml"), + variant=Variants.XML_DCR_PORTAL, dcr_title="dcr graph of running-example") + + graph = pm4py.read_dcr_xml(file_path=os.path.join("..","tests","test_output_data","dcr.xml")) + print(graph) + + +if __name__ == "__main__": + execute_discover() + execute_discover_roles() + execute_dcr_alignment() + execute_dcr_conformance() + execute_import_export() diff --git a/notebooks/dcr_tutorial.ipynb b/notebooks/dcr_tutorial.ipynb new file mode 100644 index 0000000000..308960d385 --- /dev/null +++ b/notebooks/dcr_tutorial.ipynb @@ -0,0 +1,1264 @@ +{ + "cells": [ + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-29T13:08:42.836844Z", + "start_time": "2024-08-29T13:08:42.828386Z" + } + }, + "cell_type": "code", + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "import os\n", + "print(os.getcwd())\n", + "to_run = True\n", + "if to_run:\n", + " os.chdir('..')\n", + " to_run = False\n", + "print(os.getcwd())" + ], + "id": "9973de9586145751", + "outputs": [], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "id": "b0835f4561911fc4", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-20T16:46:33.788284Z", + "start_time": "2024-08-20T16:46:33.771689Z" + } + }, + "source": [ + "# DCR Extension Tutorial" + ] + }, + { + "cell_type": "markdown", + "id": "92e888eb1a2fdfc2", + "metadata": { + "collapsed": false + }, + "source": [ + "This file will give a walkthrough of the extension that has been made for the PM4Py library.\n", + "Namely, it will go through how to create a DCR Graph, either manually or automatically by the implemented DisCoveR algorithm, showcase how conformance checking can be used to determine fitness, and finally present the import/export capability such that the graph can be visualised.\n", + "\n", + "\n", + "## Creating DCR Graphs\n", + "First, let's take a look at how to create a basic DCR Graph manually. Note that the underlying attribute in the DCR graph objects consists of sets and dictionaries, so one can access them through the property, and call them as such:" + ] + }, + { + "cell_type": "code", + "id": "2972ccdfc1e5d0aa", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:10:59.945503Z", + "start_time": "2024-08-29T13:10:59.892917Z" + } + }, + "source": [ + "import pandas as pd\n", + "\n", + "import pm4py\n", + "from pm4py.objects.dcr.obj import DcrGraph\n", + "graph = DcrGraph()\n", + "graph.events.add(\"activity1\")\n", + "graph.events.add(\"activity2\")\n", + "graph.events.add(\"activity3\")\n", + "graph.events.add(\"activity4\")\n", + "graph.labels.add(\"A\")\n", + "graph.labels.add(\"B\")\n", + "graph.labels.add(\"C\")\n", + "graph.labels.add(\"D\")\n", + "graph.label_map[\"activity1\"] = \"A\"\n", + "graph.label_map[\"activity2\"] = \"B\"\n", + "graph.label_map[\"activity3\"] = \"C\"\n", + "graph.label_map[\"activity4\"] = \"D\"\n", + "graph.conditions[\"activity1\"] = {\"activity2\"}\n", + "graph.conditions[\"activity2\"] = {\"activity3\"}\n", + "graph.responses[\"activity1\"] = {\"activity3\"}\n", + "graph.excludes[\"activity3\"] = {\"activity3\"}\n", + "graph.conditions[\"activity1\"] = {\"activity4\"}\n", + "graph.includes[\"activity3\"] = {\"activity2\"}\n", + "graph.marking.included.add(\"activity1\")\n", + "graph.marking.included.add(\"activity3\")\n", + "graph.marking.included.add(\"activity4\")\n", + "graph.marking.executed.add(\"activity1\")\n", + "graph.marking.executed.add(\"activity4\")\n", + "graph.marking.pending.add(\"activity3\")\n", + "pm4py.view_dcr(graph)" + ], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 10 + }, + { + "cell_type": "markdown", + "id": "2e88e21f11d08406", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-20T16:46:24.797688Z", + "start_time": "2024-08-20T16:46:23.766398Z" + } + }, + "source": "When the graph has been constructed, one has access to the following commands to get the different properties of the DCR graph, such as the size defined by the number of constraints, the events associated with the activity or vice versa." + }, + { + "cell_type": "code", + "id": "517261d9a8d4c277", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:09:02.990Z", + "start_time": "2024-08-29T13:09:02.975446Z" + } + }, + "source": [ + "print(graph.get_constraints())\n", + "print(graph.get_activity(\"activity1\"))\n", + "print(graph.get_event(\"A\"))\n", + "del graph" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "A\n", + "activity1\n" + ] + } + ], + "execution_count": 3 + }, + { + "cell_type": "markdown", + "id": "b7fca04ece1bedbc", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-20T16:46:31.026856Z", + "start_time": "2024-08-20T16:46:31.002511Z" + } + }, + "source": [ + "If one calls get_event() or get_activity() with a value that doesn't exist, it will return the input value. This was implemented for the conformance checking, since if someone tries to get the labelMapping but the event doesn't exist, the test would be interrupted. This way, if it doesn't exist, it will be noted by the conformance tools and be used in the conformance result.\n", + "\n", + "Now to discover a model with a given input log, a simplified interface has been created, such that the implemented algorithms are easily accessible, and therefore allow for a more simplified and straightforward use." + ] + }, + { + "cell_type": "code", + "id": "889075c8d92e5351", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:09:38.198668Z", + "start_time": "2024-08-29T13:09:38.037043Z" + } + }, + "source": [ + "import pm4py\n", + "log = pm4py.read_xes(\"tests/input_data/running-example.xes\")\n", + "graph, _ = pm4py.discover_dcr(log) \n", + "pm4py.view_dcr(graph) \n", + "del graph" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "parsing log, completed traces :: 0%| | 0/6 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 4 + }, + { + "cell_type": "markdown", + "id": "6758fef174f46939", + "metadata": { + "collapsed": false + }, + "source": [ + "In accordance to the rest of the library, the simplified interface takes in extra values for which one can use to specify the naming convention in the attribute, such that it can mine the log without failure.\n", + "\n", + "Additionally, the discover miner has been extended to allow for mining of roles; we will use the log of the running example once again." + ] + }, + { + "cell_type": "code", + "id": "b9a23f1be475cdbd", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:09:45.446825Z", + "start_time": "2024-08-29T13:09:45.331301Z" + } + }, + "source": [ + "graph, _ = pm4py.discover_dcr(log,post_process={\"roles\"},group_key=\"org:resource\")\n", + "pm4py.view_dcr(graph)\n", + "del graph" + ], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 + }, + { + "cell_type": "markdown", + "id": "35aa578ba35bd297", + "metadata": { + "collapsed": false + }, + "source": [ + "If one doesn't wish to use the simplified interface, there is a more indirect way of performing the process mining technique" + ] + }, + { + "cell_type": "code", + "id": "3a3706bc019a7a47", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:10:10.608301Z", + "start_time": "2024-08-29T13:10:10.592515Z" + } + }, + "source": [ + "from pm4py.algo.discovery.dcr_discover.variants.dcr_discover import Discover\n", + "from pm4py.objects.dcr.obj import DcrGraph\n", + "disc = Discover()\n", + "graph = DcrGraph(disc.mine(log)[0])\n", + "del log\n", + "del graph" + ], + "outputs": [], + "execution_count": 6 + }, + { + "cell_type": "markdown", + "id": "39fe0acb8c28b80a", + "metadata": { + "collapsed": false + }, + "source": [ + "Note that the discover miner also returns the abstraction log used for mining the DCR Graph, therefore it is needed to perform to specify the first iterative of the tuple." + ] + }, + { + "cell_type": "markdown", + "id": "82716ebaf4e2c773", + "metadata": { + "collapsed": false + }, + "source": [ + "## Conformance Checking\n", + "Two different techniques for checking conformance of a DCR graph have been implemented\n", + "### Rule Checking\n", + "The first technique is a quite straight forward approach. It takes an event log, and mines based on the constraints within the graph. This technique takes in a whole log and produces an output: a list of dictionaries of the values associated with the mining:" + ] + }, + { + "cell_type": "code", + "id": "1041d9ed2799711", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:11:44.180455Z", + "start_time": "2024-08-29T13:11:44.146915Z" + } + }, + "source": [ + "log = pm4py.read_xes(\"tests/input_data/running-example.xes\")\n", + "graph, _ = pm4py.discover_dcr(log)\n", + "conf_res = pm4py.conformance_dcr(log, graph, return_diagnostics_dataframe=True)\n", + "conf_res" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "parsing log, completed traces :: 0%| | 0/6 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
case_idno_dev_totalno_constr_totaldev_fitness
030281.0
120281.0
210281.0
360281.0
450281.0
540281.0
\n", + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 13 + }, + { + "cell_type": "markdown", + "id": "fcc271473f1514c7", + "metadata": { + "collapsed": false + }, + "source": [ + "Due to the DisCoveR miner's property of always producing a graph with perfect fitness, the output will therefore have no deviations. In addition to mining of DCR graphs, it is also possible to check for deviations in role assignment." + ] + }, + { + "cell_type": "code", + "id": "d1b20b34b6293d26", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:11:47.543422Z", + "start_time": "2024-08-29T13:11:47.509682Z" + } + }, + "source": [ + "# Given an event log and discovering a dcr\n", + "log = pm4py.read_xes(\"tests/input_data/running-example.xes\")\n", + "graph, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key=\"org:resource\")\n", + "\n", + "# when the roles are changed and conformance is performed\n", + "log = log.replace(\"Mike\", \"Brenda\")\n", + "conf_res = pm4py.conformance_dcr(log, graph, group_key=\"org:resource\", return_diagnostics_dataframe=True)\n", + "conf_res" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "parsing log, completed traces :: 0%| | 0/6 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
case_idno_dev_totalno_constr_totaldev_fitness
031470.978723
121470.978723
211470.978723
361470.978723
451470.978723
541470.978723
\n", + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 14 + }, + { + "cell_type": "markdown", + "id": "6c53b5124f7575f8", + "metadata": { + "collapsed": false + }, + "source": "Just like in the previous example, one can call the underlying algorithm directly if they wish to do so. In this case, one can call the class used for conformance checking:" + }, + { + "cell_type": "code", + "id": "a8f73c6174f8b8eb", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:11:49.737941Z", + "start_time": "2024-08-29T13:11:49.710041Z" + } + }, + "source": [ + "from pm4py.algo.conformance.dcr.variants.classic import RuleBasedConformance\n", + "parameters = pm4py.utils.get_properties(log,group_key=\"org:resource\")\n", + "rulecheck = RuleBasedConformance(log, graph,parameters)\n", + "conf_res = rulecheck.apply_conformance()\n", + "pd.DataFrame(conf_res)" + ], + "outputs": [ + { + "data": { + "text/plain": [ + " no_constr_total deviations no_dev_total dev_fitness \\\n", + "0 47 [(roleViolation, Brenda)] 1 0.978723 \n", + "1 47 [(roleViolation, Brenda)] 1 0.978723 \n", + "2 47 [(roleViolation, Brenda)] 1 0.978723 \n", + "3 47 [(roleViolation, Brenda)] 1 0.978723 \n", + "4 47 [(roleViolation, Brenda)] 1 0.978723 \n", + "5 47 [(roleViolation, Brenda)] 1 0.978723 \n", + "\n", + " is_fit \n", + "0 False \n", + "1 False \n", + "2 False \n", + "3 False \n", + "4 False \n", + "5 False " + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
no_constr_totaldeviationsno_dev_totaldev_fitnessis_fit
047[(roleViolation, Brenda)]10.978723False
147[(roleViolation, Brenda)]10.978723False
247[(roleViolation, Brenda)]10.978723False
347[(roleViolation, Brenda)]10.978723False
447[(roleViolation, Brenda)]10.978723False
547[(roleViolation, Brenda)]10.978723False
\n", + "
" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 15 + }, + { + "cell_type": "markdown", + "id": "3e8e8070f5d2d7e0", + "metadata": { + "collapsed": false + }, + "source": [ + "### Alignment\n", + "\n", + "The extension also allows for determining the optimal alignment of a DCR Graph." + ] + }, + { + "cell_type": "code", + "id": "25cb7003a11e3599", + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-08-29T13:17:41.811607Z", + "start_time": "2024-08-29T13:17:41.775835Z" + } + }, + "source": [ + "log = pm4py.read_xes(\"tests/input_data/running-example.xes\")\n", + "graph, _ = pm4py.discover_dcr(log)\n", + "align_res = pm4py.optimal_alignment_dcr(log, graph)\n", + "align_res" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "parsing log, completed traces :: 0%| | 0/6 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
case_idcostfitnessis_fit
0301.0True
1201.0True
2101.0True
3601.0True
4501.0True
5401.0True
\n", + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 17 + }, + { + "cell_type": "markdown", + "id": "4cd31a5cb58c4347", + "metadata": {}, + "source": [ + "## Importing/Exporting DCR Graphs\n", + "We can visualise the mined DCR graph in third party applications by exporting it as an 'xml' file and then viewing it at the corresponding portal." + ] + }, + { + "cell_type": "code", + "id": "23a596df28e9ee68", + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-29T13:18:07.398124Z", + "start_time": "2024-08-29T13:18:07.368968Z" + } + }, + "source": [ + "import pm4py\n", + "from pm4py.objects.dcr.exporter import exporter as dcr_exporter\n", + "log = pm4py.read_xes(\"tests/input_data/running-example.xes\")\n", + "graph, _ = pm4py.discover_dcr(log)\n", + "path = 'tests/test_output_data/dcrgraph.xml'\n", + "pm4py.write_dcr_xml(graph, path, variant=dcr_exporter.DCR_JS_PORTAL, dcr_title='dcrgraph', replace_whitespace=' ')" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "parsing log, completed traces :: 0%| | 0/6 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 19 + }, + { + "cell_type": "markdown", + "id": "be1ec77305198f0c", + "metadata": {}, + "source": [ + "One can alter the graph using the DCR-js tool and then import it back into PM4Py for further manipulation, for instance checking the alignment of the new model." + ] + }, + { + "cell_type": "code", + "id": "314e69a3a1cb7632", + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-29T13:19:51.913816Z", + "start_time": "2024-08-29T13:19:51.789923Z" + } + }, + "source": [ + "path_edited = 'tests/test_output_data/dcrgraph_edited.xml'\n", + "graph_edited = pm4py.read_dcr_xml(path_edited, variant=dcr_importer.DCR_JS_PORTAL)\n", + "pm4py.view_dcr(graph_edited)\n", + "align_res = pm4py.optimal_alignment_dcr(log, graph_edited, return_diagnostics_dataframe=True)\n", + "align_res" + ], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " case_id cost fitness is_fit\n", + "0 3 3 0.666667 False\n", + "1 2 1 0.800000 False\n", + "2 1 1 0.800000 False\n", + "3 6 1 0.800000 False\n", + "4 5 5 0.615385 False\n", + "5 4 1 0.800000 False" + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
case_idcostfitnessis_fit
0330.666667False
1210.800000False
2110.800000False
3610.800000False
4550.615385False
5410.800000False
\n", + "
" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 20 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# Convert to Petri Net", + "id": "c8573c3b09b548d0" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-29T13:20:57.176797Z", + "start_time": "2024-08-29T13:20:56.497103Z" + } + }, + "cell_type": "code", + "source": [ + "import pm4py\n", + "log = pm4py.read_xes(\"tests/input_data/roadtraffic100traces.xes\")\n", + "dcr, _ = pm4py.discover_dcr(log)\n", + "pm4py.view_dcr(dcr)\n", + "net, im, fm = pm4py.convert_to_petri_net(dcr,debug=False,preoptimize=True,postoptimize=True)\n", + "pm4py.view_petri_net(net,im,fm)" + ], + "id": "bdc5be5938573d45", + "outputs": [ + { + "data": { + "text/plain": [ + "parsing log, completed traces :: 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 21 + }, + { + "cell_type": "code", + "id": "fe7a928f37270717", + "metadata": { + "ExecuteTime": { + "end_time": "2024-08-29T13:21:43.073631Z", + "start_time": "2024-08-29T13:21:43.051297Z" + } + }, + "source": [ + "# cleanup\n", + "import os\n", + "os.remove(path)\n", + "os.remove(path_edited)" + ], + "outputs": [], + "execution_count": 22 + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + }, + "id": "1de462ee1a6fcf47" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pm4py/__init__.py b/pm4py/__init__.py index bdf38b3d43..13858469c3 100644 --- a/pm4py/__init__.py +++ b/pm4py/__init__.py @@ -18,8 +18,8 @@ from pm4py import util, objects, statistics, algo, visualization, llm, connectors from pm4py import analysis, conformance, convert, discovery, filtering, hof, ml, ocel, org, read, sim, stats, utils, vis, write -from pm4py.read import read_xes, read_dfg, read_bpmn, read_pnml, read_ptml, read_ocel, read_ocel_csv, read_ocel_xml, read_ocel_json, read_ocel_sqlite, read_ocel2, read_ocel2_sqlite, read_ocel2_json, read_ocel2_xml -from pm4py.write import write_xes, write_dfg, write_bpmn, write_pnml, write_ptml, write_ocel, write_ocel_json, write_ocel_csv, write_ocel_xml, write_ocel_sqlite, write_ocel2, write_ocel2_sqlite, write_ocel2_xml, write_ocel2_json +from pm4py.read import read_xes, read_dfg, read_bpmn, read_pnml, read_ptml, read_ocel, read_ocel_csv, read_ocel_xml, read_ocel_json, read_ocel_sqlite, read_ocel2, read_ocel2_sqlite, read_ocel2_json, read_ocel2_xml, read_dcr_xml +from pm4py.write import write_xes, write_dfg, write_bpmn, write_pnml, write_ptml, write_ocel, write_ocel_json, write_ocel_csv, write_ocel_xml, write_ocel_sqlite, write_ocel2, write_ocel2_sqlite, write_ocel2_xml, write_ocel2_json, write_dcr_xml from pm4py.utils import format_dataframe, parse_process_tree, serialize, deserialize, set_classifier, parse_event_log_string, project_on_event_attribute, \ sample_cases, sample_events, rebase, parse_powl_model_string from pm4py.filtering import filter_log_relative_occurrence_event_attribute, filter_start_activities, filter_end_activities, filter_variants, \ @@ -35,13 +35,13 @@ discover_petri_net_inductive, discover_process_tree_inductive, discover_heuristics_net, \ discover_dfg, discover_footprints, discover_eventually_follows_graph, discover_directly_follows_graph, discover_bpmn_inductive, \ discover_performance_dfg, discover_transition_system, discover_prefix_tree, \ - discover_temporal_profile, discover_log_skeleton, discover_batches, derive_minimum_self_distance, discover_dfg_typed, discover_declare, discover_powl + discover_temporal_profile, discover_log_skeleton, discover_batches, derive_minimum_self_distance, discover_dfg_typed, discover_declare, discover_powl, discover_dcr from pm4py.conformance import conformance_diagnostics_token_based_replay, conformance_diagnostics_alignments, \ fitness_token_based_replay, \ fitness_alignments, precision_token_based_replay, \ precision_alignments, conformance_diagnostics_footprints, \ fitness_footprints, precision_footprints, check_is_fitting, conformance_temporal_profile, \ - conformance_declare, conformance_log_skeleton, replay_prefix_tbr, generalization_tbr + conformance_declare, conformance_log_skeleton, replay_prefix_tbr, generalization_tbr, conformance_dcr, optimal_alignment_dcr from pm4py.ocel import ocel_objects_interactions_summary, ocel_temporal_summary, ocel_objects_summary, ocel_get_object_types, ocel_get_attribute_names, ocel_flattening, ocel_object_type_activities, ocel_objects_ot_count, \ discover_ocdfg, discover_oc_petri_net, discover_objects_graph, sample_ocel_objects, ocel_drop_duplicates, ocel_merge_duplicates, ocel_sort_by_additional_column, \ ocel_add_index_based_timedelta, sample_ocel_connected_components, ocel_o2o_enrichment, ocel_e2o_lifecycle_enrichment, cluster_equivalent_ocel @@ -52,7 +52,7 @@ save_vis_events_per_time_graph, view_events_distribution_graph, save_vis_events_distribution_graph, view_performance_dfg, save_vis_performance_dfg, \ view_ocpn, save_vis_ocpn, view_network_analysis, save_vis_network_analysis, view_transition_system, save_vis_transition_system, \ view_prefix_tree, save_vis_prefix_tree, view_object_graph, save_vis_object_graph, view_alignments, save_vis_alignments, \ - view_footprints, save_vis_footprints, view_powl, save_vis_powl + view_footprints, save_vis_footprints, view_powl, save_vis_powl, view_dcr, save_vis_dcr from pm4py.convert import convert_to_event_log, convert_to_event_stream, convert_to_dataframe, convert_to_bpmn, \ convert_to_petri_net, convert_to_process_tree, convert_to_reachability_graph, convert_log_to_ocel, convert_ocel_to_networkx, convert_log_to_networkx, \ convert_log_to_time_intervals, convert_petri_net_to_networkx, convert_petri_net_type @@ -78,5 +78,6 @@ from pm4py.objects.process_tree.obj import ProcessTree from pm4py.objects.ocel.obj import OCEL from pm4py.objects.bpmn.obj import BPMN +from pm4py.objects.dcr.obj import DcrGraph time.clock = time.process_time diff --git a/pm4py/algo/conformance/alignments/dcr/__init__.py b/pm4py/algo/conformance/alignments/dcr/__init__.py new file mode 100644 index 0000000000..f6b0989ee1 --- /dev/null +++ b/pm4py/algo/conformance/alignments/dcr/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.conformance.alignments.dcr import variants, algorithm diff --git a/pm4py/algo/conformance/alignments/dcr/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/conformance/alignments/dcr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..002954308c Binary files /dev/null and b/pm4py/algo/conformance/alignments/dcr/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/alignments/dcr/__pycache__/algorithm.cpython-311.pyc b/pm4py/algo/conformance/alignments/dcr/__pycache__/algorithm.cpython-311.pyc new file mode 100644 index 0000000000..d731b53e5b Binary files /dev/null and b/pm4py/algo/conformance/alignments/dcr/__pycache__/algorithm.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/alignments/dcr/algorithm.py b/pm4py/algo/conformance/alignments/dcr/algorithm.py new file mode 100644 index 0000000000..6bbc9e2ffd --- /dev/null +++ b/pm4py/algo/conformance/alignments/dcr/algorithm.py @@ -0,0 +1,60 @@ +from pm4py.algo.conformance.alignments.dcr.variants import optimal +from enum import Enum +from pm4py.util import exec_utils +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.objects.log.obj import EventLog, Trace +from typing import Optional, Dict, Any, Union, Tuple, List +from pm4py.util import typing +import pandas as pd + + +class Variants(Enum): + OPTIMAL = optimal + + +def apply(obj: Union[EventLog, Trace], G: DcrGraph, variant=Variants.OPTIMAL, parameters: Optional[Dict[Any, Any]] = None) -> Union[typing.AlignmentResult, typing.ListAlignments]: + """ + Applies the alignment algorithm provided a log/trace object, and a DCR graph. + + Parameters + -------------- + obj + Event log / Trace + G + DCR graph + variant + Variant of the DCR alignments to be used. Possible values: + - Variants.OPTIMAL + parameters + Variant-specific parameters. + + Returns + -------------- + ali + Result of the alignment + """ + return exec_utils.get_variant(variant).apply(obj, G, parameters=parameters) + + +def get_diagnostics_dataframe(log: Union[EventLog, pd.DataFrame], conf_result: List[Dict[str, Any]], variant=Variants.OPTIMAL, parameters=None) -> pd.DataFrame: + """ + Gets the diagnostics dataframe from a log and the conformance results + + Parameters + -------------- + log + Event log + conf_result + Results of conformance checking + variant + Variant to be used: + - Variants.CLASSIC + parameters + Variant-specific parameters + + Returns + -------------- + diagn_dataframe + Diagnostics dataframe + """ + return exec_utils.get_variant(variant).get_diagnostics_dataframe(log, conf_result, parameters) \ No newline at end of file diff --git a/pm4py/algo/conformance/alignments/dcr/variants/__init__.py b/pm4py/algo/conformance/alignments/dcr/variants/__init__.py new file mode 100644 index 0000000000..6b4de5c8cf --- /dev/null +++ b/pm4py/algo/conformance/alignments/dcr/variants/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.conformance.alignments.dcr.variants import optimal \ No newline at end of file diff --git a/pm4py/algo/conformance/alignments/dcr/variants/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/conformance/alignments/dcr/variants/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..417b667e25 Binary files /dev/null and b/pm4py/algo/conformance/alignments/dcr/variants/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/alignments/dcr/variants/__pycache__/optimal.cpython-311.pyc b/pm4py/algo/conformance/alignments/dcr/variants/__pycache__/optimal.cpython-311.pyc new file mode 100644 index 0000000000..f6e38ce3a0 Binary files /dev/null and b/pm4py/algo/conformance/alignments/dcr/variants/__pycache__/optimal.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/alignments/dcr/variants/optimal.py b/pm4py/algo/conformance/alignments/dcr/variants/optimal.py new file mode 100644 index 0000000000..94f6bfc140 --- /dev/null +++ b/pm4py/algo/conformance/alignments/dcr/variants/optimal.py @@ -0,0 +1,785 @@ +""" +This module contains the object-oriented implementation of the Optimal Alignments algorithm, +based on the paper by Axel Kjeld Fjelrad Christfort and Tijs Slaats [1]. + +Overview: +The implementation encapsulates the core components of the algorithm and provides. + +The calculation of the alignments and graph-trace handling are encapsulated in separate, +dedicated classes, thereby facilitating modularity and reuse. +Central to the module are the following classes: + +- `LogAlignment`: A simplified interface to perform optimal alignment through the other classes. +- `TraceAlignment`: Serves as the primary interface for interacting with the algorithm. + orchestrating the alignment process and providing access to performance metrics. +- `TraceHandler`: Manages the conversion and handling of event traces, preparing them for alignment. +- `DCRGraphHandler`: Encapsulates operations and checks on DCR graphs relevant for the alignment. +- `Alignment`: Implements the actual algorithm, managing the search space, and constructing optimal alignments. + +The module's classes interact to process an input DCR graph and a trace abd execute the alignment algorithm. This process helps in understanding how closely the behavior described by +the trace matches the behavior allowed by the DCR graph, which is essential in the analysis and optimization of business processes. + +References +---------- +.. [1] + A. K. F. Christfort, T. Slaats, "Efficient Optimal Alignment Between Dynamic Condition Response Graphs and Traces", + in Business Process Management, Springer International Publishing, 2023, pp. 3-19. + DOI _. +""" + +import pandas as pd +from copy import deepcopy, copy +from typing import Optional, Dict, Any, Union, List, Tuple +from heapq import heappop, heappush +from enum import Enum + +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.objects.dcr.semantics import DcrSemantics +from pm4py.util import constants, xes_constants, exec_utils +from pm4py.objects.log.obj import EventLog, Trace +from pm4py.objects.conversion.log import converter as log_converter + + +class LogAlignment: + """ + The LogAlignment provides the simplified interface to perform optimal alignment for DCR graphs, with a provided event log. + Calls TraceAlignment for each trace to compute optimal alignment for each trace. + + After intilializing Log alignment, can call perform_log_alignment() to execute the alignment process for all traces in log + which returns a list of result for each alignment procedure + + Example usage: + \nDefine your instances of DCR graph and trace representation as 'graph' and 'trace'\n + align_log = LogAlignment(log, parameters)\n + alignment_result = align_log.perform_log_alignment(graph, parameters)\n + + Note: + - The user is expected to have a basic understanding of DCR graphs and trace alignment in the context of process mining. + + Attributes: + traces (list[Tuple]): the list of traces as tuples. + Trace_alignments (list[Alignments]): Instance that holds the result of the alignment processes, initialized as an empty list []. + + Methods: + perform_log_alignment(graph, parameters): Performs trace alignment for a log against the DCR graph and returns the list of alignment results. + """ + + def __init__(self, log: Union[EventLog, pd.DataFrame], parameters: Optional[Dict] = None): + """ + Initializes the LogAlignment instance for performing alignment of traces in an event log. + + This constructor converts the provided log into a list of traces, each represented as a tuple of activities. + It extracts the activities using the 'activity_key' and groups events into traces using the 'case_id_key'. + + Parameters: + log (Union[EventLog, pd.DataFrame]): The event log to be aligned. Can be in the form of a pandas DataFrame + or an EventLog object. + parameters (Optional[Dict]): Optional parameters for the log conversion, such as custom activity and case + ID keys. The default values are taken from the constants module if not provided. + + Attributes: + self.traces (List[Tuple[Any]]): A list of traces where each trace is represented as a tuple of activities. + """ + activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY) + case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, constants.CASE_CONCEPT_NAME) + if isinstance(log, pd.DataFrame): + self.traces = list(log.groupby(case_id_key)[activity_key].apply(tuple)) + else: + log = log_converter.apply(log, variant=log_converter.Variants.TO_EVENT_LOG, parameters=parameters) + self.traces = [tuple(x[activity_key] for x in trace) for trace in log] + self.trace_alignments = [] + + def perform_log_alignment(self, graph: DcrGraph, parameters: Optional[Dict] = None): + """ + Processes an event log and applies a specific operation to each trace. + + This method iterates through all traces in the log, and performs alignment operations, + and store it in a list + + Parameters: + graph (DcrGraph): the event log used for aligning the traces + parameters (Optional[Dict]): A dictionary of parameters that control the behavior of the trace processing. + This can include custom activity and case ID keys, among others. + + Returns: + List[Dict]: a list of dictionaries containing info on alignment and move fitness + """ + aligned_traces = [] + for trace in self.traces: + trace_alignment = TraceAlignment(graph, trace, parameters=parameters) + aligned_traces = aligned_traces + trace_alignment.perform_alignment() + return aligned_traces + +class TraceAlignment: + """ + The TraceAlignment class provides a simplified interface to perform optimal alignment for DCR graphs, + abstracting the complexity of direct interactions with the DCRGraphHandler, TraceHandler, and Alignment classes. + + Users should initialize TraceAlignment with a DCR_Graph object and a trace object, which can be a list of events, a Pandas DataFrame, + an EventLog, or a Trace. Optional parameters can also be passed to customize the processing, such as specifying custom activity + and case ID keys. + + After initializing TraceAlignment, users can call perform_alignment() to execute the alignment process, which returns the result of + the alignment procedure. + + Example usage: + Define your instances of DCR graph and trace representation as 'graph' and 'trace' + facade = Facade(graph, trace) + alignment_result = facade.perform_alignment() + + Note: + - The user is expected to have a basic understanding of DCR graphs and trace alignment in the context of process mining. + + Attributes: + graph_handler (DCRGraphHandler): Handler for DCR graph operations. + trace_handler (TraceHandler): Handler for trace operations. + alignment (Alignment): Instance that holds the result of the alignment process, initialized to None. + + Methods: + perform_alignment(): Performs trace alignment against the DCR graph and returns the alignment result. + get_performance_metrics(): Calculates and returns the alignment fitness. + """ + + def __init__(self, graph: DcrGraph, trace: Union[List[Tuple[str]], pd.DataFrame, EventLog, Trace], + parameters: Optional[Dict] = None): + """ + Initializes the facade with a DCR graph and a trace to be processed. + + The facade serves as a simplified interface to perform alignment between + the provided DCR graph and the trace, handling the creation and coordination + of the necessary handler objects. + + Parameters + ---------- + graph : DcrGraph + The DCR graph against which the trace will be aligned. The graph should + encapsulate the behavior model. + trace : Union[List[Dict[str, Any]], pd.DataFrame, EventLog, Trace] + The trace to be aligned with the DCR graph. The trace can be in various + forms, such as a list of dictionaries representing events, a pandas + DataFrame, an EventLog object, or a Trace object. + parameters : Optional[Dict], optional + A dictionary of parameters that can be used to fine-tune the handling + of the graph and trace. The exact parameters that can be provided will + depend on the implementation of the DCRGraphHandler and TraceHandler. + + Attributes + ---------- + self.graph_handler : DCRGraphHandler + An instance of DCRGraphHandler to manage operations related to the DCR graph. + self.trace_handler : TraceHandler + An instance of TraceHandler to manage the conversion and processing of the trace. + self.alignment : Alignment or None + An instance of the Alignment class that will be initialized after + perform_alignment is called. This will hold the result of the trace + alignment against the DCR graph. + """ + self.graph_handler = DCRGraphHandler(graph) + self.trace_handler = TraceHandler(trace, parameters) + self.alignment = None # This will hold an instance of Alignment class after perform_alignment is called + self.result = None + + def perform_alignment(self): + # Perform the alignment process and store the result in the self.alignment attribute + self.alignment = Alignment(self.graph_handler, self.trace_handler) + self.result = self.alignment.apply_trace() + self.get_performance_metrics() + return [self.result] + + def get_performance_metrics(self): + # Ensure that alignment has been performed before calculating performance metrics + # Calculate and return fitness and precision based on the alignment result + performance = Performance(self.alignment, self.graph_handler, self.trace_handler) + fitness_bwc = performance.calculate_fitness() + self.result[Outputs.ALIGN_FITNESS.value] = fitness_bwc[0] + self.result[Outputs.BEST_WORST_COST.value] = fitness_bwc[1] + + +class Parameters(Enum): + """ + Enumeration that defines keys and constants for various parameters used in the alignment process. + + Attributes: + CASE_ID_KEY: The key used to identify the case ID in the event log. + ACTIVITY_KEY: The key used to identify the activity in the event log. + SYNC_COST: The cost of a synchronous move during the alignment. + MODEL_COST: The cost of a model move during the alignment. + LOG_COST: The cost of a log move during the alignment. + """ + CASE_ID_KEY = constants.PARAMETER_CONSTANT_CASEID_KEY + ACTIVITY_KEY = constants.PARAMETER_CONSTANT_ACTIVITY_KEY + SYNC_COST = 0 + MODEL_COST = 1 + LOG_COST = 1 + + +class Outputs(Enum): + """ + Enumeration that defines constants for various outputs of the alignment process. + + Attributes: + ALIGNMENT: The key for accessing the final alignment from the result. + COST: The key for accessing the total cost of the alignment. + VISITED: The key for accessing the number of visited states during the alignment process. + CLOSED: The key for accessing the number of closed states during the alignment process. + GLOBAL_MIN: The key for accessing the global minimum cost encountered during the alignment. + MODEL_MOVE_FITNESS = the key for accessing the model move fitness + LOG_MOVE_FITNESS = the key for accessing the log move fitness + ALIGN_FITNESS = the key for accessing the alignment fitness + """ + ALIGNMENT = "alignment" + COST = "cost" + VISITED = "visited_states" + CLOSED = "closed" + GLOBAL_MIN = "global_min" + ALIGN_FITNESS = 'fitness' + BEST_WORST_COST = "bwc" + +class Performance: + def __init__(self, alignment, graph_handler, trace_handler): + self.alignment = alignment + self.graph_hanlder = graph_handler + self.trace_handler = trace_handler + + def calculate_fitness(self) -> Tuple: + """ + From the Conformance Checking book [1]. + Calculate the fitness of the alignment based on the optimal and worst-case costs. + + The fitness is calculated as one minus the ratio of the optimal alignment cost to + the worst-case alignment cost. If the worst-case alignment cost is zero, + fitness is set to zero to avoid division by zero. + + Returns + ------- + float + The calculated fitness value, where higher values indicate a better fit. + + References + ---------- + * [1] C. Josep et al., "Conformance Checking Software", Springer International Publishing, 82-91, 2018. `DOI `_. + """ + # run model with empty trace + worst_case_trace = len(self.trace_handler.trace) + self.trace_handler.trace = () + # compute worst_best_alignment + best_worst_alignment = Alignment(self.graph_hanlder, self.trace_handler) + best_worst_result = best_worst_alignment.apply_trace() + bwc = (worst_case_trace + best_worst_result[Outputs.COST.value]) + fitness = 1 - (self.alignment.global_min / (bwc) if bwc > 0 else 0) + return fitness, bwc + + +class TraceHandler: + """ + TraceHandler is responsible for managing and converting traces into a format suitable + for the alignment algorithm. This class provides functionalities to check if the trace is + empty, retrieve the first activity from the trace, and convert the trace format as needed. + + A trace can be provided as a list of dictionaries, a pandas DataFrame, an EventLog, or a Trace object. + The TraceHandler takes care of converting these into a uniform internal representation. + + Attributes + ---------- + trace : Tuple[Any] | Trace + The trace to be managed and converted. It's stored internally in a list of dictionaries + regardless of the input format. + activity_key : str + The key to identify activities within the trace data. + + Methods + ------- + is_empty() -> bool: + Checks if the trace is empty (contains no events). + + get_first_activity() -> Any: + Retrieves the first activity from the trace, if available. + + convert_trace(activity_key, case_id_key, parameters): + Converts the trace into a tuple-based format required for processing by the alignment algorithm. + This conversion handles both DataFrame and Event Log traces and can be configured via parameters. + + Parameters + ---------- + trace : Tuple[str] | Trace + The initial trace data provided in one of the acceptable formats. + parameters : Optional[Dict] + Optional parameters for trace conversion. These can define the keys for activity and case ID within + the trace data and can include other conversion-related parameters. + """ + + def __init__(self, trace: Union[Tuple[str], Trace], + parameters: Optional[Dict] = None): + """ + Initializes the TraceHandler object, converting the input trace into a standard format + and storing the specified parameters. + + The conversion process varies depending on the type of trace input provided. The trace is + converted to a list of dictionary records for consistent internal processing. + + Parameters + ---------- + trace : Tuple[str] | Trace + The initial trace data provided in one of: Pandas DataFrame, an EventLog, or a single Trace. + parameters : Optional[Dict] + Optional parameters for trace conversion. These can define the keys for activity and case ID within + the trace data and can include other conversion-related parameters. If None or not a dictionary, + defaults will be used. + + The activity key used in the trace is determined by the provided parameters or defaults to + a standard key from the xes_constants if not specified. + """ + if parameters is None or not isinstance(parameters, dict): + parameters = {} + + self.activity_key = parameters.get(Parameters.ACTIVITY_KEY.value, xes_constants.DEFAULT_NAME_KEY) + + if isinstance(trace, Trace): + self.trace = tuple(event[self.activity_key] for event in trace) + else: + self.trace = trace + + def is_empty(self) -> bool: + return not bool(self.trace) + + def get_first_activity(self) -> Any: + return self.trace[0] if self.trace else None + + +class DCRGraphHandler: + """ + DCRGraphHandler manages operations on a DCR graph within the context of an alignment algorithm. + It provides methods to check if an event is enabled, if the graph is in an accepting state, + and to execute an event on the graph. + + The DCR graph follows the semantics defined in the DCR semantics module, and this class + acts as an interface to apply these semantics for the purpose of alignment computation. + + Attributes + ---------- + graph : DcrGraph + The DCR graph on which the operations are to be performed. + + Methods + ------- + is_enabled(event: Any) -> bool: + Determines if an event is enabled in the current state of the DCR graph. + + is_accepting() -> bool: + Checks if the current state of the DCR graph is an accepting state. + + execute(event: Any, curr_graph) -> Any: + Executes an event on the DCR graph, which may result in a transition to a new state. + If the execution is not possible, it returns the current graph state. + + Parameters + ---------- + graph : DcrGraph + An instance of a DCR_Graph object which the handler will manage and manipulate. + + Raises + ------ + TypeError + If the provided graph is not an instance of DCR_Graph. + """ + + def __init__(self, graph: DcrGraph): + if not isinstance(graph, DcrGraph): + raise TypeError(f"Expected a DCR_Graph object, got {type(graph)} instead") + self.graph = graph + + def is_enabled(self, event: Any) -> bool: + return DcrSemantics.is_enabled(event, self.graph) + + def enabled(self): + return DcrSemantics.enabled(self.graph) + + def is_accepting(self) -> bool: + return DcrSemantics.is_accepting(self.graph) + + def execute(self, event: Any, curr_graph) -> Any: + new_graph = DcrSemantics.execute(curr_graph, event) + if not new_graph: + return curr_graph + return new_graph + +class Alignment: + def __init__(self, graph_handler: DCRGraphHandler, trace_handler: TraceHandler, parameters: Optional[Dict] = None): + """ + Initialize the Alignment instance. + This constructor initializes the alignment with the provided DCR graph and trace handlers. It sets up + all necessary data structures for computing the alignment and its costs. + + Parameters + ---------- + graph_handler : DCRGraphHandler + An instance of DCRGraphHandler to manage the DCR graph. + trace_handler : TraceHandler + An instance of TraceHandler to manage the event log trace. + parameters : Optional[Dict] + A dictionary of parameters to configure the alignment process. Defaults are used if None. + """ + self.graph_handler = graph_handler + + if parameters is None: + parameters = {} + activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY) + parameters[Parameters.ACTIVITY_KEY.value] = activity_key + + self.trace_handler = TraceHandler(trace_handler.trace, parameters) + + self.open_set = [] + self.max_cost = 0 + self.global_min = float('inf') + self.closed_set = {} + self.visited_states = set() + self.new_moves = [] + self.final_alignment = [] + self.initial_marking = deepcopy(self.graph_handler.graph.marking) + + def handle_state(self, curr_cost, curr_graph, curr_trace, event, moves, move_type=None): + """ + Manages the transition to a new state in the alignment algorithm based on the specified move type. + It computes the new state, checks for execution equivalency to avoid re-processing, and if unique, + updates the visited states and the priority queue for further processing. + + Parameters + ---------- + curr_cost : int + The current cost of the alignment. + curr_graph : DcrGraph + The current state of the DCR graph. + curr_trace : list + The current state of the trace. + event : Any + The event from the trace that is being considered in the current alignment step. + moves : list + The list of moves made so far. + move_type : str, optional + The type of move to make. This should be one of "sync", "model", or "log". Default is None. + + Returns + ------- + None + + Raises + ------ + None + + Notes + ----- + - This method interfaces with the `get_new_state` method to compute the new state. + - It employs a heap-based priority queue to manage the processing order of states based on their costs. + - Execution equivalency check is performed to reduce redundant processing of similar states. + """ + if moves is None: + moves = [] + + new_cost, new_graph, new_trace, new_move = self.get_new_state(curr_cost, curr_graph, curr_trace, event, + move_type) + + state_representation = (str(new_graph), tuple(map(str, new_trace))) + if state_representation not in self.visited_states: + self.visited_states.add(state_representation) + new_moves = moves + [new_move] + heappush(self.open_set, (new_cost, new_graph, new_trace, str(new_graph), new_moves)) + + def get_new_state(self, curr_cost, curr_marking, curr_trace, event, move_type): + """ + Computes the new state of the alignment algorithm based on the current state and + the specified move type. The new state includes the updated cost, graph, trace, + and move. This method handles three types of moves: synchronous, model, and log. + + Parameters + ---------- + curr_cost : int + The current cost of the alignment. + curr_graph : DcrGraph + The current state of the DCR graph. + curr_trace : list + The current state of the trace. + moves : list + The list of moves made so far. + move_type : str + The type of move to make. This should be one of "sync", "model", or "log". + + Returns + ------- + tuple + A tuple containing four elements: + - new_cost : int, the updated cost of the alignment. + - new_graph : DCR_Graph, the updated state of the DCR graph. + - new_trace : list, the updated state of the trace. + - new_move : tuple, a tuple representing the move made, formatted as (move_type, first_activity). + + Example + ------- + new_cost, new_graph, new_trace, new_move = get_new_state(curr_cost, curr_graph, curr_trace, moves, "sync") + + """ + new_cost = curr_cost + self.graph_handler.graph.marking = deepcopy(curr_marking) + new_graph = self.graph_handler.graph + new_trace = curr_trace + new_move = None + if move_type == "sync": + new_cost += Parameters.SYNC_COST.value + new_move = (event, event) + new_trace = curr_trace[1:] + new_graph = self.graph_handler.execute(event, new_graph) + + elif move_type == "model": + new_cost += Parameters.MODEL_COST.value + new_move = (event, ">>") + new_graph = self.graph_handler.execute(event, new_graph) + + elif move_type == "log": + new_cost += Parameters.LOG_COST.value + new_move = (">>", event) + new_trace = curr_trace[1:] + + return new_cost, deepcopy(new_graph.marking), new_trace, new_move + + def update_closed_and_visited_sets(self, curr_cost, state_repr): + self.closed_set[state_repr] = curr_cost + + def process_current_state(self, current): + """ + Process the current state in the alignment process. + This method processes the current state of the alignment, updates the graph handler + with the current graph, and prepares the state representation for further processing. + + Parameters + ---------- + current : Tuple + The current state, which is a tuple containing the current cost, current graph, + current trace, and the moves made up to this point. + """ + curr_cost, curr_marking, curr_trace, _, moves = current + self.graph_handler.graph.marking = deepcopy(curr_marking) + state_repr = (str(self.graph_handler.graph.marking), tuple(map(str, curr_trace))) + return curr_cost, curr_marking, curr_trace, state_repr, moves + + def check_accepting_conditions(self, curr_cost, is_accepting): + """ + Check if the current state meets the accepting conditions and update the global minimum cost and final alignment. + + Parameters + ---------- + curr_cost : float + The cost associated with the current state. + is_accepting : bool + Flag indicating whether the current state is an accepting state. + + Returns + ------- + float + The final cost if the accepting conditions are met; `float('inf')` otherwise. + """ + if is_accepting: + if curr_cost <= self.global_min: + self.global_min = curr_cost + self.final_alignment = self.new_moves + + return self.global_min + + def apply_trace(self, parameters=None): + """ + Applies the alignment algorithm to a trace in order to find an optimal alignment + between the DCR graph and the trace based on the algorithm outlined in the paper + by Axel Kjeld Fjelrad Christfort and Tijs Slaats. + + Parameters + ---------- + parameters : dict, optional + A dictionary of parameters to configure the alignment algorithm. + Possible keys include: + - Parameters.ACTIVITY_KEY: Specifies the key to use for activity names in the trace data. + - Parameters.CASE_ID_KEY: Specifies the key to use for case IDs in the trace data. + If not provided or None, default values are used. + + Returns + ------- + dict + A dictionary containing the results of the alignment algorithm, with the following keys: + - 'alignment': List of tuples representing the optimal alignment found. + - 'cost': The cost of the optimal alignment. + - 'visited': The number of states visited during the alignment algorithm. + - 'closed': The number of closed states during the alignment algorithm. + - 'global_min': The global minimum cost found during the alignment algorithm. + + Example + ------- + result = alignment_obj.apply_trace() + optimal_alignment = result['alignment'] + alignment_cost = result['cost'] + """ + + visited, closed, cost, self.final_alignment, final_cost = 0, 0, 0, None, float('inf') + self.open_set.append( + (cost, deepcopy(self.graph_handler.graph.marking), self.trace_handler.trace, + str(self.graph_handler.graph.marking), [])) + + # perform while loop to iterate through all states + while self.open_set: + current = heappop(self.open_set) + visited += 1 + result = self.process_current_state(current) + # if the state has already been visited, and associated cost with the state is lower than skip + if self.skip_current(result) and result is not None: + continue + curr_cost, curr_trace, state_repr, moves = result[0], result[2], result[3], result[4] + # if curr_cost is greater than final cost, no reason to explore this branch + if curr_cost > final_cost: + continue + self.update_closed_and_visited_sets(curr_cost, state_repr) + closed += 1 + self.trace_handler.trace = curr_trace + if self.graph_handler.is_accepting() and self.trace_handler.is_empty(): + self.new_moves = moves + final_cost = self.check_accepting_conditions(curr_cost, self.graph_handler.is_accepting()) + self.max_cost = final_cost + + self.perform_moves(curr_cost, current, moves) + + return self.construct_results(visited, closed, final_cost) + + def skip_current(self, result): + # if state is visited, and cost is the same skip + curr_cost, state_repr = result[0], result[3] + visitCost = self.closed_set.get(state_repr, float("inf")) + return visitCost <= curr_cost and visitCost is not float("inf") + + def perform_moves(self, curr_cost, current, moves): + """ + Defines available moves based on the trace and model state. + + This method determines which moves are possible (synchronous, model, or log moves) + so that they can be processed accordingly. Each move type is defined as: + - Synchronous (sync): The activity is both in the trace and the model, and is currently enabled. + - Model move: The activity is enabled in the model but not in the trace. + - Log move: The activity is in the trace but not enabled in the model. + + Parameters + ---------- + curr_cost : float + The cost associated with the current state before performing any moves. + current : tuple + The current state represented as a tuple containing the following: + - current[0]: The current cumulative cost associated with the trace. + - current[1]: The current state of the graph representing the model. + - current[2]: The current position in the trace. + - current[3]: A placeholder for additional information (if any). + - current[4]: The list of moves performed to reach this state. + moves : list + The list of moves performed so far to reach the current state. This will be updated with new moves + as they are performed. + + """ + self.graph_handler.graph.marking = current[1] + first_activity = self.graph_handler.graph.get_event(self.trace_handler.get_first_activity()) + enabled = self.graph_handler.enabled() + is_enabled = self.graph_handler.is_enabled(first_activity) + if first_activity: + if is_enabled: + self.handle_state(curr_cost, current[1], current[2], first_activity, moves, "sync") + return + self.handle_state(curr_cost, current[1], current[2], first_activity, moves, "log") + for event in enabled: + self.handle_state(curr_cost, current[1], current[2], event, moves, "model") + + def construct_results(self, visited, closed, final_cost): + """ + Constructs a dictionary of results from the alignment process containing various metrics + and outcomes, such as the final alignment, its cost, and statistics about the search process. + + Parameters + ---------- + visited : int + The number of states visited during the alignment process. + closed : int + The number of states that were closed (i.e., fully processed and will not be revisited). + final_cost : float + The cost associated with the final alignment obtained. + + Returns + ------- + dict + A dictionary with keys corresponding to various outputs of the alignment process: + - 'alignment': The final alignment between the process model and the trace. + - 'cost': The cost of the final alignment . + - 'visited': The total number of visited states. + - 'closed': The total number of closed states. + - 'model move fitness': the fitness provided that model moves are used + - 'log move fitness': the fitness provided by the log moves + """ + self.graph_handler.graph.marking = self.initial_marking + return { + Outputs.ALIGNMENT.value: self.final_alignment, + Outputs.COST.value: final_cost, + Outputs.VISITED.value: visited, + Outputs.CLOSED.value: closed, + Outputs.GLOBAL_MIN.value: self.global_min, + } + +def apply(trace_or_log: Union[pd.DataFrame,EventLog,Trace], graph: DcrGraph, parameters=None): + """ + Applies an alignment operation on a given trace or log against a specified DCR graph. + + Depending on the type of input, this function handles the alignment of a single trace or multiple traces contained + in an event log. For a single trace, it creates an instance of TraceAlignment and performs the alignment. + For an event log, it initializes a LogAlignment object and aligns each trace contained within. + + Parameters: + trace_or_log (Union[pd.DataFrame, EventLog, Trace]): The event log or single trace to align. + graph (DcrGraph): The DCR graph against which the alignment is to be performed. + parameters (Optional[Dict]): A dictionary of parameters for the alignment (default is None). + + Returns: + - If a single trace is provided, returns the result of the TraceAlignment. + - If an event log is provided, returns a list of results from LogAlignment for each trace. + """ + if isinstance(trace_or_log, Trace): + alignment = TraceAlignment(graph, trace_or_log, parameters=parameters) + return alignment.perform_alignment() + else: + alignment = LogAlignment(trace_or_log, parameters=parameters) + return alignment.perform_log_alignment(graph, parameters=parameters) + + +def get_diagnostics_dataframe(log: EventLog, conf_result: List[Dict[str, Any]], parameters=None) -> pd.DataFrame: + """ + Gets the diagnostics dataframe from a log and the conformance results + + Parameters + -------------- + log + Event log + conf_result + Results of conformance checking + variant + Variant to be used: + - Variants.CLASSIC + parameters + Variant-specific parameters + + Returns + -------------- + diagn_dataframe + Diagnostics dataframe + """ + if parameters is None: + parameters = {} + + case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, + xes_constants.DEFAULT_TRACEID_KEY) + + diagn_stream = [] + for index in range(len(log)): + case_id = log[index].attributes[case_id_key] + cost = conf_result[index][Outputs.COST.value] + align_fitness = conf_result[index][Outputs.ALIGN_FITNESS.value] + is_fit = align_fitness == 1.0 + diagn_stream.append({"case_id": case_id, "cost": cost, "fitness": align_fitness, "is_fit": is_fit}) + + return pd.DataFrame(diagn_stream) diff --git a/pm4py/algo/conformance/alignments/dcr/variants/optimal_multithreaded.py b/pm4py/algo/conformance/alignments/dcr/variants/optimal_multithreaded.py new file mode 100644 index 0000000000..587cda6f91 --- /dev/null +++ b/pm4py/algo/conformance/alignments/dcr/variants/optimal_multithreaded.py @@ -0,0 +1,920 @@ +""" +This module contains the object-oriented implementation of the Optimal Alignments algorithm, +based on the paper by Axel Kjeld Fjelrad Christfort and Tijs Slaats [1]. + +Overview: +The implementation encapsulates the core components of the algorithm and provides. + +The calculation of the alignments and graph-trace handling are encapsulated in separate, +dedicated classes, thereby facilitating modularity and reuse. +Central to the module are the following classes: + +- `LogAlignment`: A simplified interface to perform optimal alignment through the other classes. +- `TraceAlignment`: Serves as the primary interface for interacting with the algorithm. + orchestrating the alignment process and providing access to performance metrics. +- `TraceHandler`: Manages the conversion and handling of event traces, preparing them for alignment. +- `DCRGraphHandler`: Encapsulates operations and checks on DCR graphs relevant for the alignment. +- `Alignment`: Implements the actual algorithm, managing the search space, and constructing optimal alignments. + +The module's classes interact to process an input DCR graph and a trace abd execute the alignment algorithm. This process helps in understanding how closely the behavior described by +the trace matches the behavior allowed by the DCR graph, which is essential in the analysis and optimization of business processes. + +This version of the module includes multithreading capabilities to improve performance when processing large logs. + +References +---------- +.. [1] + A. K. F. Christfort, T. Slaats, "Efficient Optimal Alignment Between Dynamic Condition Response Graphs and Traces", + in Business Process Management, Springer International Publishing, 2023, pp. 3-19. + DOI _. +""" + +import concurrent.futures +import logging +import time +import pandas as pd +import multiprocessing +from copy import deepcopy, copy +from typing import Optional, Dict, Any, Union, List, Tuple +from heapq import heappop, heappush +from enum import Enum + +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.objects.dcr.semantics import DcrSemantics +from pm4py.util import constants, xes_constants, exec_utils +from pm4py.objects.log.obj import EventLog, Trace +from pm4py.objects.conversion.log import converter as log_converter + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +class LogAlignment: + """ + LogAlignment class provides a multithreaded interface to perform optimal alignment for multiple traces in an event log. + + This class manages the parallel processing of traces, distributing the workload across multiple CPU cores + to improve performance when dealing with large event logs. + + Attributes: + parameters (Dict[str, Any]): Configuration parameters for the alignment process. + cpu_count (int): The number of CPU cores available on the system. + max_workers (int): The maximum number of worker processes to use for parallel processing. + chunk_size (int): The number of traces to process in each chunk. + traces (EventLog): The event log containing the traces to be aligned. + + Methods: + perform_log_alignment(graph: DcrGraph, parameters: Dict[str, Any] = None) -> List[Dict[str, Any]]: + Performs the alignment process for all traces in the log using multiple worker processes. + + process_chunk(graph: DcrGraph, traces: List[Trace], parameters: Dict[str, Any]) -> List[Dict[str, Any]]: + Static method to process a chunk of traces, used by worker processes. + """ + def __init__(self, traces: EventLog, parameters: Dict[str, Any] = None): + self.parameters = parameters or {} + self.cpu_count = multiprocessing.cpu_count() + self.max_workers = self.parameters.get("max_workers", max(1, self.cpu_count - 1)) + self.chunk_size = self.parameters.get("chunk_size", max(1, min(100, len(traces) // (self.cpu_count * 2)))) + self.traces = traces + logger.info(f"LogAlignment initialized with {len(self.traces)} traces") + logger.info(f"System has {self.cpu_count} CPU cores") + logger.info(f"Using {self.max_workers} worker processes, chunk size of {self.chunk_size}") + + def perform_log_alignment(self, graph: DcrGraph, parameters: Dict[str, Any] = None) -> List[Dict[str, Any]]: + """ + Performs the alignment process for all traces in the log using multiple worker processes. + + This method divides the traces into chunks and distributes them among worker processes + for parallel processing. It then collects and combines the results from all workers. + + Parameters: + graph (DcrGraph): The DCR graph against which the traces will be aligned. + parameters (Dict[str, Any], optional): Additional parameters for the alignment process. + + Returns: + List[Dict[str, Any]]: A list of alignment results for all processed traces. + """ + if not self.traces: + logger.warning("No valid traces to align.") + return [] + + all_results = [] + start_time = time.time() + + with concurrent.futures.ProcessPoolExecutor(max_workers=self.max_workers) as executor: + futures = [] + for i in range(0, len(self.traces), self.chunk_size): + chunk = self.traces[i:i + self.chunk_size] + futures.append(executor.submit(self.process_chunk, graph, chunk, parameters)) + + for future in concurrent.futures.as_completed(futures): + try: + results = future.result() + all_results.extend(results) + except Exception as e: + logger.error(f"Error processing chunk: {str(e)}") + + logger.info( + f"Alignment completed in {time.time() - start_time:.2f} seconds. {len(all_results)} traces aligned.") + return all_results + + @staticmethod + def process_chunk(graph: DcrGraph, traces: List[Trace], parameters: Dict[str, Any]) -> List[Dict[str, Any]]: + """ + Static method to process a chunk of traces. + + This method is designed to be run in a separate process, aligning each trace in the given chunk + against the provided DCR graph. + + Parameters: + graph (DcrGraph): The DCR graph against which the traces will be aligned. + traces (List[Trace]): A list of traces to be processed. + parameters (Dict[str, Any]): Parameters for the alignment process. + + Returns: + List[Dict[str, Any]]: A list of alignment results for the processed traces. + """ + results = [] + for trace in traces: + alignment = TraceAlignment(graph, trace, parameters=parameters) + results.extend(alignment.perform_alignment()) + return results + + +class TraceAlignment: + """ + The TraceAlignment class provides a simplified interface to perform optimal alignment for DCR graphs, + abstracting the complexity of direct interactions with the DCRGraphHandler, TraceHandler, and Alignment classes. + + Users should initialize TraceAlignment with a DCR_Graph object and a trace object, which can be a list of events, a Pandas DataFrame, + an EventLog, or a Trace. Optional parameters can also be passed to customize the processing, such as specifying custom activity + and case ID keys. + + After initializing TraceAlignment, users can call perform_alignment() to execute the alignment process, which returns the result of + the alignment procedure. + + Example usage: + Define your instances of DCR graph and trace representation as 'graph' and 'trace' + facade = Facade(graph, trace) + alignment_result = facade.perform_alignment() + + Note: + - The user is expected to have a basic understanding of DCR graphs and trace alignment in the context of process mining. + + Attributes: + graph_handler (DCRGraphHandler): Handler for DCR graph operations. + trace_handler (TraceHandler): Handler for trace operations. + alignment (Alignment): Instance that holds the result of the alignment process, initialized to None. + + Methods: + perform_alignment(): Performs trace alignment against the DCR graph and returns the alignment result. + get_performance_metrics(): Calculates and returns the alignment fitness. + """ + + def __init__(self, graph: DcrGraph, trace: Union[List[Tuple[str]], pd.DataFrame, EventLog, Trace], + parameters: Optional[Dict] = None): + """ + Initializes the facade with a DCR graph and a trace to be processed. + + The facade serves as a simplified interface to perform alignment between + the provided DCR graph and the trace, handling the creation and coordination + of the necessary handler objects. + + Parameters + ---------- + graph : DcrGraph + The DCR graph against which the trace will be aligned. The graph should + encapsulate the behavior model. + trace : Union[List[Dict[str, Any]], pd.DataFrame, EventLog, Trace] + The trace to be aligned with the DCR graph. The trace can be in various + forms, such as a list of dictionaries representing events, a pandas + DataFrame, an EventLog object, or a Trace object. + parameters : Optional[Dict], optional + A dictionary of parameters that can be used to fine-tune the handling + of the graph and trace. The exact parameters that can be provided will + depend on the implementation of the DCRGraphHandler and TraceHandler. + + Attributes + ---------- + self.graph_handler : DCRGraphHandler + An instance of DCRGraphHandler to manage operations related to the DCR graph. + self.trace_handler : TraceHandler + An instance of TraceHandler to manage the conversion and processing of the trace. + self.alignment : Alignment or None + An instance of the Alignment class that will be initialized after + perform_alignment is called. This will hold the result of the trace + alignment against the DCR graph. + """ + self.graph_handler = DCRGraphHandler(graph) + self.trace_handler = TraceHandler(trace, parameters) + self.alignment = None # This will hold an instance of Alignment class after perform_alignment is called + self.result = None + + def perform_alignment(self): + if not self.trace_handler.trace: + print(f"Warning: The trace is empty. Skipping alignment.") + return [] + + try: + self.alignment = Alignment(self.graph_handler, self.trace_handler) + self.result = self.alignment.apply_trace() + + if not self.result: + print("Warning: No alignment result produced.") + return [] + + self.get_performance_metrics() + return [self.result] + except Exception as e: + print(f"Error during alignment: {str(e)}") + return [] + + def get_performance_metrics(self): + # Ensure that alignment has been performed before calculating performance metrics + # Calculate and return fitness and precision based on the alignment result + performance = Performance(self.alignment, self.graph_handler, self.trace_handler) + fitness_bwc = performance.calculate_fitness() + self.result[Outputs.ALIGN_FITNESS.value] = fitness_bwc[0] + self.result[Outputs.BEST_WORST_COST.value] = fitness_bwc[1] + + + +class Parameters(Enum): + """ + Enumeration that defines keys and constants for various parameters used in the alignment process. + + Attributes: + CASE_ID_KEY: The key used to identify the case ID in the event log. + ACTIVITY_KEY: The key used to identify the activity in the event log. + SYNC_COST: The cost of a synchronous move during the alignment. + MODEL_COST: The cost of a model move during the alignment. + LOG_COST: The cost of a log move during the alignment. + """ + CASE_ID_KEY = constants.PARAMETER_CONSTANT_CASEID_KEY + ACTIVITY_KEY = constants.PARAMETER_CONSTANT_ACTIVITY_KEY + SYNC_COST = 0 + MODEL_COST = 1 + LOG_COST = 1 + + +class Outputs(Enum): + """ + Enumeration that defines constants for various outputs of the alignment process. + + Attributes: + ALIGNMENT: The key for accessing the final alignment from the result. + COST: The key for accessing the total cost of the alignment. + VISITED: The key for accessing the number of visited states during the alignment process. + CLOSED: The key for accessing the number of closed states during the alignment process. + GLOBAL_MIN: The key for accessing the global minimum cost encountered during the alignment. + MODEL_MOVE_FITNESS = the key for accessing the model move fitness + LOG_MOVE_FITNESS = the key for accessing the log move fitness + ALIGN_FITNESS = the key for accessing the alignment fitness + """ + ALIGNMENT = "alignment" + COST = "cost" + VISITED = "visited_states" + CLOSED = "closed" + GLOBAL_MIN = "global_min" + ALIGN_FITNESS = 'fitness' + BEST_WORST_COST = "bwc" + +class Performance: + def __init__(self, alignment, graph_handler, trace_handler): + self.alignment = alignment + self.graph_hanlder = graph_handler + self.trace_handler = trace_handler + + def calculate_fitness(self) -> Tuple: + """ + From the Conformance Checking book [1]. + Calculate the fitness of the alignment based on the optimal and worst-case costs. + + The fitness is calculated as one minus the ratio of the optimal alignment cost to + the worst-case alignment cost. If the worst-case alignment cost is zero, + fitness is set to zero to avoid division by zero. + + Returns + ------- + float + The calculated fitness value, where higher values indicate a better fit. + + References + ---------- + * [1] C. Josep et al., "Conformance Checking Software", Springer International Publishing, 82-91, 2018. `DOI `_. + """ + # run model with empty trace + worst_case_trace = len(self.trace_handler.trace) + self.trace_handler.trace = () + # compute worst_best_alignment + best_worst_alignment = Alignment(self.graph_hanlder, self.trace_handler) + best_worst_result = best_worst_alignment.apply_trace() + bwc = (worst_case_trace + best_worst_result[Outputs.COST.value]) + fitness = 1 - (self.alignment.global_min / (bwc) if bwc > 0 else 0) + return fitness, bwc + + +class TraceHandler: + """ + TraceHandler is responsible for managing and converting traces into a format suitable + for the alignment algorithm. This class provides functionalities to check if the trace is + empty, retrieve the first activity from the trace, and convert the trace format as needed. + + A trace can be provided as a list of dictionaries, a pandas DataFrame, an EventLog, or a Trace object. + The TraceHandler takes care of converting these into a uniform internal representation. + + Attributes + ---------- + trace : Tuple[Any] | Trace + The trace to be managed and converted. It's stored internally in a list of dictionaries + regardless of the input format. + activity_key : str + The key to identify activities within the trace data. + + Methods + ------- + is_empty() -> bool: + Checks if the trace is empty (contains no events). + + get_first_activity() -> Any: + Retrieves the first activity from the trace, if available. + + convert_trace(activity_key, case_id_key, parameters): + Converts the trace into a tuple-based format required for processing by the alignment algorithm. + This conversion handles both DataFrame and Event Log traces and can be configured via parameters. + + Parameters + ---------- + trace : Tuple[str] | Trace + The initial trace data provided in one of the acceptable formats. + parameters : Optional[Dict] + Optional parameters for trace conversion. These can define the keys for activity and case ID within + the trace data and can include other conversion-related parameters. + """ + + def __init__(self, trace: Union[Tuple[str], Trace], + parameters: Optional[Dict] = None): + """ + Initializes the TraceHandler object, converting the input trace into a standard format + and storing the specified parameters. + + The conversion process varies depending on the type of trace input provided. The trace is + converted to a list of dictionary records for consistent internal processing. + + Parameters + ---------- + trace : Tuple[str] | Trace + The initial trace data provided in one of: Pandas DataFrame, an EventLog, or a single Trace. + parameters : Optional[Dict] + Optional parameters for trace conversion. These can define the keys for activity and case ID within + the trace data and can include other conversion-related parameters. If None or not a dictionary, + defaults will be used. + + The activity key used in the trace is determined by the provided parameters or defaults to + a standard key from the xes_constants if not specified. + """ + if parameters is None or not isinstance(parameters, dict): + parameters = {} + + self.activity_key = parameters.get(Parameters.ACTIVITY_KEY.value, xes_constants.DEFAULT_NAME_KEY) + + if isinstance(trace, Trace): + self.trace = tuple(event[self.activity_key] for event in trace) + else: + # Ensure trace is properly initialized + if trace and isinstance(trace, tuple) and all(isinstance(act, str) for act in trace): + self.trace = trace + else: + self.trace = tuple() # Initialize as an empty tuple instead of None + + def is_empty(self) -> bool: + return not bool(self.trace) + + def get_first_activity(self) -> Any: + return self.trace[0] if self.trace else None + + +class DCRGraphHandler: + """ + DCRGraphHandler manages operations on a DCR graph within the context of an alignment algorithm. + It provides methods to check if an event is enabled, if the graph is in an accepting state, + and to execute an event on the graph. + + The DCR graph follows the semantics defined in the DCR semantics module, and this class + acts as an interface to apply these semantics for the purpose of alignment computation. + + Attributes + ---------- + graph : DcrGraph + The DCR graph on which the operations are to be performed. + + Methods + ------- + is_enabled(event: Any) -> bool: + Determines if an event is enabled in the current state of the DCR graph. + + is_accepting() -> bool: + Checks if the current state of the DCR graph is an accepting state. + + execute(event: Any, curr_graph) -> Any: + Executes an event on the DCR graph, which may result in a transition to a new state. + If the execution is not possible, it returns the current graph state. + + Parameters + ---------- + graph : DcrGraph + An instance of a DCR_Graph object which the handler will manage and manipulate. + + Raises + ------ + TypeError + If the provided graph is not an instance of DCR_Graph. + """ + + def __init__(self, graph: DcrGraph): + if not isinstance(graph, DcrGraph): + raise TypeError(f"Expected a DCR_Graph object, got {type(graph)} instead") + self.graph = graph + + def is_enabled(self, event: Any) -> bool: + return DcrSemantics.is_enabled(event, self.graph) + + def enabled(self): + return DcrSemantics.enabled(self.graph) + + def is_accepting(self) -> bool: + return DcrSemantics.is_accepting(self.graph) + + def execute(self, event: Any, curr_graph) -> Any: + new_graph = DcrSemantics.execute(curr_graph, event) + if not new_graph: + return curr_graph + return new_graph + +class Alignment: + def __init__(self, graph_handler: DCRGraphHandler, trace_handler: TraceHandler, parameters: Optional[Dict] = None): + """ + Initialize the Alignment instance. + This constructor initializes the alignment with the provided DCR graph and trace handlers. It sets up + all necessary data structures for computing the alignment and its costs. + + Parameters + ---------- + graph_handler : DCRGraphHandler + An instance of DCRGraphHandler to manage the DCR graph. + trace_handler : TraceHandler + An instance of TraceHandler to manage the event log trace. + parameters : Optional[Dict] + A dictionary of parameters to configure the alignment process. Defaults are used if None. + """ + self.graph_handler = graph_handler + + if parameters is None: + parameters = {} + activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY) + parameters[Parameters.ACTIVITY_KEY.value] = activity_key + + self.trace_handler = TraceHandler(trace_handler.trace, parameters) + + self.open_set = [] + self.max_cost = 0 + self.global_min = float('inf') + self.closed_set = {} + self.visited_states = set() + self.new_moves = [] + self.final_alignment = [] + self.initial_marking = deepcopy(self.graph_handler.graph.marking) + + def handle_state(self, curr_cost, curr_graph, curr_trace, event, moves, move_type=None): + """ + Manages the transition to a new state in the alignment algorithm based on the specified move type. + It computes the new state, checks for execution equivalency to avoid re-processing, and if unique, + updates the visited states and the priority queue for further processing. + + Parameters + ---------- + curr_cost : int + The current cost of the alignment. + curr_graph : DcrGraph + The current state of the DCR graph. + curr_trace : list + The current state of the trace. + event : Any + The event from the trace that is being considered in the current alignment step. + moves : list + The list of moves made so far. + move_type : str, optional + The type of move to make. This should be one of "sync", "model", or "log". Default is None. + + Returns + ------- + None + + Raises + ------ + None + + Notes + ----- + - This method interfaces with the `get_new_state` method to compute the new state. + - It employs a heap-based priority queue to manage the processing order of states based on their costs. + - Execution equivalency check is performed to reduce redundant processing of similar states. + """ + if moves is None: + moves = [] + + new_cost, new_graph, new_trace, new_move = self.get_new_state(curr_cost, curr_graph, curr_trace, event, + move_type) + + state_representation = (str(new_graph), tuple(map(str, new_trace))) + if state_representation not in self.visited_states: + self.visited_states.add(state_representation) + new_moves = moves + [new_move] + heappush(self.open_set,(new_cost, new_graph, new_trace, str(new_graph), new_moves)) + + def get_new_state(self, curr_cost, curr_marking, curr_trace, event, move_type): + """ + Computes the new state of the alignment algorithm based on the current state and + the specified move type. The new state includes the updated cost, graph, trace, + and move. This method handles three types of moves: synchronous, model, and log. + + Parameters + ---------- + curr_cost : int + The current cost of the alignment. + curr_graph : DcrGraph + The current state of the DCR graph. + curr_trace : list + The current state of the trace. + moves : list + The list of moves made so far. + move_type : str + The type of move to make. This should be one of "sync", "model", or "log". + + Returns + ------- + tuple + A tuple containing four elements: + - new_cost : int, the updated cost of the alignment. + - new_graph : DCR_Graph, the updated state of the DCR graph. + - new_trace : list, the updated state of the trace. + - new_move : tuple, a tuple representing the move made, formatted as (move_type, first_activity). + + Example + ------- + new_cost, new_graph, new_trace, new_move = get_new_state(curr_cost, curr_graph, curr_trace, moves, "sync") + + """ + new_cost = curr_cost + self.graph_handler.graph.marking = deepcopy(curr_marking) + new_graph = self.graph_handler.graph + new_trace = curr_trace + new_move = None + if move_type == "sync": + new_cost += Parameters.SYNC_COST.value + new_move = (event, event) + new_trace = curr_trace[1:] + new_graph = self.graph_handler.execute(event, new_graph) + + elif move_type == "model": + new_cost += Parameters.MODEL_COST.value + new_move = (event, ">>") + new_graph = self.graph_handler.execute(event, new_graph) + + elif move_type == "log": + new_cost += Parameters.LOG_COST.value + new_move = (">>", event) + new_trace = curr_trace[1:] + + return new_cost, deepcopy(new_graph.marking), new_trace, new_move + + def update_closed_and_visited_sets(self, curr_cost, state_repr): + self.closed_set[state_repr] = curr_cost + + def process_current_state(self, current): + """ + Process the current state in the alignment process. + This method processes the current state of the alignment, updates the graph handler + with the current graph, and prepares the state representation for further processing. + + Parameters + ---------- + current : Tuple + The current state, which is a tuple containing the current cost, current graph, + current trace, and the moves made up to this point. + """ + curr_cost, curr_marking, curr_trace, _, moves = current + self.graph_handler.graph.marking = deepcopy(curr_marking) + + # Check if the trace is None or empty and handle accordingly + if curr_trace is None or not curr_trace: + return curr_cost, curr_marking, (), str(self.graph_handler.graph.marking), moves + + state_repr = (str(self.graph_handler.graph.marking), tuple(map(str, curr_trace))) + return curr_cost, curr_marking, curr_trace, state_repr, moves + + def check_accepting_conditions(self, curr_cost, is_accepting): + """ + Check if the current state meets the accepting conditions and update the global minimum cost and final alignment. + + Parameters + ---------- + curr_cost : float + The cost associated with the current state. + is_accepting : bool + Flag indicating whether the current state is an accepting state. + + Returns + ------- + float + The final cost if the accepting conditions are met; `float('inf')` otherwise. + """ + if is_accepting: + if curr_cost <= self.global_min: + self.global_min = curr_cost + self.final_alignment = self.new_moves + + return self.global_min + + + def apply_trace(self, parameters=None): + """ + Applies the alignment algorithm to a trace in order to find an optimal alignment + between the DCR graph and the trace based on the algorithm outlined in the paper + by Axel Kjeld Fjelrad Christfort and Tijs Slaats. + https://link.springer.com/chapter/10.1007/978-3-031-41620-0_1 + + Parameters + ---------- + parameters : dict, optional + A dictionary of parameters to configure the alignment algorithm. + Possible keys include: + - Parameters.ACTIVITY_KEY: Specifies the key to use for activity names in the trace data. + - Parameters.CASE_ID_KEY: Specifies the key to use for case IDs in the trace data. + If not provided or None, default values are used. + + Returns + ------- + dict + A dictionary containing the results of the alignment algorithm, with the following keys: + - 'alignment': List of tuples representing the optimal alignment found. + - 'cost': The cost of the optimal alignment. + - 'visited': The number of states visited during the alignment algorithm. + - 'closed': The number of closed states during the alignment algorithm. + - 'global_min': The global minimum cost found during the alignment algorithm. + + Example + ------- + result = alignment_obj.apply_trace() + optimal_alignment = result['alignment'] + alignment_cost = result['cost'] + """ + + visited, closed, cost, self.final_alignment, final_cost = 0, 0, 0, None, float('inf') + self.open_set.append( + (cost, deepcopy(self.graph_handler.graph.marking), self.trace_handler.trace, + str(self.graph_handler.graph.marking), [])) + + while self.open_set: + current = heappop(self.open_set) + visited += 1 + result = self.process_current_state(current) + if result is None: + continue + curr_cost, curr_trace, state_repr, moves = result[0], result[2], result[3], result[4] + if curr_cost > final_cost: + continue + self.update_closed_and_visited_sets(curr_cost, state_repr) + closed += 1 + self.trace_handler.trace = curr_trace + if self.graph_handler.is_accepting() and self.trace_handler.is_empty(): + self.new_moves = moves + final_cost = self.check_accepting_conditions(curr_cost, self.graph_handler.is_accepting()) + self.max_cost = final_cost + + try: + self.perform_moves(curr_cost, current, moves) + except Exception as e: + print(f"Error performing moves: {str(e)}") + continue + + if self.final_alignment is None: + print("Warning: No valid alignment found.") + return None + + return self.construct_results(visited, closed, final_cost) + + def skip_current(self, result): + #if state is visited, and cost is the same skip + curr_cost, state_repr = result[0], result[3] + visitCost = self.closed_set.get(state_repr,float("inf")) + return visitCost <= curr_cost and visitCost is not float("inf") + + def perform_moves(self, curr_cost, current, moves): + """ + Defines available moves based on the trace and model state. + + This method determines which moves are possible (synchronous, model, or log moves) + so that they can be processed accordingly. Each move type is defined as: + - Synchronous (sync): The activity is both in the trace and the model, and is currently enabled. + - Model move: The activity is enabled in the model but not in the trace. + - Log move: The activity is in the trace but not enabled in the model. + + Parameters + ---------- + curr_cost : float + The cost associated with the current state before performing any moves. + current : tuple + The current state represented as a tuple containing the following: + - current[0]: The current cumulative cost associated with the trace. + - current[1]: The current state of the graph representing the model. + - current[2]: The current position in the trace. + - current[3]: A placeholder for additional information (if any). + - current[4]: The list of moves performed to reach this state. + moves : list + The list of moves performed so far to reach the current state. This will be updated with new moves + as they are performed. + """ + self.graph_handler.graph.marking = current[1] + first_activity_name = self.trace_handler.get_first_activity() + + if first_activity_name is None: + return # No more activities in the trace, just return + + try: + first_activity = self.graph_handler.graph.get_event(first_activity_name) + except KeyError: + self.handle_state(curr_cost, current[1], current[2], first_activity_name, moves, "log") + return + + enabled = self.graph_handler.enabled() + is_enabled = self.graph_handler.is_enabled(first_activity) + + if is_enabled: + self.handle_state(curr_cost, current[1], current[2], first_activity, moves, "sync") + return + + self.handle_state(curr_cost, current[1], current[2], first_activity, moves, "log") + + for event in enabled: + self.handle_state(curr_cost, current[1], current[2], event, moves, "model") + + def construct_results(self, visited, closed, final_cost): + """ + Constructs a dictionary of results from the alignment process containing various metrics + and outcomes, such as the final alignment, its cost, and statistics about the search process. + + Parameters + ---------- + visited : int + The number of states visited during the alignment process. + closed : int + The number of states that were closed (i.e., fully processed and will not be revisited). + final_cost : float + The cost associated with the final alignment obtained. + + Returns + ------- + dict + A dictionary with keys corresponding to various outputs of the alignment process: + - 'alignment': The final alignment between the process model and the trace. + - 'cost': The cost of the final alignment . + - 'visited': The total number of visited states. + - 'closed': The total number of closed states. + - 'model move fitness': the fitness provided that model moves are used + - 'log move fitness': the fitness provided by the log moves + """ + self.graph_handler.graph.marking = self.initial_marking + return { + Outputs.ALIGNMENT.value: self.final_alignment, + Outputs.COST.value: final_cost, + Outputs.VISITED.value: visited, + Outputs.CLOSED.value: closed, + Outputs.GLOBAL_MIN.value: self.global_min, + } + + +def apply(trace_or_log: Union[pd.DataFrame, EventLog, Trace], graph: DcrGraph, parameters=None): + """ + Applies the alignment algorithm to either a single trace or an entire event log. + + This function serves as the main entry point for the alignment process. It determines + whether to use the single-trace alignment or the multi-threaded log alignment based on + the input type and size. + + Parameters: + trace_or_log (Union[pd.DataFrame, EventLog, Trace]): The input trace or log to be aligned. + graph (DcrGraph): The DCR graph against which the alignment will be performed. + parameters (dict, optional): Additional parameters for the alignment process. + + Returns: + Union[List[Dict[str, Any]], Dict[str, Any]]: The alignment results. For a single trace, + it returns a dictionary. For a log, it returns a list of dictionaries. + """ + if isinstance(trace_or_log, Trace): + alignment = TraceAlignment(graph, trace_or_log, parameters=parameters) + return alignment.perform_alignment() + else: + if isinstance(trace_or_log, pd.DataFrame): + trace_or_log = log_converter.apply(trace_or_log, variant=log_converter.Variants.TO_EVENT_LOG) + + if len(trace_or_log) < 100: + return apply_original(trace_or_log, graph, parameters) + + alignment = LogAlignment(trace_or_log, parameters=parameters) + return alignment.perform_log_alignment(graph, parameters=parameters) + + +def apply_original(log: EventLog, graph: DcrGraph, parameters=None): + """ + Applies the alignment algorithm to an event log without using multithreading. + This function is used for smaller logs (less than 100 traces). + + Parameters: + ----------- + log : EventLog + The event log to be aligned. + graph : DcrGraph + The DCR graph against which the alignment will be performed. + parameters : dict, optional + Additional parameters for the alignment process. + + Returns: + -------- + List[Dict[str, Any]] + A list of dictionaries, each containing the alignment results for a single trace. + """ + results = [] + for trace in log: + alignment = TraceAlignment(graph, trace, parameters=parameters) + trace_result = alignment.perform_alignment() + results.extend(trace_result) + return results + +def apply_multithreaded(trace_or_log: Union[pd.DataFrame, EventLog, Trace], graph: DcrGraph, parameters=None): + """ + Applies the multithreaded alignment algorithm to either a single trace or an entire event log. + + This function is similar to 'apply', but it always uses the multithreaded approach for log alignment, + regardless of the log size. It's useful when processing large logs or when maximum performance is required. + + Parameters: + trace_or_log (Union[pd.DataFrame, EventLog, Trace]): The input trace or log to be aligned. + graph (DcrGraph): The DCR graph against which the alignment will be performed. + parameters (dict, optional): Additional parameters for the alignment process. + + Returns: + Union[List[Dict[str, Any]], Dict[str, Any]]: The alignment results. For a single trace, + it returns a dictionary. For a log, it returns a list of dictionaries. + """ + if isinstance(trace_or_log, Trace): + alignment = TraceAlignment(graph, trace_or_log, parameters=parameters) + return alignment.perform_alignment() + else: + if isinstance(trace_or_log, pd.DataFrame): + trace_or_log = log_converter.apply(trace_or_log, variant=log_converter.Variants.TO_EVENT_LOG) + + parameters = parameters or {} + parameters.setdefault("max_workers", 4) + + alignment = LogAlignment(trace_or_log, parameters=parameters) + return alignment.perform_log_alignment(graph, parameters=parameters) + + + +def get_diagnostics_dataframe(log: EventLog, conf_result: List[Dict[str, Any]], parameters=None) -> pd.DataFrame: + """ + Gets the diagnostics dataframe from a log and the conformance results + + Parameters + -------------- + log + Event log + conf_result + Results of conformance checking + variant + Variant to be used: + - Variants.CLASSIC + parameters + Variant-specific parameters + + Returns + -------------- + diagn_dataframe + Diagnostics dataframe + """ + if parameters is None: + parameters = {} + + case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, + xes_constants.DEFAULT_TRACEID_KEY) + + import pandas as pd + diagn_stream = [] + for index in range(len(log)): + case_id = log[index].attributes[case_id_key] + align_fitness = conf_result[index][Outputs.ALIGN_FITNESS.value] + diagn_stream.append({"case_id": case_id, "align_fitness": align_fitness}) + + return pd.DataFrame(diagn_stream) + diff --git a/pm4py/algo/conformance/dcr/__init__.py b/pm4py/algo/conformance/dcr/__init__.py new file mode 100644 index 0000000000..fcaee8d717 --- /dev/null +++ b/pm4py/algo/conformance/dcr/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.conformance.dcr import algorithm, variants, rules, decorators \ No newline at end of file diff --git a/pm4py/algo/conformance/dcr/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/conformance/dcr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..3d77fb3c50 Binary files /dev/null and b/pm4py/algo/conformance/dcr/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/__pycache__/algorithm.cpython-311.pyc b/pm4py/algo/conformance/dcr/__pycache__/algorithm.cpython-311.pyc new file mode 100644 index 0000000000..1b814da29b Binary files /dev/null and b/pm4py/algo/conformance/dcr/__pycache__/algorithm.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/algorithm.py b/pm4py/algo/conformance/dcr/algorithm.py new file mode 100644 index 0000000000..4d5cb808d2 --- /dev/null +++ b/pm4py/algo/conformance/dcr/algorithm.py @@ -0,0 +1,70 @@ +import pm4py +from pm4py.objects.log.obj import EventLog +import pandas as pd +from pm4py.algo.conformance.dcr.variants import classic +from enum import Enum +from pm4py.util import exec_utils +from typing import Union, Any, Dict, Tuple, List, Optional +from pm4py.util import constants + + +class Variants(Enum): + CLASSIC = classic + + +def apply(log: Union[pd.DataFrame, EventLog], G, variant=Variants.CLASSIC, + parameters: Optional[Dict[Union[Any, Any], Any]] = None) -> List[Dict[str, Any]]: + """ + Applies rule based conformance checking against a DCR graph and an event log. + + Parameters + ---------- + log + Event log / Pandas dataframe + G + DCR Graph + + variant + Variant to be used: + - Variants.CLASSIC + + parameters + Variant-specific parameters + + Returns + ---------- + conf_res + List containing dictionaries with the following keys and values: + - no_constr_total: the total number of constraints of the DCR Graphs + - deviations: the list of deviations + - no_dev_total: the total number of deviations + - dev_fitness: the fitness (1 - no_dev_total / no_constr_total), + - is_fit: True if the case is perfectly fit + """ + + # run apply function to return template with fulfilled and violated activities + return exec_utils.get_variant(variant).apply(log, G, parameters) + + +def get_diagnostics_dataframe(log: Union[EventLog, pd.DataFrame], conf_result: List[Dict[str, Any]], variant=Variants.CLASSIC, parameters=None) -> pd.DataFrame: + """ + Gets the diagnostics dataframe from a log and the conformance results + + Parameters + -------------- + log + Event log + conf_result + Results of conformance checking + variant + Variant to be used: + - Variants.CLASSIC + parameters + Variant-specific parameters + + Returns + -------------- + diagn_dataframe + Diagnostics dataframe + """ + return exec_utils.get_variant(variant).get_diagnostics_dataframe(log, conf_result, parameters) diff --git a/pm4py/algo/conformance/dcr/decorators/__init__.py b/pm4py/algo/conformance/dcr/decorators/__init__.py new file mode 100644 index 0000000000..fd0b4200f4 --- /dev/null +++ b/pm4py/algo/conformance/dcr/decorators/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.conformance.dcr.decorators import decorator, roledecorator \ No newline at end of file diff --git a/pm4py/algo/conformance/dcr/decorators/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/conformance/dcr/decorators/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..3a21491412 Binary files /dev/null and b/pm4py/algo/conformance/dcr/decorators/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/decorators/__pycache__/decorator.cpython-311.pyc b/pm4py/algo/conformance/dcr/decorators/__pycache__/decorator.cpython-311.pyc new file mode 100644 index 0000000000..313b7ee8be Binary files /dev/null and b/pm4py/algo/conformance/dcr/decorators/__pycache__/decorator.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/decorators/__pycache__/roledecorator.cpython-311.pyc b/pm4py/algo/conformance/dcr/decorators/__pycache__/roledecorator.cpython-311.pyc new file mode 100644 index 0000000000..e622b466f8 Binary files /dev/null and b/pm4py/algo/conformance/dcr/decorators/__pycache__/roledecorator.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/decorators/decorator.py b/pm4py/algo/conformance/dcr/decorators/decorator.py new file mode 100644 index 0000000000..4d41217d23 --- /dev/null +++ b/pm4py/algo/conformance/dcr/decorators/decorator.py @@ -0,0 +1,204 @@ +from abc import ABC, abstractmethod +from pm4py.algo.conformance.dcr.rules.condition import CheckCondition +from pm4py.algo.conformance.dcr.rules.exclude import CheckExclude +from pm4py.algo.conformance.dcr.rules.include import CheckInclude +from pm4py.algo.conformance.dcr.rules.response import CheckResponse +from pm4py.objects.dcr.obj import DcrGraph +from typing import List, Any, Dict, Tuple, Optional, Union + +class Checker(ABC): + """ + An interface for Checker implementations and related decorators. + + This abstract base class defines the fundamental checker methods that must be implemented by concrete + checker classes. These methods are aimed at evaluating various conformance rules within a DCR graph. + + Methods + ------- + enabled_checker(act, G, deviations, parameters=None): + Abstract method to check rules when an activity is enabled. + + all_checker(act, event, G, deviations, parameters=None): + Abstract method to check rules for all types of activities. + + accepting_checker(G, responses, deviations, parameters=None): + Abstract method to check for rules requiring an accepting state. + The checker class provides the methods that must be inherited by the decorators. + The checker class instantiates the conformance checker methods that will be overwritten to perform the determine possible deviations. + currently supports: + * For the standard base DCR graph, enabled_checker() and accepting_checker() methods are used + * For a DCR Graph with distributed, the all_checker() methods was derived to give a means for checking deviating role assignment + + Methods + -------- + enabled_Checker(event, graph, deviations, parameters): + method to determine deviations of non enabled events, i.e events that are not allowed to execute + all_checker(event, event_attributes, graph, deviations, parameters): + method to determine deviations of event for each execution + accepting_checker(graph, responses, deviations, parameters): + method to determine deviations that caused DCR graph to be in a non-accepting state. + """ + + @abstractmethod + def enabled_checker(self, event: str, graph: DcrGraph, deviations:List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + pass + + @abstractmethod + def all_checker(self, event: str, event_attributes: dict, graph: DcrGraph, deviations:List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + pass + + @abstractmethod + def accepting_checker(self, graph: DcrGraph, responses: List[Tuple[str, str]], deviations:List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + pass + + +class ConcreteChecker(Checker): + """ + The ConcreteChecker class, provides the base for the functionality that the checker should provide. + + Contains all the methods needed to perform conformance checking for a base DCR Graph + + Methods + -------- + enabled_Checker(act, G, deviations, parameters): + Determine the deviation that caused it not to be enabled + all_checker(act, event, G, deviations, parameters): + Checks for nothing as no rule for a base DCR graph has rules that would be required to determine with every execution of an event + accepting_checker(G, responses, deviations, parameters): + determine the deviation that caused the DCR graph to be non-accepting after an execution of a trace + """ + + def enabled_checker(self, event: str, graph: DcrGraph, deviations: List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + """ + enabled_checker() is called when an event that is to be executed is not enabled + Check all the deviations that could be associated with a not enabled event for a base DCR Graph + + Parameters + ---------- + event: str + the executed event + graph: DcrGraph + DCR Graph + deviations: List[Any] + the list of deviations + parameters: Optional[Dict[Union[str, Any], Any]] + optional parameters + """ + CheckCondition.check_rule(event, graph, deviations) + CheckExclude.check_rule(event, graph, parameters['executionHistory'], deviations) + CheckInclude.check_rule(event, graph, deviations) + + def all_checker(self, event: str, event_attributes: dict, graph: DcrGraph, deviations: List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + pass + + def accepting_checker(self, graph: DcrGraph, responses: List[Tuple[str, str]], deviations: List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + """ + accepting_checker is called when a DCR graph is not accepting after an execution of a trace + checks all response deviations for a base DCR Graph + + Parameters + ---------- + graph: DcrGraph + DCR Graph + responses: List[Tuple[str, str]] + list of response constraint not fulfilled + deviations: List[Any] + the list of deviations + parameters: Optional[Dict[Union[str, Any], Any]] + Optional, parameter containing keys used + """ + CheckResponse.check_rule(graph, responses, deviations) + + +class Decorator(Checker): + """ + A decorator for Checker objects, providing a flexible mechanism to enhance or modify their behavior. + + This class implements the decorator pattern to wrap a Checker object. It overrides the Checker + interface methods and can add additional functionality before or after invoking these methods on + the wrapped Checker instance. + + Inherits From + -------------- + Checker : The abstract base class for checker implementations. + + Attributes + ---------- + + self._checker : Checker + The internal Checker instance that is being decorated. + + Methods + ------- + enabled_checker(act, G, deviations, parameters=None): + Invokes the enabled_checker method on the decorated Checker instance, potentially adding extra behavior. + + all_checker(act, event, G, deviations, parameters=None): + Invokes the all_checker method on the decorated Checker instance, potentially adding extra behavior. + + accepting_checker(G, trace, deviations, parameters=None): + Invokes the accepting_checker method on the decorated Checker instance, potentially adding extra behavior. + """ + def __init__(self, checker: Checker) -> None: + """ + Constructs the checker with another checker, such that it can be called + + Parameters + ---------- + checker: Checker + The checker that will be decorated + """ + self._checker = checker + + def enabled_checker(self, event: str, graph: DcrGraph, deviations: List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + """ + This method calls enabled_checker() of the underlying class to continue search for cause of deviation between Graph and event Log + + Parameters + ---------- + event: str + Current event ID in trace + graph: DcrGraph + DCR Graph + deviations: List[Any] + List of deviations + parameters: Optional[Dict[Union[str, Any], Any]] + optional parameters + """ + self._checker.enabled_checker(event, graph, deviations, parameters=parameters) + + def all_checker(self, event: str, event_attributes: dict, graph: DcrGraph, deviations: List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + """ + This method calls all_checker() of the underlying class to continue search for cause of deviation between Graph and event Log + + Parameters + ---------- + event: str + Current event ID in trace + event_attributes: dict + Current event with all attributes + graph: DcrGraph + DCR Graph + deviations: List[Any] + List of deviations + parameters: Optional[Dict[Union[str, Any], Any]] + optional parameters + """ + self._checker.all_checker(event, event_attributes, graph, deviations, parameters=parameters) + + def accepting_checker(self, graph: DcrGraph, responses: List[Tuple[str, str]], deviations: List[Any], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + """ + This method calls accepting_checker() of the underlying class to continue search for cause of deviation between Graph and event Log + + Parameters + ---------- + graph: DcrGraph + DCR Graph + responses: List[Tuple[str, str]] + The recorded response relation between events to be executed and it originator + deviations: List[Any] + List of deviations + parameters: Optional[Dict[Union[str, Any], Any]] + optional parameters + """ + self._checker.accepting_checker(graph, responses, deviations, parameters=parameters) diff --git a/pm4py/algo/conformance/dcr/decorators/roledecorator.py b/pm4py/algo/conformance/dcr/decorators/roledecorator.py new file mode 100644 index 0000000000..ec6de72aa0 --- /dev/null +++ b/pm4py/algo/conformance/dcr/decorators/roledecorator.py @@ -0,0 +1,37 @@ +from enum import Enum +from pm4py.algo.conformance.dcr.decorators.decorator import Decorator +from pm4py.algo.conformance.dcr.rules.role import CheckRole +from pm4py.util import exec_utils, constants, xes_constants +from pm4py.objects.dcr.distributed.obj import DistributedDcrGraph +from pm4py.objects.dcr.obj import DcrGraph +from typing import Optional, Dict, Union, Any, List, Tuple + +class Parameters(Enum): + GROUP_KEY = constants.PARAMETER_CONSTANT_GROUP_KEY + +class RoleDecorator(Decorator): + """ + The RoleDecorator Class is used to provide methods for checking deviations of distributed. + It will call a method to check if the current event is executed by an entity that has authority to perform + the activity the event represents. + + Methods + -------- + enabled_checker(event, graph, deviations, parameters=None) + this method will call the underlying class used to check for deviations + all_checker(event, event_attributes, graph, deviations, parameters=None) + This method will determine if deviations occurs due to violation of role assignments + enabled_checker(e, G, deviations, parameters=None) + this method will call the underlying class used to check for deviations + """ + def enabled_checker(self, event: str, graph: Union[DistributedDcrGraph, DcrGraph], deviations: List[Tuple[str, Any]], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + self._checker.enabled_checker(event, graph, deviations, parameters) + + def all_checker(self, event: str, event_attributes: dict, graph: Union[DistributedDcrGraph, DcrGraph], deviations: List[Tuple[str, Any]], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + self._checker.all_checker(event, event_attributes, graph, deviations, parameters=parameters) + group_key = exec_utils.get_param_value(Parameters.GROUP_KEY,parameters,xes_constants.DEFAULT_GROUP_KEY) + role = event_attributes[group_key] + CheckRole.check_rule(event, graph, role, deviations) + + def accepting_checker(self, graph: Union[DistributedDcrGraph, DcrGraph], responses: List[Tuple[str, str]], deviations: List[Tuple[str, Any]], parameters: Optional[Dict[Union[str, Any], Any]] = None) -> None: + self._checker.accepting_checker(graph, responses, deviations, parameters) \ No newline at end of file diff --git a/pm4py/algo/conformance/dcr/rules/__init__.py b/pm4py/algo/conformance/dcr/rules/__init__.py new file mode 100644 index 0000000000..271a563f3a --- /dev/null +++ b/pm4py/algo/conformance/dcr/rules/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.conformance.dcr.rules import abc, condition, exclude, include, response, role \ No newline at end of file diff --git a/pm4py/algo/conformance/dcr/rules/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/conformance/dcr/rules/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..c53a9f3239 Binary files /dev/null and b/pm4py/algo/conformance/dcr/rules/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/rules/__pycache__/abc.cpython-311.pyc b/pm4py/algo/conformance/dcr/rules/__pycache__/abc.cpython-311.pyc new file mode 100644 index 0000000000..10f77d1207 Binary files /dev/null and b/pm4py/algo/conformance/dcr/rules/__pycache__/abc.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/rules/__pycache__/condition.cpython-311.pyc b/pm4py/algo/conformance/dcr/rules/__pycache__/condition.cpython-311.pyc new file mode 100644 index 0000000000..0f096cd545 Binary files /dev/null and b/pm4py/algo/conformance/dcr/rules/__pycache__/condition.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/rules/__pycache__/exclude.cpython-311.pyc b/pm4py/algo/conformance/dcr/rules/__pycache__/exclude.cpython-311.pyc new file mode 100644 index 0000000000..cabfb7c3b1 Binary files /dev/null and b/pm4py/algo/conformance/dcr/rules/__pycache__/exclude.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/rules/__pycache__/include.cpython-311.pyc b/pm4py/algo/conformance/dcr/rules/__pycache__/include.cpython-311.pyc new file mode 100644 index 0000000000..5a661198d4 Binary files /dev/null and b/pm4py/algo/conformance/dcr/rules/__pycache__/include.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/rules/__pycache__/response.cpython-311.pyc b/pm4py/algo/conformance/dcr/rules/__pycache__/response.cpython-311.pyc new file mode 100644 index 0000000000..8a2a062ec6 Binary files /dev/null and b/pm4py/algo/conformance/dcr/rules/__pycache__/response.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/rules/__pycache__/role.cpython-311.pyc b/pm4py/algo/conformance/dcr/rules/__pycache__/role.cpython-311.pyc new file mode 100644 index 0000000000..e694682097 Binary files /dev/null and b/pm4py/algo/conformance/dcr/rules/__pycache__/role.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/rules/abc.py b/pm4py/algo/conformance/dcr/rules/abc.py new file mode 100644 index 0000000000..0e39ac46b1 --- /dev/null +++ b/pm4py/algo/conformance/dcr/rules/abc.py @@ -0,0 +1,9 @@ +from abc import ABC, abstractmethod + +class CheckFrame(ABC): + """ + the CheckFrame Class creates an interface, that specifies which functionality that associated class should have + """ + @abstractmethod + def check_rule(self, *args, **kwargs): + pass \ No newline at end of file diff --git a/pm4py/algo/conformance/dcr/rules/condition.py b/pm4py/algo/conformance/dcr/rules/condition.py new file mode 100644 index 0000000000..b4a64c10c0 --- /dev/null +++ b/pm4py/algo/conformance/dcr/rules/condition.py @@ -0,0 +1,34 @@ +from pm4py.algo.conformance.dcr.rules.abc import CheckFrame +from pm4py.objects.dcr.obj import DcrGraph +from typing import List, Tuple, Any + +class CheckCondition(CheckFrame): + @classmethod + def check_rule(cls, event: str, graph: DcrGraph, deviations: List[Tuple[str, Any]]): + ''' + Checks if event violates the conditions relation + + Parameters + -------------- + event: str + Current event + graph: DcrGraph + DCR Graph + deviations: List[Tuple[str, Any]] + List of deviations + Returns + -------------- + deviations: List[Tuple[str, Any]] + List of updated deviation if any were detected + ''' + # we check if conditions for activity has been executed, if not, that's a conditions violation + # check if act is in conditions for + if event in graph.conditions: + # check the conditions for event act + for event_prime in graph.conditions[event]: + # if conditions are included and not executed, add violation + if event_prime in graph.conditions[event].intersection( + graph.marking.included.difference(graph.marking.executed)): + if ('conditionViolation', (event_prime, event)) not in deviations: + deviations.append(('conditionViolation', (event_prime, event))) + return deviations diff --git a/pm4py/algo/conformance/dcr/rules/exclude.py b/pm4py/algo/conformance/dcr/rules/exclude.py new file mode 100644 index 0000000000..1008f2732c --- /dev/null +++ b/pm4py/algo/conformance/dcr/rules/exclude.py @@ -0,0 +1,38 @@ +from pm4py.algo.conformance.dcr.rules.abc import CheckFrame +from pm4py.objects.dcr.obj import DcrGraph +from typing import List, Tuple, Any + +class CheckExclude(CheckFrame): + @classmethod + def check_rule(cls, event: str, graph: DcrGraph, execution_his:List, deviations: List[Tuple[str, Any]]): + ''' + Checks if event violates the exclude relation + + Parameters + -------------- + event: str + Current event + graph: DcrGraph + DCR Graph + execution_his: List + List to check for when event was excluded + deviations: List[Tuple[str, Any]] + List of deviations + Returns + -------------- + deviations: List[Tuple[str, Any]] + List of updated deviation if any were detected + ''' + # if an activity has been excluded, but trace tries to execute, exclude violation + if event not in graph.marking.included: + exclude_origin = [] + for event_prime in execution_his: + if event in graph.excludes.get(event_prime,set()): + exclude_origin.append(event_prime) + if event in graph.includes.get(event_prime,set()): + exclude_origin = [] + #if violation exist, no need to store it + for event_prime in exclude_origin: + if ('excludeViolation', (event_prime, event)) not in deviations: + deviations.append(('excludeViolation', (event_prime, event))) + return deviations diff --git a/pm4py/algo/conformance/dcr/rules/include.py b/pm4py/algo/conformance/dcr/rules/include.py new file mode 100644 index 0000000000..fecfceed5b --- /dev/null +++ b/pm4py/algo/conformance/dcr/rules/include.py @@ -0,0 +1,30 @@ +from pm4py.algo.conformance.dcr.rules.abc import CheckFrame +from pm4py.objects.dcr.obj import DcrGraph +from typing import List, Tuple, Any + +class CheckInclude(CheckFrame): + @classmethod + def check_rule(cls, event: str, graph: DcrGraph, deviations: List[Tuple[str, Any]]): + """ + Checks if event violates the include relation + + Parameters + -------------- + event: str + current event + graph: DcrGraph + DCR Graph + deviations: List[Tuple[str, Any]] + List of deviations + + Returns + -------------- + deviations: List[Tuple[str, Any]] + List of updated deviation if any were detected + """ + if event not in graph.marking.included: + for event_prime in graph.includes: + if event in graph.includes[event_prime]: + if ['includeViolation', (event_prime, event)] not in deviations: + deviations.append(('includeViolation', (event_prime, event))) + return deviations diff --git a/pm4py/algo/conformance/dcr/rules/response.py b/pm4py/algo/conformance/dcr/rules/response.py new file mode 100644 index 0000000000..5e3a615b8f --- /dev/null +++ b/pm4py/algo/conformance/dcr/rules/response.py @@ -0,0 +1,32 @@ +from pm4py.algo.conformance.dcr.rules.abc import CheckFrame +from typing import Union +from pm4py.objects.dcr.obj import DcrGraph +from typing import List, Tuple, Any + +class CheckResponse(CheckFrame): + @classmethod + def check_rule(cls, graph: DcrGraph, responses: List[Tuple[str, str]], deviations: List[Tuple[str, Any]]): + """ + Checks if event violates the response relation. + + If DCR Graph contains pending events, the Graph has not done an incomplete run, as events are waiting to be executed + + Parameters + -------------- + graph: DcrGraph + DCR graph + responses: + responses not yet executed + deviations: List[Tuple[str, Any]] + List of deviations + + Returns + -------------- + deviations: List[Tuple[str, Any]] + List of updated deviation if any were detected + """ + # if activities are pending, and included, thats a response violation + if graph.marking.included.intersection(graph.marking.pending): + for pending in responses: + deviations.append(('responseViolation', tuple(pending))) + return deviations diff --git a/pm4py/algo/conformance/dcr/rules/role.py b/pm4py/algo/conformance/dcr/rules/role.py new file mode 100644 index 0000000000..afbe296237 --- /dev/null +++ b/pm4py/algo/conformance/dcr/rules/role.py @@ -0,0 +1,49 @@ +from pm4py.algo.conformance.dcr.rules.abc import CheckFrame +from pm4py.objects.dcr.distributed.obj import DistributedDcrGraph +from typing import List, Tuple, Any + + +class CheckRole(CheckFrame): + @classmethod + def check_rule(cls, event: str, graph: DistributedDcrGraph, role: str, deviations: List[Tuple[str, Any]]): + ''' + Checks if event violates the role assignments + 1.) if event contain role not in model + 2.) if event in model contains distributed, but executed with wrong event + + Parameters + -------------- + event: str + current event + graph: DistributedDcrGraph + DCR Graph + role: str + Role of the event + deviations: List[Tuple[str, Any]] + List of deviations + Returns + -------------- + deviations: List[Tuple[str, Any]] + List of updated deviation if any were detected + ''' + if role not in graph.roles and role == role: + # if role doesn't exist, means that they do not have authority to perform the action + if ('roleViolation', role) not in deviations: + deviations.append(('roleViolation', role)) + return deviations + else: + temp = {event: set()} + for i in graph.role_assignments: + if event in graph.role_assignments[i]: + temp[event].add(i) + # if activity has no role, return, as it can be excuted by anybody + if not temp[event]: + return deviations + # if event in model has roles + # violation when: + # 1) when as event in model does not have role + res = temp[event].intersection({role}) + if not res: + if ('roleViolation', (role, event)) not in deviations: + deviations.append(('roleViolation', (role, event))) + return deviations diff --git a/pm4py/algo/conformance/dcr/variants/__init__.py b/pm4py/algo/conformance/dcr/variants/__init__.py new file mode 100644 index 0000000000..d0bc87a1e5 --- /dev/null +++ b/pm4py/algo/conformance/dcr/variants/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.conformance.dcr.variants import classic \ No newline at end of file diff --git a/pm4py/algo/conformance/dcr/variants/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/conformance/dcr/variants/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..442aa1c111 Binary files /dev/null and b/pm4py/algo/conformance/dcr/variants/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/variants/__pycache__/classic.cpython-311.pyc b/pm4py/algo/conformance/dcr/variants/__pycache__/classic.cpython-311.pyc new file mode 100644 index 0000000000..28fe73da14 Binary files /dev/null and b/pm4py/algo/conformance/dcr/variants/__pycache__/classic.cpython-311.pyc differ diff --git a/pm4py/algo/conformance/dcr/variants/classic.py b/pm4py/algo/conformance/dcr/variants/classic.py new file mode 100644 index 0000000000..19f59a371b --- /dev/null +++ b/pm4py/algo/conformance/dcr/variants/classic.py @@ -0,0 +1,381 @@ +import pandas as pd +from enum import Enum +from pm4py.util import exec_utils, constants, xes_constants +from typing import Optional, Dict, Any, Union, List, Tuple +from pm4py.objects.log.obj import EventLog +from pm4py.objects.dcr.semantics import DcrSemantics +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.objects.dcr.distributed.obj import DistributedDcrGraph +from pm4py.algo.conformance.dcr.decorators.decorator import ConcreteChecker +from pm4py.algo.conformance.dcr.decorators.roledecorator import RoleDecorator + + + +class Parameters(Enum): + CASE_ID_KEY = constants.PARAMETER_CONSTANT_CASEID_KEY + ACTIVITY_KEY = constants.PARAMETER_CONSTANT_ACTIVITY_KEY + +class Outputs(Enum): + FITNESS = "dev_fitness" + DEVIATIONS = "deviations" + NO_DEV_TOTAL = "no_dev_total" + NO_CONSTR_TOTAL = 'no_constr_total' + IS_FIT = "is_fit" + + +class RuleBasedConformance: + """ + The RoleBasedConformance class provides a simplified interface to perform Rule based conformance check for DCR graphs + abstract the complexity of direct interaction with the underlying classes: + - CheckConditions + - CheckResponses + - CheckExcludes + - CheckIncludes + - CheckRoles, + + RuleBasedConformance is initialized, with the DCR graph to be analyzed, The event log to be replayed, + Optional parameters can also be passed to customize the processing, such as specifying custom activity + and case ID keys. + + After initialization of RuleBasedConformance class, user can call apply_conformance(), + where the DCR Graph will replay the provided event log. Once replay is done, + returns a list of conformance results for each trace, such as fitness, and the deviations + + Example usage: + + + + Note: + - The user is expected to have a base understanding of DCR Graphs and rule based conformance checking in context of process mining + + Attributes: + DCR Graph: The DCR graph to be checked + Event log: The event log to be replayed + Checker (HandleChecker): handler for the conformance checkers for each rule. + Semantics (DcrSemantics()): The semantics used executing events from the event log + Parameters: optinal parameters given by the user + + Methods: + apply_conformance(): performs the replay and computing of conformance of each trace + """ + + def __init__(self, log: Union[EventLog, pd.DataFrame], graph: Union[DcrGraph, DistributedDcrGraph], + parameters: Optional[Dict[Union[str, Any], Any]] = None): + self.__g = graph + if isinstance(log, pd.DataFrame): + log = self.__transform_pandas_dataframe(log, exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, + constants.CASE_CONCEPT_NAME)) + self.__log = log + self.__checker = HandleChecker(graph) + self.__semantics = DcrSemantics() + self.__parameters = parameters + + def apply_conformance(self) -> List[Dict[str, Any]]: + """ + Apply Rule based conformance against a DCR Graph, replays the event log using the DCR graph. + A DCR Graph will before each execution, check for deviations if the current event to be executed is enabled + or if DCR graph contains distributed, if events are executed by the correct distributed. + Will for each replay of trace check if DCR graph is in an accepting state, if not it determines cause. + + For each replay it computes the fitness of the trace. + + Implementation based on the theory provided in [1]. + + Returns + ---------- + :return: List containing dictionaries with the following keys and values: + - no_constr_total: the total number of constraints of the DCR Graphs + - deviations: the list of deviations + - no_dev_total: the total number of deviations + - dev_fitness: the fitness (1 - no_dev_total / no_constr_total), + - is_fit: True if the case is perfectly fit + :rtype: List[Dict[str, Any]] + + References + ---------- + * [1] C. Josep et al., "Conformance Checking Software", Springer International Publishing, 65-74, 2018. `DOI `_. + """ + + # Create list for accumalating each trace data for conformance + conf_case = [] + + # number of constraints (the relations between activities) + total_num_constraints = self.__g.get_constraints() + + # get activity key + activity_key = exec_utils.get_param_value(constants.PARAMETER_CONSTANT_ACTIVITY_KEY, self.__parameters, + xes_constants.DEFAULT_NAME_KEY) + + initial_marking = {'executed': set(), 'included': set(), 'pending': set()} + initial_marking['included'] = set(self.__g.marking.included) + initial_marking['executed'] = set(self.__g.marking.executed) + initial_marking['pending'] = set(self.__g.marking.pending) + + # iterate through all traces in log + for trace in self.__log: + # create base dict to accumalate trace conformance data + ret = {Outputs.NO_CONSTR_TOTAL.value: total_num_constraints, Outputs.DEVIATIONS.value: []} + # execution_his for checking dynamic excludes + self.__parameters['executionHistory'] = [] + # response_originator for checking reason for not accepting state + response_origin = [] + # iterate through all events in a trace + for event in trace: + # get the event to be executed + e = self.__g.get_event(event[activity_key]) + self.__parameters['executionHistory'].append(e) + + # check for deviations + if e in self.__g.responses: + for response in self.__g.responses[e]: + response_origin.append((e, response)) + + self.__checker.all_checker(e, event, self.__g, ret[Outputs.DEVIATIONS.value], + parameters=self.__parameters) + + if not self.__semantics.is_enabled(e, self.__g): + self.__checker.enabled_checker(e, self.__g, ret[Outputs.DEVIATIONS.value], + parameters=self.__parameters) + + # execute the event + self.__semantics.execute(self.__g, e) + + if len(response_origin) > 0: + for i in response_origin: + if e == i[1]: + response_origin.remove(i) + + # check if run is accepting + if not self.__semantics.is_accepting(self.__g): + self.__checker.accepting_checker(self.__g, response_origin, ret[Outputs.DEVIATIONS.value], + parameters=self.__parameters) + + # compute the conformance for the trace + ret[Outputs.NO_DEV_TOTAL.value] = len(ret[Outputs.DEVIATIONS.value]) + ret[Outputs.FITNESS.value] = 1 - ret[Outputs.NO_DEV_TOTAL.value] / ret[Outputs.NO_CONSTR_TOTAL.value] + ret[Outputs.IS_FIT.value] = ret[Outputs.NO_DEV_TOTAL.value] == 0 + conf_case.append(ret) + + # reset graph + self.__g.marking.reset(initial_marking.copy()) + + return conf_case + + def __transform_pandas_dataframe(self, dataframe: pd.DataFrame, case_id_key: str): + """ + Transforms a pandas DataFrame into a list of event logs grouped by cases. + Uses a snippet from __transform_dataframe_to_event_stream_new as template to transform pandas dataframe + + This function takes a pandas DataFrame where each row represents an event and converts it into a + list of lists, where each inner list contains all events related to a single case. The grouping + of events into cases is based on the case identifier specified by the 'case_id_key' parameter. + + Parameters: + - dataframe (pd.DataFrame): The pandas DataFrame to be transformed. + - case_id_key (str): The column name in the DataFrame that acts as the case identifier. + + Returns: + - list: A list of event logs, where each event log is a list of events (dictionaries) + corresponding to a single case. + + Each event in the event log is represented as a dictionary, where the keys are the column names + from the DataFrame and the values are the corresponding values for that event. + """ + list_events = [] + columns_names = list(dataframe.columns) + columns_corr = [] + log = [] + last_case_key = dataframe.iloc[0][case_id_key] + for c in columns_names: + columns_corr.append(dataframe[c].to_numpy()) + length = columns_corr[-1].size + for i in range(length): + event = {} + for j in range(len(columns_names)): + event[columns_names[j]] = columns_corr[j][i] + if last_case_key != event[case_id_key]: + log.append(list_events) + list_events = [] + last_case_key = event[case_id_key] + list_events.append(event) + log.append(list_events) + return log + + +class HandleChecker: + """ + HandleChecker is responsible for the constructing and calling the associated conformance checker + for the replay algorithm. This class provides the functionalities to check conformance, + retrieves the underlying methods for rule checking deviations + + The handle checker is provided the DCR graphs, to construct the collection of methods used for conformance checking + + Attributes + ----------- + Checker: :class:`pm4py.algo.conformance.dcr.decorators.decorator.Checker` + The Checker to be used to compute and determine deviations during replay + + Methods + ----------- + enabled_checker(event, graph, deviations, parameters) -> None: + Checks for deviations when an activity is not enabled in the DCR Graphs + + all_checker(event, event_attributes, graph, deviations, parameters) -> None: + Check for deviations that can happen when the rule is not dependent on events being enabled + + accepting_checker(graph, response_origin, deviations, parameters) -> None: + Checks for deviations that caused the DCR Graphs to be in an unaccepted State after replay + + Parameters + ---------- + graph: Union[DcrGraph, DistributedDcrGraph] + DCR graph + """ + + def __init__(self, graph: Union[DcrGraph, DistributedDcrGraph]): + """ + Constructs the CheckHandler, uses the decorator to add functionality depending on input Graph + - DCR_Graph construct standard checker + - RoleDCR_Graph Decorate standard checker with Role Checking functionality + Parameters + ---------- + graph: Union[DcrGraph, DistributedDcrGraph] + DCR Graph + """ + self.checker = ConcreteChecker() + # check for additional attributes in dcr, instantiate decorator associated + if hasattr(graph, 'roles'): + self.checker = RoleDecorator(self.checker) + + def enabled_checker(self, event: str, graph: Union[DcrGraph, DistributedDcrGraph], deviations: List[Any], + parameters: Optional[Dict[Any, Any]] = None) -> None: + """ + Enabled checker called when event is not enabled for execution in trace + Parameters + ---------- + event: str + Current event in trace + graph: Union[DcrGraph, DistributedDcrGraph] + DCR Graph + deviations: List[Any] + List of deviations + parameters: Optional[Dict[Any, Any]] + Optional parameters + """ + self.checker.enabled_checker(event, graph, deviations, parameters=parameters) + + def all_checker(self, event: str, event_attributes: Dict, graph: Union[DcrGraph, DistributedDcrGraph], deviations: List[Any], + parameters: Optional[Dict[Any, Any]] = None) -> None: + """ + All checker called for each event in trace to check if any deviation happens regardless of being enabled + + Parameters + ---------- + event: str + Current event in trace + event_attributes: Dict + All event information used for conformance checking + graph: Union[DcrGraph, DistributedDcrGraph] + DCR Graph + deviations: List[Any] + List of deviations + parameters: Optional[Dict[Any, Any]] + Optional parameters + + """ + self.checker.all_checker(event, event_attributes, graph, deviations, parameters=parameters) + + def accepting_checker(self, graph: Union[DcrGraph, DistributedDcrGraph], response_origin: List[Tuple[str,str]], + deviations: List[Any], parameters: Optional[Dict[Any, Any]] = None) -> None: + """ + Accepting checker, called when the DCR graph at the end of trace execution is not not accepting + + Parameters + ---------- + graph: Union[DcrGraph, DistributedDcrGraph] + DCR Graph + response_origin + deviations: List[Any] + List of deviations + parameters: Optional[Dict[Any, Any]] + Optional parameters + """ + self.checker.accepting_checker(graph, response_origin, deviations, parameters=parameters) + + +def apply(log: Union[pd.DataFrame, EventLog], graph: Union[DcrGraph, DistributedDcrGraph], + parameters: Optional[Dict[Any, Any]] = None): + """ + Applies rule based conformance checking against a DCR graph and an event log. + Replays the entire log, executing each event and store potential deviations based on set rules associated with the DCR graph. + + Implementation based on the theory provided in [1]_. + + Parameters + ----------- + :param log: pd.DataFrame | EventLog + event log as :class: `EventLog` or as pandas Dataframe + :param graph: DCR_Graph | RoleDCR_Graph + DCR Graph + :param parameters: Optional[Dict[Any, Any]] + Possible parameters of the algorithm, including: + - Parameters.ACTIVITY_KEY => the attribute to be used as activity + - Parameters.CASE_ID_KEY => the attribute to be used as case identifier + - Parameters.GROUP_KEY => the attribute to be used as role identifier + + Returns + ---------- + :return: List containing dictionaries with the following keys and values: + - no_constr_total: the total number of constraints of the DCR Graphs + - deviations: the list of deviations + - no_dev_total: the total number of deviations + - dev_fitness: the fitness (1 - no_dev_total / no_constr_total), + - is_fit: True if the case is perfectly fit + + References + ---------- + .. [1] C. Josep et al., "Conformance Checking Software", + Springer International Publishing, 65-74, 2018. `DOI `_. + """ + if parameters is None: + parameters = {} + con = RuleBasedConformance(log, graph, parameters=parameters) + return con.apply_conformance() + + +def get_diagnostics_dataframe(log: Union[EventLog, pd.DataFrame], conf_result: List[Dict[str, Any]], + parameters: Optional[Dict[Any, Any]] = None) -> pd.DataFrame: + """ + Gets the diagnostics dataframe from a log and the results of conformance checking of DCR graph + + Applies the same functionality as log_skeleton and declare + + Parameters + --------------- + :param log: event log as :class: `EventLog` or as pandas Dataframe + :param conf_result: Results of conformance checking + :param parameters: Optional Parameter to specify case id key + + Returns + --------------- + :return: Diagnostics dataframe + """ + + if parameters is None: + parameters = {} + + case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, + xes_constants.DEFAULT_TRACEID_KEY) + + import pandas as pd + diagn_stream = [] + for index in range(len(log)): + case_id = log[index].attributes[case_id_key] + no_dev_total = conf_result[index][Outputs.NO_DEV_TOTAL.value] + no_constr_total = conf_result[index][Outputs.NO_CONSTR_TOTAL.value] + dev_fitness = conf_result[index][Outputs.FITNESS.value] + + diagn_stream.append({"case_id": case_id, "no_dev_total": no_dev_total, "no_constr_total": no_constr_total, + "dev_fitness": dev_fitness}) + + return pd.DataFrame(diagn_stream) diff --git a/pm4py/algo/discovery/dcr_discover/__init__.py b/pm4py/algo/discovery/dcr_discover/__init__.py new file mode 100644 index 0000000000..e89f7ce6d1 --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.discovery.dcr_discover import algorithm, variants, extenstions \ No newline at end of file diff --git a/pm4py/algo/discovery/dcr_discover/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/discovery/dcr_discover/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..1fd98fd286 Binary files /dev/null and b/pm4py/algo/discovery/dcr_discover/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/discovery/dcr_discover/__pycache__/algorithm.cpython-311.pyc b/pm4py/algo/discovery/dcr_discover/__pycache__/algorithm.cpython-311.pyc new file mode 100644 index 0000000000..12f2fbe421 Binary files /dev/null and b/pm4py/algo/discovery/dcr_discover/__pycache__/algorithm.cpython-311.pyc differ diff --git a/pm4py/algo/discovery/dcr_discover/algorithm.py b/pm4py/algo/discovery/dcr_discover/algorithm.py new file mode 100644 index 0000000000..f31b2f77bb --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/algorithm.py @@ -0,0 +1,82 @@ +from pm4py.objects.log.obj import EventLog +from pm4py.util import exec_utils +from pm4py.algo.discovery.dcr_discover.variants import dcr_discover +from pm4py.algo.discovery.dcr_discover.extenstions import roles, pending, time_constraints, nesting +from enum import Enum, auto +import pandas as pd +from typing import Union, Any, Optional, Dict, Tuple, Set + + +class ExtensionVariants(Enum): + ROLES = roles + PENDING = pending + TIMED = time_constraints + NESTING = nesting + + +class Variants(Enum): + DCR_DISCOVER = dcr_discover + + +DCR_DISCOVER = Variants.DCR_DISCOVER +ROLES = ExtensionVariants.ROLES +DCR_PENDING = ExtensionVariants.PENDING +DCR_TIMED = ExtensionVariants.TIMED +DCR_NESTING = ExtensionVariants.NESTING +VERSIONS = {DCR_DISCOVER} + + +def apply(log: Union[EventLog, pd.DataFrame], variant=DCR_DISCOVER, findAdditionalConditions: bool = True, + post_process: Optional[Set[str]] = None, parameters: Optional[Dict[Any, Any]] = None) -> Tuple[Any, dict]: + """ + discover a DCR graph from a provided event log, implemented the DisCoveR algorithm presented in [1]_. + Allows for mining for additional attribute currently implemented mining of organisational attributes. + + Parameters + --------------- + log: EventLog | pd.DataFrame + event log used for discovery + variant + Variant of the algorithm to use: + - DCR_BASIC + findAdditionalConditions: + Parameter determining if the miner should include an extra step of mining for extra conditions + - [True, False] + + post_process + kind of post process mining to handle further patterns + - DCR_ROLES + + parameters + variant specific parameters + findAdditionalConditions: [True or False] + + Returns + --------------- + DcrGraph | DistributedDcrGraph | HierarchicalDcrGraph | TimeDcrGraph: + DCR graph (as an object) containing eventId, set of activities, mapping of event to activities, + condition relations, response relation, include relations and exclude relations. + possible to return variant of different dcr graph depending on which variant, basic, distributed, etc. + + References + ---------- + .. [1] + C. O. Back et al. "DisCoveR: accurate and efficient discovery of declarative process models", + International Journal on Software Tools for Technology Transfer, 2022, 24:563–587. 'DOI' _. + """ + + input_log = log # deepcopy(log) + graph, la = exec_utils.get_variant(variant).apply(input_log, findAdditionalConditions=findAdditionalConditions, parameters=parameters) + + if post_process is None: + post_process = set() + + if 'roles' in post_process: + graph = exec_utils.get_variant(ROLES).apply(input_log, graph, parameters=parameters) + if 'pending' in post_process: + graph = exec_utils.get_variant(DCR_PENDING).apply(input_log, graph, parameters=parameters) + if 'nesting' in post_process: + graph = exec_utils.get_variant(DCR_NESTING).apply(graph, parameters=parameters) + if 'timed' in post_process: + graph = exec_utils.get_variant(DCR_TIMED).apply(input_log, graph, parameters=parameters) + return graph, la diff --git a/pm4py/algo/discovery/dcr_discover/extenstions/__init__.py b/pm4py/algo/discovery/dcr_discover/extenstions/__init__.py new file mode 100644 index 0000000000..eb8ba97a34 --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/extenstions/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.discovery.dcr_discover.extenstions import roles \ No newline at end of file diff --git a/pm4py/algo/discovery/dcr_discover/extenstions/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/discovery/dcr_discover/extenstions/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..7740c301c5 Binary files /dev/null and b/pm4py/algo/discovery/dcr_discover/extenstions/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/discovery/dcr_discover/extenstions/__pycache__/roles.cpython-311.pyc b/pm4py/algo/discovery/dcr_discover/extenstions/__pycache__/roles.cpython-311.pyc new file mode 100644 index 0000000000..f9dd62fce7 Binary files /dev/null and b/pm4py/algo/discovery/dcr_discover/extenstions/__pycache__/roles.cpython-311.pyc differ diff --git a/pm4py/algo/discovery/dcr_discover/extenstions/nesting.py b/pm4py/algo/discovery/dcr_discover/extenstions/nesting.py new file mode 100644 index 0000000000..2b53ac6537 --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/extenstions/nesting.py @@ -0,0 +1,394 @@ +from copy import deepcopy +from enum import Enum, auto +import pandas as pd +import networkx as nx +from typing import Optional, Any, Union, Dict + +from pm4py.objects.dcr.obj import dcr_template, DcrGraph, TemplateRelations as Relations +from pm4py.objects.dcr.hierarchical.obj import HierarchicalDcrGraph +from pm4py.objects.log.obj import EventLog + + +class NestVariants(Enum): + CHOICE = auto() + NEST = auto() + CHOICE_NEST = auto() + + +def apply(graph, parameters): + """ + this method calls the nesting miner + + Parameters + ---------- + log: EventLog | pandas.Dataframe + Event log to use in the role miner + graph: DCR_Graph + Dcr graph to apply additional attributes to + parameters + Parameters of the algorithm, including: + nest_variant : the nesting algorithm to use from the enum above: CHOICE|NEST|CHOICE_NEST + Returns + ------- + :class:´GroupSubprocessDcrGraph` + return a DCR graph, that contains nested groups + """ + nesting_mine = NestingMining() + return nesting_mine.mine(graph, parameters) + + +class NestingMining: + """ + The NestingMining provides a simple algorithm to mine nestings + + After initialization, user can call mine(log, G, parameters), which will return a DCR Graph with nested groups. + + Reference paper: + Cosma et al. "Improving Simplicity by Discovering Nested Groups in Declarative Models" https://doi.org/10.1007/978-3-031-61057-8_26 + Attributes + ---------- + graph: Dict[str,Any] + A template that will be used collecting organizational data + + Methods + ------- + mine(log, G, parameters) + calls the main mining function, extract nested groups + + Notes + ------ + * + """ + + def mine(self, graph, parameters: Optional[Dict[str, Any]]): + """ + Main nested groups mining algorithm + + Parameters + ---------- + graph: DCRGraph + DCR graph to append additional attributes + parameters: Optional[Dict[str, Any]] + optional parameters used for role mining + Returns + ------- + NestedDCRGraph(G, dcr) + returns a DCR graph with nested groups + """ + nest_variant = NestVariants.CHOICE_NEST + if 'nest_variant' in parameters: + nest_variant = parameters['nest_variant'] + # from the parameters ask which type of nesting do you want + match nest_variant.value: + case NestVariants.CHOICE.value: + return self.apply_choice(graph) + case NestVariants.NEST.value: + return self.apply_nest(graph) + case NestVariants.CHOICE_NEST.value: + return self.apply_nest(self.apply_choice(graph)) + + def apply_choice(self, graph): + choice = Choice() + return choice.apply_choice(graph) + + def apply_nest(self, graph): + existing_nestings = deepcopy(graph.nestedgroups) if len(graph.nestedgroups)>0 else None + nesting = Nesting() + nesting.create_encoding(graph.obj_to_template()) + nesting.nest(graph.events) + nesting.remove_redundant_nestings() + return nesting.get_nested_dcr_graph(graph,existing_nestings) + + +class Choice(object): + + def __init__(self): + self.nesting_template = {"nestedgroups": {}, "nestedgroupsMap": {}, "subprocesses": {}} + + def apply_choice(self, graph): + self.get_mutual_exclusions(graph) + for name, me_events in self.nesting_template['nestedgroups'].items(): + graph.events.add(name) + graph.marking.included.add(name) + for me_event in me_events: + self.nesting_template['nestedgroupsMap'][me_event] = name + for me_prime in me_events: + graph.excludes[me_event].discard(me_prime) + graph.excludes[me_prime].discard(me_event) + graph.excludes[name] = set([name]) + + from pm4py.objects.dcr.obj import Relations as ObjRel + for name, me_events in self.nesting_template['nestedgroups'].items(): + external_events_to_check = graph.events.difference(me_events.union(set(name))) + for r in [ObjRel.C,ObjRel.R,ObjRel.I,ObjRel.E]: + rel = r.value + for e in external_events_to_check: + all_internal_same_relation = True + for internal_event in me_events: + all_internal_same_relation &= internal_event in getattr(graph, rel) and e in getattr(graph, rel)[internal_event] + if all_internal_same_relation: + if name not in getattr(graph, rel): + getattr(graph, rel)[name] = set() + getattr(graph, rel)[name].add(e) + for internal_event in me_events: + getattr(graph, rel)[internal_event].remove(e) + for e in external_events_to_check: + all_internal_same_relation = True + for internal_event in me_events: + all_internal_same_relation &= e in getattr(graph, rel) and internal_event in getattr(graph, rel)[e] + if all_internal_same_relation: + if name not in getattr(graph, rel): + getattr(graph, rel)[e] = set() + getattr(graph, rel)[e].add(name) + getattr(graph, rel)[e] = getattr(graph, rel)[e].difference(me_events) + return HierarchicalDcrGraph({**graph.obj_to_template(), **self.nesting_template}) + + def get_mutual_exclusions(self, dcr, i:Optional[int]=0): + """ + Get nested groups based on cliques. Updates the self.nesting_template dict + Parameters + ---------- + dcr + A core Dcr Graph as mined from the DisCoveR miner + i + An integer seed for the naming of choice groups + Returns + ------- + + """ + + graph = self.get_mutually_excluding_graph(dcr) + cliques = list(frozenset(s) for s in nx.enumerate_all_cliques(graph) if len(s) > 1) + cliques = sorted(cliques, key=len, reverse=True) + used_cliques = {} + for c in cliques: + used_cliques[c] = False + + used_events = set() + for clique in cliques: + if not used_cliques[clique]: + if len(clique.intersection(used_events)) == 0: + # any new mutually exclusive subprocess must be disjoint from all existing ones + i += 1 + self.nesting_template['nestedgroups'][f'Choice{i}'] = set(clique) + used_cliques[clique] = True + used_events = used_events.union(clique) + + def get_mutually_excluding_graph(self, graph): + ind = pd.Index(sorted(graph.events), dtype=str) + rel_matrix = pd.DataFrame(0, columns=ind, index=ind, dtype=int) + for e in graph.events: + for e_prime in graph.events: + if e in graph.excludes and e_prime in graph.excludes[e]: + rel_matrix.at[e, e_prime] = 1 + + self_excluding = set() + for e in graph.events: + if rel_matrix.at[e, e] == 1: + self_excluding.add(e) + mutually_excluding = [] + for e in self_excluding: + for e_prime in self_excluding: + if e != e_prime and rel_matrix.at[e, e_prime] == 1 and rel_matrix.at[e_prime, e] == 1: + if (e, e_prime) not in mutually_excluding and (e_prime, e) not in mutually_excluding: + mutually_excluding.append((e, e_prime)) + + return nx.from_edgelist(mutually_excluding) + +class Nesting(object): + + def __init__(self): + self.nesting_template = {"nestedgroups": {}, "nestedgroupsMap": {}, "subprocesses": {}} + self.nesting_ids = set() + self.nesting_map = {} + self.nest_id = 0 + self.enc = None + self.in_rec_step = 0 + self.out_rec_step = 0 + self.debug = False + + def encode(self, G): + enc = {} + for e in G['events']: + enc[e] = set() + for e in G['events']: + for e_prime in G['events']: + for rel in Relations: + if e in G[rel.value] and e_prime in G[rel.value][e]: + if rel in [Relations.C, Relations.M]: + enc[e].add((e_prime, rel.value, 'in')) + else: + enc[e].add((e_prime, rel.value, 'out')) + if e_prime in G[rel.value] and e in G[rel.value][e_prime]: + if rel in [Relations.C, Relations.M]: + enc[e].add((e_prime, rel.value, 'out')) + else: + enc[e].add((e_prime, rel.value, 'in')) + return enc + + def get_opposite_rel_dict_str(self, relStr, direction, event, nestingId): + relation_dict_str_del = (event, relStr, "out" if direction == "in" else "in") + relation_dict_str_add = (nestingId, relStr, "out" if direction == "in" else "in") + + return relation_dict_str_del, relation_dict_str_add + + def create_encoding(self, dcr_graph): + self.enc = self.encode(dcr_graph) + + def find_largest_nesting(self, events_source, parent_nesting=None): + cands = {} + events = deepcopy(events_source) + for e in events: + for j in events: + arrow_s = frozenset(self.enc[e].intersection(self.enc[j])) + if len(arrow_s) > 0: + if not arrow_s in cands: + cands[arrow_s] = set([]) + cands[arrow_s] = cands[arrow_s].union(set([e, j])) + + best_score = 0 + best = None + for arrow_s in cands.keys(): + cand_score = (len(cands[arrow_s]) - 1) * len(arrow_s) + if cand_score > best_score: + best_score = cand_score + best = arrow_s + + if best and len(cands[best]) > 1 and len(best) >= 1: + if self.debug: + print( + f'[out]:{self.out_rec_step} [in]:{self.in_rec_step} \n' + f' [events] {events} \n' + f'[cands[best]] {cands[best]} \n' # these are the events inside the nesting + f' [best] {best} \n' + f' [enc] {self.enc} \n ' + f' [cands] {cands} \n' + ) + self.nest_id += 1 + nest_event = f'Group{self.nest_id}' + self.nesting_ids.add(nest_event) + self.enc[nest_event] = set(best) + + if parent_nesting: + parent_nesting['events'] = parent_nesting['events'].difference(cands[best]) + parent_nesting['events'].add(nest_event) + self.nesting_map[nest_event] = parent_nesting['id'] + + for e in cands[best]: + self.nesting_map[e] = nest_event + self.enc[e] = self.enc[e].difference(best) + for (e_prime, rel, direction) in best: + op_rel_del, op_rel_add = self.get_opposite_rel_dict_str(rel, direction, e, nest_event) + # TODO: find out why sometimes it tries to remove non-existing encodings + self.enc[e_prime].discard(op_rel_del) # .remove(op_rel_del) + self.enc[e_prime].add(op_rel_add) + + retval = [{'nestingEvents': cands[best], 'sharedRels': best}] + found = True + while found: + temp_retval = self.find_largest_nesting(events_source=cands[best], parent_nesting={'id': f'Group{self.nest_id}', 'events': cands[best]}) + if temp_retval and len(temp_retval) > 0: + retval.extend(temp_retval) + for tmp in temp_retval: + events = events.difference(tmp['nestingEvents']) + else: + found = False + self.in_rec_step += 1 + return retval + + def nest(self, events_source): + nestings_arr = [{'nestingEvents': set(), 'sharedRels': set()}] + events = deepcopy(events_source) + + while True: + temp_retval = self.find_largest_nesting(events) + if temp_retval and len(temp_retval) > 0: + nestings_arr.extend(temp_retval) + for tmp in temp_retval: + events = events.difference(tmp['nestingEvents']) + else: + break + self.out_rec_step += 1 + + return self.nesting_map, self.nesting_ids + + def remove_redundant_nestings(self): + nestings = {} + for n in self.nesting_ids: + nestings[n] = set() + for k, v in self.nesting_map.items(): + nestings[v].add(k) + + # Removing redundant nestings + nests_to_remove = set([]) + for key in nestings: + val = nestings[key] + if len(val) == 1: + nests_to_remove.add(list(val)[0]) + + for nest_to_remove in nests_to_remove: + parent = self.nesting_map[nest_to_remove] + for k, v in list(self.nesting_map.items()): + if v == nest_to_remove: + self.nesting_map[k] = parent + print("Deleting: ", nest_to_remove) + del self.nesting_map[nest_to_remove] + self.nesting_ids.remove(nest_to_remove) + + for e, v in deepcopy(list(self.enc.items())): + for r in v: #I get a set changed error here + (e_prime, rel, direction) = r + if e_prime == nest_to_remove: + self.enc[e].remove(r) + self.enc[e].add((parent, rel, direction)) + if e == nest_to_remove: + self.enc[parent] = self.enc[parent].union(self.enc[e]) + del self.enc[e] + + def should_add(self, rel, direction): + return direction == 'in' if rel in [Relations.C.value, Relations.M.value] else direction == 'out' + + def get_nested_dcr_graph(self, graph, existing_nestings=None): + res_dcr = graph.obj_to_template() + events = set(self.enc.keys()) + res_dcr['events'] = events + res_dcr['marking']['included'] = events + + for n in self.nesting_ids: + res_dcr['nestedgroups'][n] = set() + for k, v in self.nesting_map.items(): + res_dcr['nestedgroups'][v].add(k) + + for e, v in self.enc.items(): + for e_prime, rel, direction in v: + if self.should_add(rel, direction): + if e not in res_dcr[rel]: + res_dcr[rel][e] = set() + res_dcr[rel][e].add(e_prime) + + if existing_nestings: + for me, me_events in existing_nestings.items(): + if me not in res_dcr['nestedgroups']: + res_dcr['nestedgroups'][me] = set() + for me_event in me_events: + if me_event in self.nesting_map: + highest_nesting = self.nesting_map[me_event] + while True: + if highest_nesting in self.nesting_map: + highest_nesting = self.nesting_map[highest_nesting] + else: + break + if highest_nesting not in res_dcr['nestedgroups'][me]: + res_dcr['nestedgroups'][me].add(highest_nesting) + else: + res_dcr['nestedgroups'][me].add(me_event) + self.nesting_map[me_event] = me + if self.debug: + print(self.nesting_map[me]) + print(self.nesting_map) + print(res_dcr['nestedgroups']) + + res_dcr['nestedgroupsMap'] = deepcopy(self.nesting_map) + + return HierarchicalDcrGraph(res_dcr) + # return res_dcr diff --git a/pm4py/algo/discovery/dcr_discover/extenstions/pending.py b/pm4py/algo/discovery/dcr_discover/extenstions/pending.py new file mode 100644 index 0000000000..4f8542f37c --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/extenstions/pending.py @@ -0,0 +1,59 @@ +from typing import Union + +import pm4py +import pandas as pd + +from copy import deepcopy + +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.objects.dcr.semantics import DcrSemantics +from pm4py.objects.log.obj import EventLog + + +def apply(log: Union[pd.DataFrame,EventLog], graph: DcrGraph, parameters): + """ + An extension to the DCR Graphs discovery algorithm for the discovery of initially pending events + Parameters + ---------- + log + Event log / Pandas dataframe + graph + DCR Graph + ignore_lifecycle + If True it does not take into account the 'lifecycle:transition' attribute of the log event else False + + Returns + ---------- + An updated DCR Graph with the Pending Marking updated to contain initially pending events + """ + ignore_lifecycle = True + if 'ignore_lifecycle' in parameters: + ignore_lifecycle = parameters["ignore_lifecycle"] + + if isinstance(log, pd.DataFrame): + log = pm4py.convert_to_event_log(log) + + at_least_once_all_traces = set(graph.events) + end_excluded_all_traces = set(graph.events) + + for trace in log: + executed_events = set() + im = deepcopy(graph.marking) + temp_graph = deepcopy(graph) + complete = True + semantics_obj = DcrSemantics() + for event in trace: + semantics_obj.execute(temp_graph, event['concept:name']) + if event['concept:name'] in temp_graph.marking.executed: + executed_events.add(event['concept:name']) + if not ignore_lifecycle: + complete = complete and event['lifecycle:transition'] == 'complete' + if complete: + fm = temp_graph.marking + excluded_events = im.included.difference(fm.included) + at_least_once_all_traces = at_least_once_all_traces.intersection(executed_events) + end_excluded_all_traces = end_excluded_all_traces.intersection(excluded_events) + + initially_pending = at_least_once_all_traces.union(end_excluded_all_traces) + graph.marking.pending = graph.marking.pending.union(initially_pending) + return graph diff --git a/pm4py/algo/discovery/dcr_discover/extenstions/roles.py b/pm4py/algo/discovery/dcr_discover/extenstions/roles.py new file mode 100644 index 0000000000..0d158c9e60 --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/extenstions/roles.py @@ -0,0 +1,134 @@ +import pandas as pd +from typing import Optional, Any, Union, Dict +import pm4py +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.util import exec_utils, constants, xes_constants +from pm4py.objects.dcr.distributed.obj import DistributedDcrGraph +from pm4py.objects.log.obj import EventLog + + +def apply(log, graph, parameters) -> DistributedDcrGraph: + """ + this method calls the role miner + + Parameters + ---------- + log: EventLog | pandas.Dataframe + Event log to use in the role miner + graph: DCRGraph + Dcr graph to apply additional attributes to + parameters + Parameters of the algorithm, including: + activity_key: activity identifier, used for assigning the events to + resource_key: resource identifier, used to determine the principals and role assignmed if specified + group_key: group identifier, used to determine the access right, i.e. the Role assignments for event in log + + Returns + ------- + :class:´RoleDCR_Graph` + return a DCR graph, that contains organizational attributes + """ + role_mine = RoleMining() + return role_mine.mine(log, graph, parameters) + + +class RoleMining: + """ + The RoleMining provides a simple algorithm to mine for organizational data of an event log for DCR graphs + + After initialization, user can call mine(log, G, parameters), which will return a DCR Graph with distributed. + + Attributes + ---------- + graph: Dict[str,Any] + A template that will be used collecting organizational data + + Methods + ------- + mine(log, G, parameters) + calls the main mining function, extract distributed and principals from the log and perform rol + + Notes + ------ + * NaN values are disregarded, if event in log has event with both, it will not store NaN as a role assignment + * Currently no useful implementation for analysis of principalsAssignments, but is included for future improvement + """ + def __init__(self): + self.role_template = {"roles": set(), "principals": set(), "roleAssignments": {}, "principalsAssignments": {}} + + def __role_assignment_role_to_activity(self, log: pd.DataFrame, activity_key: str, + group_key: str, resource_key: str) -> None: + """ + If log has defined distributed, mine for role assignment using a role identifier, + such as a Group key or possible optional parameter. + + Parameters + ---------- + log + event log + activity_key + attribute to be used as activity identifier + group_key + attribute to be used as role identifier + resource_key + attribute to be used as resource identifier + """ + # turn this into a dict that can iterated over + act_roles_couple = dict(log.groupby([group_key, activity_key]).size()) + for couple in act_roles_couple: + self.role_template['roleAssignments'][couple[0]] = self.role_template['roleAssignments'][couple[0]].union({couple[1]}) + act_roles_couple = dict(log.groupby([group_key, resource_key]).size()) + for couple in act_roles_couple: + self.role_template['principalsAssignments'][couple[0]] = self.role_template['principalsAssignments'][couple[0]].union({couple[1]}) + + + def mine(self, log: Union[pd.DataFrame, EventLog], graph: DcrGraph, parameters: Optional[Dict[str, Any]]): + """ + Main role mine algorithm, will mine for principals and distributed in a DCR graphs, and associated role assignment. + determine principals, distributed and roleAssignment through unique occurrences in log. + + Parameters + ---------- + log: pandas.DataFrame | EventLog + Event log used for mining + graph: DCRGraph + DCR graph to append additional attributes + parameters: Optional[Dict[str, Any]] + optional parameters used for role mining + Returns + ------- + RoleDCR_Graph(G, dcr) + returns a DCR graph with organizational attributes, store in a variant of DCR + :class:`pm4py.objects.dcr.distributed.obj.RoleDCR_Graph` + """ + + activity_key = exec_utils.get_param_value(constants.PARAMETER_CONSTANT_ACTIVITY_KEY, parameters, + xes_constants.DEFAULT_NAME_KEY) + resource_key = exec_utils.get_param_value(constants.PARAMETER_CONSTANT_RESOURCE_KEY, parameters, + xes_constants.DEFAULT_RESOURCE_KEY) + group_key = exec_utils.get_param_value(constants.PARAMETER_CONSTANT_GROUP_KEY, parameters, + xes_constants.DEFAULT_GROUP_KEY) + + # perform mining on event logs + if not isinstance(log, pd.DataFrame): + log = pm4py.convert_to_dataframe(log) + + keys = set(log.keys()) + if (resource_key not in keys) and (group_key not in keys): + raise ValueError('input log does not contain attribute identifiers for resources or roles') + + # load resources if provided + principals = set(log[resource_key].values) + principals = set(filter(lambda x: x == x, principals)) + self.role_template['principals'] = principals + + # if no resources are provided, map distributed to activities + roles = set(log[group_key].values) + roles = set(filter(lambda x: x == x, roles)) + self.role_template['roles'] = roles + for i in self.role_template['roles']: + self.role_template['roleAssignments'][i] = set() + self.role_template['principalsAssignments'][i] = set() + + self.__role_assignment_role_to_activity(log, activity_key, group_key, resource_key) + return DistributedDcrGraph({**graph.obj_to_template(), **self.role_template}) diff --git a/pm4py/algo/discovery/dcr_discover/extenstions/time_constraints.py b/pm4py/algo/discovery/dcr_discover/extenstions/time_constraints.py new file mode 100644 index 0000000000..51f3ef5360 --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/extenstions/time_constraints.py @@ -0,0 +1,154 @@ +from copy import deepcopy + +import pandas as pd +from typing import Optional, Any, Union, Dict +import pm4py +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.util import exec_utils, constants, xes_constants +from pm4py.objects.dcr.timed.obj import TimedDcrGraph +from pm4py.objects.log.obj import EventLog + + +def apply(log, graph: DcrGraph, parameters) -> TimedDcrGraph: + """ + this method calls the time miner + + Parameters + ---------- + log: EventLog | pandas.Dataframe + Event log to use in the time miner + graph: DCR_Graph + Dcr graph to apply additional attributes to + parameters + Parameters of the algorithm, including: + + + Returns + ------- + :class:´TimedDcrGraph` + return a DCR graph + """ + time_mine = TimeMining() + return time_mine.mine(log, graph, parameters) + + +class TimeMining: + """ + The TimeMining provides a simple algorithm to mine timing data of an event log for DCR graphs + + After initialization, user can call mine(log, G, parameters), which will return a DCR Graph with time. + + Attributes + ---------- + graph: Dict[str,Any] + + Methods + ------- + mine(log, G, parameters) + + Notes + ------ + * + """ + def __init__(self): + self.timing_dict = {"conditionsForDelays": {}, "responseToDeadlines": {}} + + + def get_log_with_pair(self, event_log, e1, e2): + ''' + when selecting the case ids (cids) here there is a difference when taking + strictly less than < and strictly less than or equal <= + Less than or equal <= allows for instant executions (so a time of 0 between events e1 and e2) + ''' + first_e1 = event_log[event_log['concept:name'] == e1].groupby('case:concept:name')[ + ['case:concept:name', 'time:timestamp']].first().reset_index(drop=True) + subset_is_in = first_e1.merge(event_log, on='case:concept:name', how='inner', suffixes=('_e1', '')) + cids = subset_is_in[ + ((subset_is_in['time:timestamp_e1'] <= subset_is_in['time:timestamp']) & (subset_is_in['concept:name'] == e2))][ + 'case:concept:name'].unique() + return event_log[event_log['case:concept:name'].isin(cids)].copy(deep=True) + + + def get_delta_between_events(self, filtered_df, event_pair, rule=None): + e1 = event_pair[0] + e2 = event_pair[1] + filtered_df = filtered_df[['case:concept:name', 'concept:name', 'time:timestamp']] + filtered_df = filtered_df[filtered_df['concept:name'].isin(event_pair)] + filtered_df['time:timestamp'] = pd.to_datetime(filtered_df['time:timestamp'], utc=True) + deltas = [] + # for idx, g in filtered_df[filtered_df['concept:name'].isin([e1, e2])].groupby('case:concept:name'): + for idx, g in filtered_df.groupby('case:concept:name'): + g = g.sort_values(by='time:timestamp').reset_index(drop=True) + g['time:timestamp:to'] = g['time:timestamp'].shift(-1) + g['concept:name:to'] = g['concept:name'].shift(-1) + temp_df = deepcopy(g) + res = [] + if rule == 'RESPONSE': + g_e1 = deepcopy(g[g['concept:name'] == e1]) + if len(g_e1) >= 1: + g_e1 = g_e1.reset_index(drop=False) + g_e1['index_below'] = g_e1['index'].shift(-1) + g_e1 = g_e1[((g_e1['index_below'] - g_e1['index']) == 1)] + g_e1['delta'] = g_e1['time:timestamp:to'] - g_e1['time:timestamp'] + res.extend(g_e1['delta']) + temp_df = temp_df[ + (temp_df['concept:name'] == e1) & (temp_df['concept:name:to'] == e2)] + temp_df['delta'] = temp_df['time:timestamp:to'] - temp_df['time:timestamp'] + res.extend(temp_df['delta']) + elif rule == 'CONDITION': + temp_df = temp_df[ + (temp_df['concept:name'] == e1) & (temp_df['concept:name:to'] == e2)] + temp_df['delta'] = temp_df['time:timestamp:to'] - temp_df['time:timestamp'] + res.extend(temp_df['delta']) + else: + temp_df = temp_df[ + (temp_df['concept:name'] == e1) & (temp_df['concept:name:to'] == e2)] + temp_df['delta'] = temp_df['time:timestamp:to'] - temp_df['time:timestamp'] + res.extend(temp_df['delta']) + deltas.extend(res) + return deltas + + + def mine(self, log: Union[pd.DataFrame, EventLog], graph, parameters: Optional[Dict[str, Any]]): + activity_key = exec_utils.get_param_value(constants.PARAMETER_CONSTANT_ACTIVITY_KEY, parameters, + xes_constants.DEFAULT_NAME_KEY) + # perform mining on event logs + if not isinstance(log, pd.DataFrame): + log = pm4py.convert_to_dataframe(log) + activities = log[activity_key].unique() + + timing_input_dict = {'CONDITION': set(), 'RESPONSE': set()} + for e1 in graph.conditions.keys(): + for e2 in graph.conditions[e1]: + timing_input_dict['CONDITION'].add((e2, e1)) + + for e1 in graph.responses.keys(): + for e2 in graph.responses[e1]: + timing_input_dict['RESPONSE'].add((e1, e2)) + + timings = {} + for rule, event_pairs in timing_input_dict.items(): + for event_pair in event_pairs: + if event_pair[0] in activities and event_pair[1] in activities: + filtered_df = self.get_log_with_pair(log, event_pair[0], event_pair[1]) + data = self.get_delta_between_events(filtered_df, event_pair, rule) + timings[(rule, event_pair[0], event_pair[1])] = data + + # these are a dict with events as keys and tuples as values + for timing, value in timings.items(): + if timing[0] == 'CONDITION': + e1 = timing[2] + e2 = timing[1] + if e1 not in self.timing_dict['conditionsForDelays']: + self.timing_dict['conditionsForDelays'][e1] = {} + # to have perfect fitness we extract the minimum delay for conditions + self.timing_dict['conditionsForDelays'][e1][e2] = min(value) + elif timing[0] == 'RESPONSE': + e1 = timing[1] + e2 = timing[2] + if e1 not in self.timing_dict['responseToDeadlines']: + self.timing_dict['responseToDeadlines'][e1] = {} + # to have perfect fitness we extract the maximum deadline for responses + self.timing_dict['responseToDeadlines'][e1][e2] = max(value) + + return TimedDcrGraph({**graph.obj_to_template(), **self.timing_dict}) diff --git a/pm4py/algo/discovery/dcr_discover/variants/__init__.py b/pm4py/algo/discovery/dcr_discover/variants/__init__.py new file mode 100644 index 0000000000..792c260f3a --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/variants/__init__.py @@ -0,0 +1 @@ +from pm4py.algo.discovery.dcr_discover.variants import dcr_discover \ No newline at end of file diff --git a/pm4py/algo/discovery/dcr_discover/variants/__pycache__/__init__.cpython-311.pyc b/pm4py/algo/discovery/dcr_discover/variants/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..368079263d Binary files /dev/null and b/pm4py/algo/discovery/dcr_discover/variants/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/algo/discovery/dcr_discover/variants/__pycache__/dcr_discover.cpython-311.pyc b/pm4py/algo/discovery/dcr_discover/variants/__pycache__/dcr_discover.cpython-311.pyc new file mode 100644 index 0000000000..41d0672308 Binary files /dev/null and b/pm4py/algo/discovery/dcr_discover/variants/__pycache__/dcr_discover.cpython-311.pyc differ diff --git a/pm4py/algo/discovery/dcr_discover/variants/dcr_discover.py b/pm4py/algo/discovery/dcr_discover/variants/dcr_discover.py new file mode 100644 index 0000000000..b081b8958c --- /dev/null +++ b/pm4py/algo/discovery/dcr_discover/variants/dcr_discover.py @@ -0,0 +1,387 @@ +from copy import deepcopy + +import numpy as np +import pandas as pd + +import pm4py.utils +from pm4py.stats import get_event_attribute_values +from pm4py.objects.dcr.obj import dcr_template +from enum import Enum +from typing import Tuple, Dict, Set, Any, List, Union +from pm4py.util import exec_utils, constants, xes_constants +from pm4py.objects.log.obj import EventLog +from pm4py.objects.dcr.obj import DcrGraph + + +# these parameters are used in case of attribute has a custom name, in which case it can be specified on call +class Parameters(Enum): + """ + An enumeration class to hold parameter keys used for specifying the activity and case identifier keys + within a log during the DCR discovery process. + + Attributes + ---------- + ACTIVITY_KEY : str + The key used to identify the activity attribute in the event log. + CASE_ID_KEY : str + The key used to identify the case identifier attribute in the event log. + """ + ACTIVITY_KEY = constants.PARAMETER_CONSTANT_ACTIVITY_KEY + CASE_ID_KEY = constants.PARAMETER_CONSTANT_CASEID_KEY + + +def apply(log, findAdditionalConditions=True, parameters = None) -> Tuple[DcrGraph,Dict[str, Any]]: + """ + Discovers a DCR graph model from an event log, using algorithm described in [1]_. + + Parameters + ---------- + log + event log (pandas dataframe) + findAdditionalConditions + bool value to identify if additional conditions should be mined + parameters + Possible parameters of the algorithm, including: + - Parameters.ACTIVITY_KEY + - Parameters.Case_ID_KEY + Returns + ------- + tuple(dict,dict) + returns tuple of dictionaries containing the dcr_graph and the abstracted log used to mine the graph + + References + ---------- + .. [1] + C. O. Back et al., "DisCoveR: accurate and efficient discovery of declarative process models", + International Journal on Software Tools for Technology Transfer, 2022, 24:563–587. 'DOI' _. + + """ + disc = Discover() + return disc.mine(log, findAdditionalConditions, parameters = parameters) + + +class Discover: + """ + The Discover class is responsible for mining DCR graphs from event logs. + + Attributes + ---------- + graph : dict + A dictionary representing the DCR graph, initialized from a template. + logAbstraction : dict + A dictionary containing abstracted information from the event log to be mined. + + Methods + ---------- + mine(log: Union[EventLog, pd.DataFrame], findAdditionalConditions: bool = True, parameters: Optional[dict] = None) -> Tuple[DCR_Graph, Dict[str, Any]]: + Mines a DCR graph and the log abstraction from an event log. + + createLogAbstraction(log: Union[EventLog, pd.DataFrame], activity_key: str, case_key: str) -> int: + Creates an abstraction of the event log to facilitate the mining process. + + parseTrace(trace: List[str]) -> int: + Parses a single trace to extract relations between events. + + optimizeRelation(relation: Dict[str, Set[str]]) -> Dict[str, Set[str]]: + Optimizes a relation by removing redundant relations based on transitive closure. + + mineFromAbstraction(findAdditionalConditions: bool = True) -> int: + Mines DCR constraints from the log abstraction. + """ + def __init__(self): + self.graph = deepcopy(dcr_template) + self.logAbstraction = { + 'events': set(), + 'traces': [[]], + 'atMostOnce': set(), + 'chainPrecedenceFor': {}, + 'precedenceFor': {}, + 'predecessor': {}, + 'responseTo': {}, + 'successor': {} + } + + def mine(self, log: Union[EventLog, pd.DataFrame], findAdditionalConditions=True, parameters=None) -> Tuple[DcrGraph,Dict[str, Any]]: + """ + Method used for calling the underlying mining algorithm used for discovery of DCR Graphs + + Parameters + ---------- + log + an event log as EventLog or pandas.DataFrame + findAdditionalConditions + Condition for mining additional condition: True (default) or False + + parameters + activity_key: optional parameter, used to identify the activities in the log + case_id_key: optional parameter, used to identify the cases executed in the log + + Returns + ------- + Tuple[DcrGraph,Dict[str, Any]] + returns a tuple containing: + - The DCR Graph + - The log abstraction used for mining + """ + activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY) + case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, constants.CASE_CONCEPT_NAME) + self.createLogAbstraction(log, activity_key, case_id_key) + self.mineFromAbstraction(findAdditionalConditions=findAdditionalConditions) + return DcrGraph(self.graph), self.logAbstraction + + def createLogAbstraction(self, log: [EventLog,pd.DataFrame], activity_key: str, case_key: str) -> int: + """ + Performs the mining of abstraction log, will map event log onto a selection of DECLARE templates. + + Parameters + ---------- + log : EventLog | pd.DataFrame + The event log to be abstracted. + activity_key : str + The attribute key used to identify the activities recorded in the log. + case_key : str + The attribute key used to identify the cases recorded in the log. + + Returns + ------- + int + Returns 0 for success, and any other value for failure. + """ + # initiate the activities, in DisCoveR, activities and event id is mapped bijectively + activities = get_event_attribute_values(log, activity_key) + events = set(activities) + + # load events in to log abstraction + self.logAbstraction['events'] = events.copy() + log = pm4py.project_on_event_attribute(log, case_id_key=case_key) + + # flatten the event log, all traces are equally significant + traces = set(tuple(i) for i in log) + traces = [list(i) for i in traces] + + self.logAbstraction['traces'] = traces + self.logAbstraction['atMostOnce'] = events.copy() + for event in events: + self.logAbstraction['chainPrecedenceFor'][event] = events.copy() - set([event]) + self.logAbstraction['precedenceFor'][event] = events.copy() - set([event]) + self.logAbstraction['predecessor'][event] = set() + self.logAbstraction['responseTo'][event] = events.copy() - set([event]) + self.logAbstraction['successor'][event] = set() + for trace in self.logAbstraction['traces']: + self.parseTrace(trace) + + for i in self.logAbstraction['predecessor']: + for j in self.logAbstraction['predecessor'][i]: + self.logAbstraction['successor'][j].add(i) + return 0 + + def parseTrace(self, trace: List[str]) -> int: + """ + Parses a trace to mine DEClARE constraints. + + Parameters + ---------- + trace : List[str] + A list representing a trace, where each element is an event, and the order of events is maintained. + + Returns + ------- + int + Returns 0 on success, and any other value on failure. + + Notes + ----- + This method performs the following key steps: + - Identifies and updates predecessor relationships for each event in the trace. + - Updates 'atMostOnce', 'precedenceFor', and 'chainPrecedenceFor' sets in the log abstraction based on the trace events. + - Computes and updates 'responseTo' sets in the log abstraction based on the events seen before and after each event in the trace. + """ + localAtLeastOnce = set() + localSeenOnlyBefore = {} + lastEvent = '' + for event in trace: + # All events seen before this one must be predecessors + self.logAbstraction['predecessor'][event] = self.logAbstraction['predecessor'].get(event).union( + localAtLeastOnce) + # If event seen before in trace, remove from atMostOnce + if event in localAtLeastOnce: + self.logAbstraction['atMostOnce'].discard(event) + localAtLeastOnce.add(event) + # Precedence for (event): All events that occurred before (event) are kept in the precedenceFor set + self.logAbstraction['precedenceFor'][event] = self.logAbstraction['precedenceFor'][event].intersection( + localAtLeastOnce) + # Chain-Precedence for (event): Some event must occur immediately before (event) in all traces + if lastEvent != '': # TODO: objects vs strings in sets + # If first time this clause is encountered - leaves lastEvent in chain-precedence set. + # The intersect is empty if this clause is encountered again with another lastEvent. + self.logAbstraction['chainPrecedenceFor'][event] = self.logAbstraction['chainPrecedenceFor'][ + event].intersection(set([lastEvent])) + else: + # First event in a trace, and chainPrecedence is therefore not possible + self.logAbstraction['chainPrecedenceFor'][event] = set() + # To later compute responses we note which events were seen before (event) and not after + if len(self.logAbstraction['responseTo'][event]) > 0: + # Save all events seen before (event) + localSeenOnlyBefore[event] = localAtLeastOnce.copy() + + # Clear (event) from all localSeenOnlyBefore, since (event) has now occurred after + for key in localSeenOnlyBefore: + localSeenOnlyBefore[key].discard(event) + lastEvent = event + for event in localSeenOnlyBefore: + # Compute set of events in trace that happened after (event) + seenOnlyAfter = localAtLeastOnce.difference(localSeenOnlyBefore[event]) + # Delete self-relation + seenOnlyAfter.discard(event) + # Set of events that always happens after (event) + self.logAbstraction['responseTo'][event] = self.logAbstraction['responseTo'][event].intersection( + seenOnlyAfter) + return 0 + + def optimizeRelation(self, relation: Dict[str, Set[str]]) -> Dict[str, Set[str]]: + """ + Optimizes a given relation by removing redundant connections based on transitive closure. + + For instance, if there are relations A -> B, B -> C, then an existing relation A -> C can be removed + as it is implied by the transitive nature of the other relations. + + Parameters + ---------- + relation : Dict[str, Set[str]] + A dictionary representing a relation, where keys are starting points and values are sets of endpoints. + + Returns + ------- + Dict[str, Set[str]] + An optimized version of the input relations, with redundant connections removed. + """ + # Sorted dict to avoid possibly non-deterministic behavior due to unordered nature of dict + relation = dict(sorted(relation.items(), key=lambda conditions: len(conditions[1]),reverse=True)) + for eventA in relation: + for eventB in relation[eventA]: + relation[eventA] = relation[eventA].difference(relation[eventB]) + return relation + + def mineFromAbstraction(self, findAdditionalConditions: bool = True) -> int: + """ + Mines DCR constraints based on the DECLARE templates stored in the log abstraction. + + This method initializes a graph and mines conditions, responses, self-exclusions, and additional conditions + (if specified) from the user. It also optimizes the relations by removing redundant relations based + on transitive closure. + + Parameters + ---------- + findAdditionalConditions : bool, optional + Specifies whether to mine additional conditions. Default is True. + + Returns + ------- + int + Returns 0 if successful, anything else for failure. + """ + # Initialize graph + # Note that events become an alias, but this is irrelevant since events are never altered + self.graph['events'] = self.logAbstraction['events'].copy() + + #insert labels and label mapping, used for bijective label mapping + self.graph['labels'] = deepcopy(self.graph['events']) + + # All events are initially included + self.graph['marking']['included'] = self.logAbstraction['events'].copy() + + # Initialize all to_petri_net to avoid indexing errors + for event in self.graph['events']: + self.graph['labelMapping'][event] = event #{event} + self.graph['conditionsFor'][event] = set() + self.graph['excludesTo'][event] = set() + self.graph['includesTo'][event] = set() + self.graph['responseTo'][event] = set() + + + # Mine conditions from logAbstraction + self.graph['conditionsFor'] = deepcopy(self.logAbstraction['precedenceFor']) + # remove redundant conditions + self.graph['conditionsFor'] = self.optimizeRelation(self.graph['conditionsFor']) + # Mine responses from logAbstraction + self.graph['responseTo'] = deepcopy(self.logAbstraction['responseTo']) + # Remove redundant responses + self.graph['responseTo'] = self.optimizeRelation(self.graph['responseTo']) + + # Mine self-exclusions + for event in self.logAbstraction['responseTo']: + if event in self.logAbstraction['atMostOnce']: + self.graph['excludesTo'][event].add(event) + + # For each chainprecedence(i,j) we add: include(i,j) exclude(j,j) + for j in self.logAbstraction['chainPrecedenceFor']: + for i in self.logAbstraction['chainPrecedenceFor'][j]: + if j not in self.logAbstraction['atMostOnce']: # new addition to prevent adding unnecessary includes + self.graph['includesTo'][i].add(j) + self.graph['excludesTo'][j].add(j) + + # Additional excludes based on predecessors / successors + for event in self.logAbstraction['events']: + # Union of predecessor and successors sets, i.e. all events occuring in the same trace as event + coExisters = self.logAbstraction['predecessor'][event].union(self.logAbstraction['successor'][event]) + nonCoExisters = self.logAbstraction['events'].difference(coExisters) + nonCoExisters.discard(event) + # Note that if events i & j do not co-exist, they should exclude each other. + # Here we only add i -->% j, but on the iteration for j, j -->% i will be added. + self.graph['excludesTo'][event] = self.graph['excludesTo'][event].union(nonCoExisters) + + # if s precedes (event) but never succeeds (event) add (event) -->% s if s -->% s does not exist + precedesButNeverSucceeds = self.logAbstraction['predecessor'][event].difference( + self.logAbstraction['successor'][event]) + for s in precedesButNeverSucceeds: + if not s in self.graph['excludesTo'][s]: + self.graph['excludesTo'][event].add(s) + + # Removing redundant excludes. + # If r always precedes s, and r -->% t, then s -->% t is (mostly) redundant + for s in self.logAbstraction['precedenceFor']: + for r in self.logAbstraction['precedenceFor'][s]: + for t in self.graph['excludesTo'][r]: + self.graph['excludesTo'][s].discard(t) + + if findAdditionalConditions: + """ + Mining additional conditions: + Every event, x, that occurs before some event, y, is a possible candidate for a condition x -->* y + This is due to the fact, that in the traces where x does not occur before y, x might be excluded + """ + possibleConditions = deepcopy(self.logAbstraction['predecessor']) + # Replay entire log, filtering out any invalid conditions + for trace in self.logAbstraction['traces']: + localSeenBefore = set() + included = self.logAbstraction['events'].copy() + for event in trace: + # Compute conditions that still allow event to be executed + excluded = self.logAbstraction['events'].difference(included) + validConditions = localSeenBefore.union(excluded) + # Only keep valid conditions + possibleConditions[event] = possibleConditions[event].intersection(validConditions) + # Execute excludes starting from (event) + included = included.difference(self.graph['excludesTo'][event]) + # Execute includes starting from (event) + included = included.union(self.graph['includesTo'][event]) + localSeenBefore.add(event) + + # Now the only possible Condtitions that remain are valid for all traces + # These are therefore added to the graph + for key in self.graph['conditionsFor']: + self.graph['conditionsFor'][key] = self.graph['conditionsFor'][key].union(possibleConditions[key]) + + # Removing redundant conditions + self.graph['conditionsFor'] = self.optimizeRelation(self.graph['conditionsFor']) + self.clean_empty_sets() + return 0 + + def clean_empty_sets(self): + for k, v in deepcopy(self.graph).items(): + if k in ['conditionsFor', 'responseTo', 'excludesTo', 'includesTo']: + v_new = {} + for k2, v2 in v.items(): + if v2: + v_new[k2] = set([v3 for v3 in v2 if v3 is not set()]) + self.graph[k] = v_new \ No newline at end of file diff --git a/pm4py/conformance.py b/pm4py/conformance.py index d438e2cff8..a362c54041 100644 --- a/pm4py/conformance.py +++ b/pm4py/conformance.py @@ -24,6 +24,7 @@ from pm4py.objects.petri_net.obj import PetriNet, Marking from pm4py.convert import convert_to_event_log from pm4py.objects.process_tree.obj import ProcessTree +from pm4py.objects.dcr.obj import DcrGraph from pm4py.util import xes_constants, constants from pm4py.utils import get_properties, __event_log_deprecation_warning from pm4py.util.pandas_utils import check_is_pandas_dataframe, check_pandas_dataframe_columns @@ -827,3 +828,118 @@ def conformance_log_skeleton(log: Union[EventLog, pd.DataFrame], log_skeleton: D return log_skeleton_conformance.get_diagnostics_dataframe(log, result, parameters=properties) return result + + +def conformance_dcr(log: Union[EventLog, pd.DataFrame], dcr_graph: DcrGraph, activity_key: str = "concept:name", + timestamp_key: str = "time:timestamp", case_id_key: str = "case:concept:name", + group_key: str = "org:group", resource_key: str = "org:resource", + return_diagnostics_dataframe: bool = constants.DEFAULT_RETURN_DIAGNOSTICS_DATAFRAME) -> pd.DataFrame | \ + List[Tuple[ + str, + Dict[ + str, Any]]]: + """ + Applies rule based conformance checking against a DCR model. + reference: + C. Josep et al., "Conformance Checking Software", Springer International Publishing, 65-74, 2018., https://doi.org/10.1007/978-3-319-99414-7. + + :param log: event log + :param dcr_graph: DCR graph + :param activity_key: attribute to be used for the activity + :param timestamp_key: attribute to be used for the timestamp + :param case_id_key: attribute to be used as case identifier + :param group_key: attribute to be used as role identifier + :param resource_key: attribute to be used as resource identifier + :param return_diagnostics_dataframe: if possible, returns a dataframe with the diagnostics (instead of the usual output) + :rtype: `DataFrame | List[Tuple[str,Dict[str, Any]]]` + .. code-block:: python3 + import pm4py + log = pm4py.read_xes("C:/receipt.xes") + grap, la = pm4py.discover_dcr(log) + conf_res = pm4py.conformance_dcr(log, dcr_graph) + """ + if type(log) not in [pd.DataFrame, EventLog]: raise Exception( + "the method can be applied only to a traditional event log!") + __event_log_deprecation_warning(log) + + if check_is_pandas_dataframe(log): + check_pandas_dataframe_columns(log, activity_key=activity_key, timestamp_key=timestamp_key, + case_id_key=case_id_key) + + if return_diagnostics_dataframe: + log = convert_to_event_log(log, case_id_key=case_id_key) + case_id_key = None + + properties = get_properties(log, activity_key=activity_key, timestamp_key=timestamp_key, case_id_key=case_id_key, + group_key=group_key, resource_key=resource_key) + + from pm4py.algo.conformance.dcr import algorithm as dcr_conformance + result = dcr_conformance.apply(log, dcr_graph, parameters=properties) + + if return_diagnostics_dataframe: + return dcr_conformance.get_diagnostics_dataframe(log, result, parameters=properties) + + return result + + +def optimal_alignment_dcr( + log: Union[EventLog, pd.DataFrame, Trace], + dcr_graph: DcrGraph, + activity_key: str = "concept:name", + timestamp_key: str = "time:timestamp", + case_id_key: str = "case:concept:name", + return_diagnostics_dataframe: bool = constants.DEFAULT_RETURN_DIAGNOSTICS_DATAFRAME +) -> pd.DataFrame | Any: + """ + Applies optimal alignment against a DCR model. + Reference paper: + Axel Kjeld Fjelrad Christfort & Tijs Slaats. "Efficient Optimal Alignment Between Dynamic Condition Response Graphs and Traces" https://doi.org/10.1007/978-3-031-41620-0_1 + Parameters + ---------- + log : EventLog | pd.DataFrame | Trace + Event log to be used for alignment. also supports Trace + dcr_graph : DCRGraph + The DCR graph against which the log is aligned. + activity_key : str + The key to identify activity names in the log. + timestamp_key : str + The key to identify timestamps in the log. + case_id_key : str + The key to identify case identifiers in the log. + return_diagnostics_dataframe : bool, default False + If True, returns a diagnostics dataframe instead of the usual list output. + Returns + ------- + Union[pd.DataFrame, List[Tuple[str, Dict[str, Any]]]] + Depending on the value of `return_diagnostics_dataframe`, returns either + a pandas DataFrame with diagnostics or a list of alignment results. + Raises + ------ + Exception + If the log provided is not an instance of EventLog or pandas DataFrame. + Examples + -------- + .. code-block:: python3 + import pm4py + graph, la = pm4py.discover_DCR(log) + conf_res = pm4py.optimal_alignment_dcr(log,graph) + """ + + if type(log) not in [pd.DataFrame, EventLog, Trace]: + raise Exception("The method can be applied only to a traditional event log or Trace!") + + from pm4py.algo.conformance.alignments.dcr import algorithm as dcr_alignment + + if return_diagnostics_dataframe: + if isinstance(log, Trace): + raise Exception("The method can be applied only to a traditional event log!") + log = convert_to_event_log(log, case_id_key=case_id_key) + case_id_key = None + + properties = get_properties(log, activity_key=activity_key, timestamp_key=timestamp_key, case_id_key=case_id_key) + + result = dcr_alignment.apply(log, dcr_graph, parameters=properties) + if return_diagnostics_dataframe: + return dcr_alignment.get_diagnostics_dataframe(log, result, parameters=properties) + + return result diff --git a/pm4py/convert.py b/pm4py/convert.py index 7c510d7f26..b7fa049cf8 100644 --- a/pm4py/convert.py +++ b/pm4py/convert.py @@ -24,6 +24,8 @@ from copy import deepcopy from pm4py.objects.bpmn.obj import BPMN +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.objects.dcr.timed.obj import TimedDcrGraph from pm4py.objects.ocel.obj import OCEL from pm4py.objects.powl.obj import POWL from pm4py.objects.heuristics_net.obj import HeuristicsNet @@ -169,13 +171,13 @@ def convert_to_bpmn(*args: Union[Tuple[PetriNet, Marking, Marking], ProcessTree] raise Exception("unsupported conversion of the provided object to BPMN") -def convert_to_petri_net(*args: Union[BPMN, ProcessTree, HeuristicsNet, POWL, dict]) -> Tuple[PetriNet, Marking, Marking]: +def convert_to_petri_net(obj: Union[BPMN, ProcessTree, HeuristicsNet, DcrGraph, POWL, dict], *args, **kwargs) -> Tuple[PetriNet, Marking, Marking]: """ Converts an input model to an (accepting) Petri net. - The input objects can either be a process tree, BPMN model or a Heuristic net. + The input objects can either be a process tree, BPMN model, a Heuristic net or a Dcr Graph. The output is a triple, containing the Petri net and the initial and final markings. The markings are only returned if they can be reasonable derived from the input model. - :param args: process tree, Heuristics net, BPMN or POWL model + :param args: process tree, Heuristics net, BPMN, POWL model or Dcr Graph :rtype: ``Tuple[PetriNet, Marking, Marking]`` .. code-block:: python3 @@ -186,27 +188,33 @@ def convert_to_petri_net(*args: Union[BPMN, ProcessTree, HeuristicsNet, POWL, di process_tree = pm4py.read_ptml("tests/input_data/running-example.ptml") net, im, fm = pm4py.convert_to_petri_net(process_tree) """ - if isinstance(args[0], PetriNet): + if isinstance(obj, PetriNet): # the object is already a Petri net - return args[0], args[1], args[2] - elif isinstance(args[0], ProcessTree): - if isinstance(args[0], POWL): + return obj, args[0], args[1] + elif isinstance(obj, ProcessTree): + if isinstance(obj, POWL): from pm4py.objects.conversion.powl import converter - return converter.apply(args[0]) + return converter.apply(obj) from pm4py.objects.conversion.process_tree.variants import to_petri_net - return to_petri_net.apply(args[0]) - elif isinstance(args[0], BPMN): + return to_petri_net.apply(obj) + elif isinstance(obj, BPMN): from pm4py.objects.conversion.bpmn.variants import to_petri_net - return to_petri_net.apply(args[0]) - elif isinstance(args[0], HeuristicsNet): + return to_petri_net.apply(obj) + elif isinstance(obj, HeuristicsNet): from pm4py.objects.conversion.heuristics_net.variants import to_petri_net - return to_petri_net.apply(args[0]) - elif isinstance(args[0], dict): + return to_petri_net.apply(obj) + elif isinstance(obj, dict): # DFG from pm4py.objects.conversion.dfg.variants import to_petri_net_activity_defines_place - return to_petri_net_activity_defines_place.apply(args[0], parameters={ - to_petri_net_activity_defines_place.Parameters.START_ACTIVITIES: args[1], - to_petri_net_activity_defines_place.Parameters.END_ACTIVITIES: args[2]}) + return to_petri_net_activity_defines_place.apply(obj, parameters={ + to_petri_net_activity_defines_place.Parameters.START_ACTIVITIES: args[0], + to_petri_net_activity_defines_place.Parameters.END_ACTIVITIES: args[1]}) + elif isinstance(obj, TimedDcrGraph): + from pm4py.objects.conversion.dcr import converter + return converter.apply(obj,variant=converter.Variants.TO_TIMED_ARC_PETRI_NET, parameters=kwargs) + elif isinstance(obj, DcrGraph): + from pm4py.objects.conversion.dcr import converter + return converter.apply(obj,variant=converter.Variants.TO_INHIBITOR_NET , parameters=kwargs) # if no conversion is done, then the format of the arguments is unsupported raise Exception("unsupported conversion of the provided object to Petri net") diff --git a/pm4py/discovery.py b/pm4py/discovery.py index 9b0aec81c9..721f1e10c3 100644 --- a/pm4py/discovery.py +++ b/pm4py/discovery.py @@ -27,6 +27,7 @@ from pm4py.algo.discovery.powl.inductive.variants.dynamic_clustering_frequency.dynamic_clustering_frequency_partial_order_cut import \ ORDER_FREQUENCY_RATIO from pm4py.algo.discovery.powl.inductive.variants.powl_discovery_varaints import POWLDiscoveryVariant +from pm4py.algo.discovery.dcr_discover.algorithm import ExtensionVariants from pm4py.objects.bpmn.obj import BPMN from pm4py.objects.dfg.obj import DFG from pm4py.objects.powl.obj import POWL @@ -865,3 +866,57 @@ def discover_batches(log: Union[EventLog, pd.DataFrame], merge_distance: int = 1 from pm4py.algo.discovery.batches import algorithm as batches_discovery return batches_discovery.apply(log, parameters=properties) + + +def discover_dcr(log: Union[EventLog, pd.DataFrame], post_process: Set[str] = None, activity_key: str = "concept:name", + timestamp_key: str = "time:timestamp", case_id_key: str = "case:concept:name", + resource_key: str = "org:resource", group_key: str = "org:group", + finaAdditionalConditions: bool = True, **kwargs) -> Tuple[Any, Dict[str, Any]]: + """ + Discovers a DCR graph from an event log based on the DisCoveR algorithm. + This method implements the DCR discovery algorithm as described in: + C. O. Back, T. Slaats, T. T. Hildebrandt, M. Marquard, "DisCoveR: accurate and efficient discovery of declarative process models". + Parameters + ---------- + log : Union[EventLog, pd.DataFrame] + The event log or Pandas dataframe containing the event data. + post_process : Optional[str] + Specifies the type of post-processing for the event log, currently supports ROLES, PENDING, TIMED and NESTINGS. + activity_key : str, optional + The attribute to be used for the activity, defaults to "concept:name". + timestamp_key : str, optional + The attribute to be used for the timestamp, defaults to "time:timestamp". + case_id_key : str, optional + The attribute to be used as the case identifier, defaults to "case:concept:name". + group_key : str, optional + The attribute to be used as a role identifier, defaults to "org:group". + resource_key : str, optional + The attribute to be used as a resource identifier, defaults to "org:resource". + findAdditionalConditions : bool, optional + A boolean value specifying whether additional conditions should be found, defaults to True. + Returns + ------- + Tuple[Any, dict] + A tuple containing the discovered DCR graph and a dictionary with additional information. + Examples + -------- + .. code-block:: python3 + import pm4py + graph, la = pm4py.discover_DCR(log) + """ + if type(log) not in [pd.DataFrame, EventLog, EventStream]: + raise Exception( + "the method can be applied only to a traditional event log!") + __event_log_deprecation_warning(log) + if check_is_pandas_dataframe(log): + check_pandas_dataframe_columns(log, activity_key=activity_key, case_id_key=case_id_key, + timestamp_key=timestamp_key) + properties = get_properties( + log, activity_key=activity_key, case_id_key=case_id_key, timestamp_key=timestamp_key, + resource_key=resource_key, group_key=group_key) + properties = {**properties, **kwargs} + + from pm4py.algo.discovery.dcr_discover import algorithm as dcr_alg + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + return dcr_alg.apply(log, dcr_discover, post_process=post_process, + findAdditionalConditions=finaAdditionalConditions, parameters=properties) diff --git a/pm4py/objects/conversion/dcr/__init__.py b/pm4py/objects/conversion/dcr/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/conversion/dcr/converter.py b/pm4py/objects/conversion/dcr/converter.py new file mode 100644 index 0000000000..b7e05e0903 --- /dev/null +++ b/pm4py/objects/conversion/dcr/converter.py @@ -0,0 +1,59 @@ +from copy import deepcopy +from enum import Enum +from typing import Union, Tuple + +from pm4py.objects.dcr.hierarchical.obj import HierarchicalDcrGraph +from pm4py.objects.dcr.extended.obj import ExtendedDcrGraph +from pm4py.objects.dcr.timed.obj import TimedDcrGraph +from pm4py.objects.dcr.utils.utils import nested_groups_and_sps_to_flat_dcr +from pm4py.objects.petri_net.obj import PetriNet, Marking +from pm4py.objects.conversion.dcr.variants import to_inhibitor_net, to_timed_arc_petri_net +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.util import exec_utils + + +class Variants(Enum): + TO_INHIBITOR_NET = to_inhibitor_net + TO_TIMED_ARC_PETRI_NET = to_timed_arc_petri_net + + +DEFAULT_VARIANT = Variants.TO_INHIBITOR_NET + + +def apply(obj: Union[DcrGraph,ExtendedDcrGraph,HierarchicalDcrGraph,TimedDcrGraph], + variant=DEFAULT_VARIANT, parameters=None) -> Tuple[PetriNet, Marking, Marking|None]: + """ + Converts a DCR Graph to a Petri Net + + Reference paper: + Vlad Paul Cosma, Thomas T. Hildebrandt & Tijs Slaats. "Transforming Dynamic Condition Response Graphs to Safe Petri Nets" https://doi.org/10.1007/978-3-031-33620-1_22 + Parameters + ---------- + obj : + A DCR Graph with all 6 relations and optionally timed. + variant: + TO_INHIBITOR_NET|TO_TIMED_ARC_PETRI_NET Create either an untimed inhibitor net or a timed arc petri net respectively. + parameters: + Configurable parameters: + -preoptimize: True if the conversion should be optimized based on the reachable DCR Markings else False + -postoptimize: True if the conversion should be optimized based on the reachable Petri Net Marking else False + -map_unexecutable_events: True if events not executable in the DCR Graph should be mapped, else False + -tapn_path: Path to export the net to. Can end in .pnml or .tapn for timed arc petri nets[1] + -debug: True if debug information should be displayed and a Petri Net for each step in the conversion should be generated else False + Returns + -------- + A Petri Net, an initial marking and None representing that there is no final marking + + + References: + [1] Lasse Jacobsen, Morten Jacobsen, Mikael H. Møller, and Jirı Srba. "Verification of Timed-Arc Petri Nets" https://doi.org/10.1007/978-3-642-18381-2_4 + Note: + The Petri Net final marking is None as declarative DCR Graphs have no unique accepting state based on its markings + """ + if parameters is None: + parameters = {} + if isinstance(obj, HierarchicalDcrGraph): + obj = nested_groups_and_sps_to_flat_dcr(obj) + obj = deepcopy(obj).obj_to_template() + net, im = exec_utils.get_variant(variant).apply(obj, parameters=parameters) + return net, im, None diff --git a/pm4py/objects/conversion/dcr/variants/__init__.py b/pm4py/objects/conversion/dcr/variants/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/conversion/dcr/variants/reachability_analysis.py b/pm4py/objects/conversion/dcr/variants/reachability_analysis.py new file mode 100644 index 0000000000..87966e4d37 --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/reachability_analysis.py @@ -0,0 +1,187 @@ +import re +from copy import copy + +from pm4py.objects import petri_net +from pm4py.objects.transition_system.obj import TransitionSystem +# from pm4py.objects.petri_net.utils import align_utils +from pm4py.objects.transition_system import obj as ts +from pm4py.objects.transition_system import utils +from pm4py.util import exec_utils +from enum import Enum +import time + + +class Parameters(Enum): + MAX_ELAB_TIME = "max_elab_time" + PETRI_SEMANTICS = "petri_semantics" + + +def staterep(name): + """ + Creates a string representation for a state of a transition system. + Necessary because graphviz does not support symbols simulation than alphanimerics and '_'. + TODO: find a better representation. + + Parameters + ---------- + name: the name of a state + + Returns + ------- + Version of the name filtered of non-alphanumerical characters (except '_'). + """ + return re.sub(r'\W+', '', name) + +def get_visible_transitions_eventually_enabled_by_marking(net, marking, semantics): + """ + Get visible transitions eventually enabled by marking (passing possibly through hidden transitions) + Parameters + ---------- + net + Petri net + marking + Current marking + semantics + Petri net semantics + """ + all_enabled_transitions = sorted(list(semantics.enabled_transitions(net, marking)), + key=lambda x: (str(x.name), id(x))) + initial_all_enabled_transitions_marking_dictio = {} + all_enabled_transitions_marking_dictio = {} + for trans in all_enabled_transitions: + all_enabled_transitions_marking_dictio[trans] = marking + initial_all_enabled_transitions_marking_dictio[trans] = marking + visible_transitions = set() + visited_transitions = set() + + i = 0 + while i < len(all_enabled_transitions): + t = all_enabled_transitions[i] + marking_copy = copy(all_enabled_transitions_marking_dictio[t]) + + if repr([t, marking_copy]) not in visited_transitions: + if t.label is not None: + visible_transitions.add(t) + else: + if semantics.is_enabled(t, net, marking_copy): + new_marking = semantics.execute(t, net, marking_copy) + new_enabled_transitions = sorted(list(semantics.enabled_transitions(net, new_marking)), + key=lambda x: (str(x.name), id(x))) + for t2 in new_enabled_transitions: + all_enabled_transitions.append(t2) + all_enabled_transitions_marking_dictio[t2] = new_marking + visited_transitions.add(repr([t, marking_copy])) + i = i + 1 + + return visible_transitions + +def marking_flow_petri(net, im, return_eventually_enabled=False, parameters=None): + """ + Construct the marking flow of a Petri net + + Parameters + ----------------- + net + Petri net + im + Initial marking + return_eventually_enabled + Return the eventually enabled (visible) transitions + """ + if parameters is None: + parameters = {} + + # set a maximum execution time of 1 day (it can be changed by providing the parameter) + max_exec_time = exec_utils.get_param_value(Parameters.MAX_ELAB_TIME, parameters, 86400) + semantics = exec_utils.get_param_value(Parameters.PETRI_SEMANTICS, parameters, petri_net.semantics.ClassicSemantics()) + + start_time = time.time() + + incoming_transitions = {im: set()} + outgoing_transitions = {} + eventually_enabled = {} + + active = [im] + while active: + if (time.time() - start_time) >= max_exec_time: + # interrupt the execution + return incoming_transitions, outgoing_transitions, eventually_enabled + m = active.pop() + enabled_transitions = semantics.enabled_transitions(net, m) + if return_eventually_enabled: + eventually_enabled[m] = get_visible_transitions_eventually_enabled_by_marking(net, m, semantics) + outgoing_transitions[m] = {} + for t in enabled_transitions: + nm = semantics.weak_execute(t, net, m) + outgoing_transitions[m][t] = nm + if nm not in incoming_transitions: + incoming_transitions[nm] = set() + if nm not in active: + active.append(nm) + incoming_transitions[nm].add(t) + + return incoming_transitions, outgoing_transitions, eventually_enabled + + +def construct_reachability_graph_from_flow(incoming_transitions, outgoing_transitions, + use_trans_name=False, parameters=None): + """ + Construct the reachability graph from the marking flow + + Parameters + ---------------- + incoming_transitions + Incoming transitions + outgoing_transitions + Outgoing transitions + use_trans_name + Use the transition name + + Returns + ---------------- + re_gr + Transition system that represents the reachability graph of the input Petri net. + """ + if parameters is None: + parameters = {} + + re_gr = ts.TransitionSystem() + + map_states = {} + for s in incoming_transitions: + if use_trans_name: + map_states[s] = ts.TransitionSystem.State(s) + else: + map_states[s] = ts.TransitionSystem.State(staterep(repr(s))) + re_gr.states.add(map_states[s]) + + for s1 in outgoing_transitions: + for t in outgoing_transitions[s1]: + s2 = outgoing_transitions[s1][t] + if use_trans_name: + utils.add_arc_from_to(t.name, map_states[s1], map_states[s2], re_gr) + else: + utils.add_arc_from_to(repr(t), map_states[s1], map_states[s2], re_gr) + + return re_gr + + +def construct_reachability_graph(net, initial_marking, use_trans_name=False, parameters=None) -> TransitionSystem: + """ + Creates a reachability graph of a certain Petri net. + DO NOT ATTEMPT WITH AN UNBOUNDED PETRI NET, EVER. + + Parameters + ---------- + net: Petri net + initial_marking: initial marking of the Petri net. + + Returns + ------- + re_gr: Transition system that represents the reachability graph of the input Petri net. + """ + incoming_transitions, outgoing_transitions, eventually_enabled = marking_flow_petri(net, initial_marking, + parameters=parameters) + + return construct_reachability_graph_from_flow(incoming_transitions, outgoing_transitions, + use_trans_name=use_trans_name, parameters=parameters) diff --git a/pm4py/objects/conversion/dcr/variants/to_inhibitor_net.py b/pm4py/objects/conversion/dcr/variants/to_inhibitor_net.py new file mode 100644 index 0000000000..2115d442c0 --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_inhibitor_net.py @@ -0,0 +1,328 @@ +import os + +from pm4py.objects.petri_net.obj import * +from pm4py.objects.petri_net.exporter import exporter as pnml_exporter + +from pm4py.objects.conversion.dcr.variants.to_petri_net_submodules import exceptional_cases, single_relations, preoptimizer, utils + + +class Dcr2PetriNet(object): + + def __init__(self, preoptimize=True, postoptimize=True, map_unexecutable_events=False, debug=False, **kwargs) -> None: + """ + Init the conversion object + Parameters + ---------- + preoptimize : If True it will remove unreachable DCR markings based on the DCR behaviour + postoptimize : If True it will remove dead transitions based on the underlying petri net reachability graph + map_unexecutable_events : If True it will map unexecutable events + debug : If True it will print debug information + kwargs + """ + self.in_t_types = ['event', 'init', 'initpend', 'pend'] + self.helper_struct = {} + self.preoptimize = preoptimize + self.postoptimize = postoptimize + self.map_unexecutable_events = map_unexecutable_events + self.preoptimizer = preoptimizer.Preoptimizer() + self.transitions = {} + self.mapping_exceptions = None + self.reachability_timeout = None + self.print_steps = debug + self.debug = debug + + def initialize_helper_struct(self, graph: dict) -> None: + """ + Initializes a helper structure to keep track of DCR Events and their related places and transitions in the Petri Net + Parameters + ---------- + graph + the DcrGraph + Returns + ------- + None + """ + for event in graph['events']: + self.helper_struct[event] = {} + self.helper_struct[event]['places'] = {} + self.helper_struct[event]['places']['included'] = None + self.helper_struct[event]['places']['pending'] = None + self.helper_struct[event]['places']['pending_excluded'] = None + self.helper_struct[event]['places']['executed'] = None + self.helper_struct[event]['transitions'] = [] + self.helper_struct[event]['trans_group_index'] = 0 + self.helper_struct[event]['t_types'] = self.in_t_types + + self.transitions[event] = {} + for event_prime in graph['events']: + self.transitions[event][event_prime] = [] + + def create_event_pattern_places(self, event: str, graph: dict, net: PetriNet, m: Marking) -> (InhibitorNet, Marking): + """ + Creates petri net places and the petri net marking for a single event + """ + default_make_included = True + default_make_pend = True + default_make_pend_ex = True + default_make_exec = True + if self.preoptimize: + default_make_included = event in self.preoptimizer.need_included_place + default_make_pend = event in self.preoptimizer.need_pending_place + default_make_pend_ex = event in self.preoptimizer.need_pending_excluded_place + default_make_exec = event in self.preoptimizer.need_executed_place + + if default_make_included: + inc_place = PetriNet.Place(f'included_{event}') + net.places.add(inc_place) + self.helper_struct[event]['places']['included'] = inc_place + # fill the marking + if event in graph['marking']['included']: + m[inc_place] = 1 + + if default_make_pend: + pend_place = PetriNet.Place(f'pending_{event}') + net.places.add(pend_place) + self.helper_struct[event]['places']['pending'] = pend_place + # fill the marking + if event in graph['marking']['pending'] and event in graph['marking']['included']: + m[pend_place] = 1 + + if default_make_pend_ex: + pend_excl_place = PetriNet.Place(f'pending_excluded_{event}') + net.places.add(pend_excl_place) + self.helper_struct[event]['places']['pending_excluded'] = pend_excl_place + # fill the marking + if event in graph['marking']['pending'] and not event in graph['marking']['included']: + m[pend_excl_place] = 1 + + if default_make_exec: + exec_place = PetriNet.Place(f'executed_{event}') + net.places.add(exec_place) + self.helper_struct[event]['places']['executed'] = exec_place + # fill the marking + if event in graph['marking']['executed']: + m[exec_place] = 1 + if self.preoptimize: + ts = ['event'] + if default_make_exec and not event in graph['marking']['executed'] and not event in self.preoptimizer.no_init_t: + ts.append('init') + if default_make_exec and default_make_pend and not event in self.preoptimizer.no_initpend_t: + ts.append('initpend') + if default_make_pend: + ts.append('pend') + self.helper_struct[event]['t_types'] = ts + + return net, m + + def create_event_pattern(self, event: str, graph: dict, net: PetriNet, m: Marking) -> (InhibitorNet, Marking): + """ + Creates the petri net for a single event + """ + net, m = self.create_event_pattern_places(event, graph, net, m) + net, ts = utils.create_event_pattern_transitions_and_arcs(net, event, self.helper_struct, + self.mapping_exceptions) + self.helper_struct[event]['transitions'].extend(ts) + return net, m + + def post_optimize_petri_net_reachability_graph(self, net, m, graph=None, merge_parallel_places=True) -> InhibitorNet: + """ + Removes dead regions in the petri net based on the reachability graph. + Parameters + ---------- + merge_parallel_places + If True it will remove duplicate places that behave the same in their marking + Returns + ------- + Reduced petri net + """ + from pm4py.objects.petri_net.utils import petri_utils + from pm4py.objects.petri_net.inhibitor_reset import semantics as inhibitor_semantics + from pm4py.objects.conversion.dcr.variants import reachability_analysis + max_elab_time = 2 * 60 * 60 # 2 hours + if self.reachability_timeout: + max_elab_time = self.reachability_timeout + trans_sys = reachability_analysis.construct_reachability_graph(net, m, use_trans_name=True, + parameters={ + 'petri_semantics': inhibitor_semantics.InhibitorResetSemantics(), + 'max_elab_time': max_elab_time + }) + if self.debug: + from pm4py.visualization.transition_system import visualizer as ts_visualizer + gviz = ts_visualizer.apply(trans_sys, parameters={ts_visualizer.Variants.VIEW_BASED.value.Parameters.FORMAT: "png"}) + ts_visualizer.view(gviz) + fired_transitions = set() + + for transition in trans_sys.transitions: + fired_transitions.add(transition.name) + + ts_to_remove = set() + for t in net.transitions: + if t.name not in fired_transitions: + ts_to_remove.add(t) + for t in ts_to_remove: + net = petri_utils.remove_transition(net, t) + + changed_places = set() + for state_list in trans_sys.states: + for state in state_list.name: + changed_places.add(state) + + parallel_places = set() + places_to_rename = {} + ps_to_remove = set(net.places).difference(changed_places) + + if graph and merge_parallel_places: + for event in graph['events']: + for type, event_place in self.helper_struct[event]['places'].items(): + for type_prime, event_place_prime in self.helper_struct[event]['places'].items(): + if event_place and event_place_prime and event_place.name != event_place_prime.name and \ + event_place not in parallel_places: + is_parallel = False + ep_ins = event_place.in_arcs + epp_ins = event_place_prime.in_arcs + ep_outs = event_place.out_arcs + epp_outs = event_place_prime.out_arcs + if len(ep_ins) == len(epp_ins) and len(ep_outs) == len(epp_outs): + ep_sources = set() + epp_sources = set() + for ep_in in ep_ins: + ep_sources.add(ep_in.source) + for epp_in in epp_ins: + epp_sources.add(epp_in.source) + ep_targets = set() + epp_targets = set() + for ep_out in ep_outs: + ep_targets.add(ep_out.target) + for epp_out in epp_outs: + epp_targets.add(epp_out.target) + if ep_sources == epp_sources and ep_targets == epp_targets: + is_parallel = True + if is_parallel and m[event_place] == m[event_place_prime]: + parallel_places.add(event_place_prime) + places_to_rename[event_place] = f'{type_prime}_{event_place.name}' + ps_to_remove = ps_to_remove.union(parallel_places) + + for p in ps_to_remove: + net = petri_utils.remove_place(net, p) + + for p, name in places_to_rename.items(): + p.name = name + return net + + def export_debug_net(self, net, m, path, step, pn_export_format): + """ + Helper function to export a petri net at any intermediary step in the conversion of the DcrGraph + """ + path_without_extension, extens = os.path.splitext(path) + debug_save_path = f'{path_without_extension}_{step}{extens}' + pnml_exporter.apply(net, m, debug_save_path, variant=pn_export_format, parameters={'isTimed': False}) + + def apply(self, graph, pn_path=None, **kwargs) -> (InhibitorNet, Marking): + self.initialize_helper_struct(graph) + self.mapping_exceptions = exceptional_cases.ExceptionalCases(self.helper_struct) + self.preoptimizer = preoptimizer.Preoptimizer() + induction_step = 0 + pn_export_format = pnml_exporter.TAPN + if pn_path and pn_path.endswith("pnml"): + pn_export_format = pnml_exporter.PNML + + tapn = InhibitorNet("Dcr2Pn") + m = Marking() + # pre-optimize mapping based on DCR graph behaviour + if self.preoptimize: + if self.print_steps: + print('[i] preoptimizing') + self.preoptimizer.pre_optimize_based_on_dcr_behaviour(graph) + if not self.map_unexecutable_events: + graph = self.preoptimizer.remove_un_executable_events_from_dcr(graph) + + # including the handling of exception cases from the induction step + graph = self.mapping_exceptions.filter_exceptional_cases(graph) + if self.preoptimize: + if self.print_steps: + print('[i] finding exceptional behaviour') + self.preoptimizer.preoptimize_based_on_exceptional_cases(graph, self.mapping_exceptions) + + # map events + if self.print_steps: + print('[i] mapping events') + for event in graph['events']: + tapn, m = self.create_event_pattern(event, graph, tapn, m) + + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}event', pn_export_format) + induction_step += 1 + + sr = single_relations.SingleRelations(self.helper_struct, self.mapping_exceptions) + # map constraining relations + if self.print_steps: + print('[i] map constraining relations') + for event in graph['conditionsFor']: + for event_prime in graph['conditionsFor'][event]: + tapn = sr.create_condition_pattern(event, event_prime, tapn) + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}conditionsFor', pn_export_format) + induction_step += 1 + for event in graph['milestonesFor']: + for event_prime in graph['milestonesFor'][event]: + tapn = sr.create_milestone_pattern(event, event_prime, tapn) + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}milestonesFor', pn_export_format) + induction_step += 1 + + # map effect relations + if self.print_steps: + print('[i] map effect relations') + for event in graph['includesTo']: + for event_prime in graph['includesTo'][event]: + tapn = sr.create_include_pattern(event, event_prime, tapn) + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}includesTo', pn_export_format) + induction_step += 1 + for event in graph['excludesTo']: + for event_prime in graph['excludesTo'][event]: + tapn = sr.create_exclude_pattern(event, event_prime, tapn) + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}{event}excludesTo{event_prime}', pn_export_format) + induction_step += 1 + for event in graph['responseTo']: + for event_prime in graph['responseTo'][event]: + tapn = sr.create_response_pattern(event, event_prime, tapn) + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}responseTo', pn_export_format) + induction_step += 1 + for event in graph['noResponseTo']: + for event_prime in graph['noResponseTo'][event]: + tapn = sr.create_no_response_pattern(event, event_prime, tapn) + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}noResponseTo', pn_export_format) + induction_step += 1 + + # handle all relation exceptions + if self.print_steps: + print('[i] handle all relation exceptions') + tapn = self.mapping_exceptions.map_exceptional_cases_between_events(tapn, m) + + if self.debug and pn_path: + self.export_debug_net(tapn, m, pn_path, f'{induction_step}exceptions', pn_export_format) + induction_step += 1 + + # post-optimize based on the petri net reachability graph + if self.postoptimize: + if self.print_steps: + print('[i] post optimizing') + tapn = self.post_optimize_petri_net_reachability_graph(tapn, m, graph) + + if pn_path: + if self.print_steps: + print(f'[i] export to {pn_path}') + + pnml_exporter.apply(tapn, m, pn_path, variant=pn_export_format, parameters={'isTimed': False}) + + return tapn, m + + +def apply(dcr, parameters): + d2p = Dcr2PetriNet(**parameters) + tapn, m = d2p.apply(dcr, **parameters) + return tapn, m diff --git a/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/__init__.py b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/exceptional_cases.py b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/exceptional_cases.py new file mode 100644 index 0000000000..13fbc28cd8 --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/exceptional_cases.py @@ -0,0 +1,1622 @@ +from pm4py.objects.petri_net.obj import * +from pm4py.objects.dcr.obj import TemplateRelations as Relations +from pm4py.objects.conversion.dcr.variants.to_petri_net_submodules import utils + +from itertools import combinations + +I = Relations.I.value +E = Relations.E.value +R = Relations.R.value +N = Relations.N.value +C = Relations.C.value +M = Relations.M.value + + +class ExceptionalCases(object): + + def __init__(self, helper_struct) -> None: + self.helper_struct = helper_struct + + self.effect_relations = [I, E, R, N] + self.constrain_relations = [C, M] + self.all_relations = self.effect_relations + self.constrain_relations + + self.self_exceptions = {} + for r in self.all_relations: + self.self_exceptions[r] = set() + self.self_exceptions[frozenset([E, R])] = set() + self.self_exceptions[frozenset([C, M])] = set() + self.exceptions = {} + self.apply_exceptions = {} + for i in range(6, 1, -1): + for comb in combinations(self.all_relations, i): + self.exceptions[frozenset(comb)] = set() + apply_comb = set(comb) + if I in apply_comb and E in apply_comb: + apply_comb.remove(E) + if R in apply_comb and N in apply_comb: + apply_comb.remove(N) + self.apply_exceptions[frozenset(apply_comb)] = None + + # 2 constrain + 4 effect relations (permutations 1 - 1 [because {CMIERN}=={CMIR}]) = 0 + # 2 constrain + 3 effect relations (permutations 4 - 4 [all reduce to 2 constrain 2 effects]) = 0 + # 2 constrain + 2 effect relations (permutations 6 - 2 [{CMIE}=={CMI} and {CMRN}=={CMR}]) = 4 + self.apply_exceptions[ + frozenset([C, M, E, R])] = self.create_exception_condition_milestone_exclude_response_pattern + self.apply_exceptions[ + frozenset([C, M, E, N])] = self.create_exception_condition_milestone_exclude_no_response_pattern + self.apply_exceptions[ + frozenset([C, M, I, R])] = self.create_exception_condition_milestone_include_response_pattern + self.apply_exceptions[ + frozenset([C, M, I, N])] = self.create_exception_condition_milestone_include_no_response_pattern + # 1 constrain + 4 effect relations (permutations 2 - 2 [all reduce to 1 constrain 2 effects]) = 0 + # 1 constrain + 3 effect relations (permutations 8 - 8 [all reduce to 1 constrain 2 effects]) = 0 + # 0 constrain + 4 effect relations (1-1 [because {I,E,R,N}=={I,R}]) = 0 + # 2 constrain + 1 effect (4) + self.apply_exceptions[frozenset([C, M, R])] = self.create_exception_condition_milestone_response_pattern + self.apply_exceptions[frozenset([C, M, N])] = self.create_exception_condition_milestone_no_response_pattern + self.apply_exceptions[frozenset([C, M, I])] = self.create_exception_condition_milestone_include_pattern + self.apply_exceptions[frozenset([C, M, E])] = self.create_exception_condition_milestone_exclude_pattern + # 1 constrain + 2 effect relations (12 - 4 [{C,R,N},{C,I,E},{M,R,N},{M,I,E}]) = 8 + self.apply_exceptions[frozenset([M, N, I])] = self.create_exception_milestone_no_response_include_pattern + self.apply_exceptions[frozenset([M, N, E])] = self.create_exception_milestone_no_response_exclude_pattern + self.apply_exceptions[frozenset([M, R, I])] = self.create_exception_milestone_response_include_pattern + self.apply_exceptions[frozenset([M, R, E])] = self.create_exception_milestone_response_exclude_pattern + self.apply_exceptions[frozenset([C, N, I])] = self.create_exception_condition_no_response_include_pattern + self.apply_exceptions[frozenset([C, N, E])] = self.create_exception_condition_no_response_exclude_pattern + self.apply_exceptions[frozenset([C, R, I])] = self.create_exception_condition_response_include_pattern + self.apply_exceptions[frozenset([C, R, E])] = self.create_exception_condition_response_exclude_pattern + # 0 constrain + 3 effect relations (4 - 4 [all reduce to 2 effects]) = 0 + # 1 constrain + 1 effect relation (8) = 8 + self.apply_exceptions[frozenset([I, C])] = self.create_exception_condition_include_pattern + self.apply_exceptions[frozenset([E, C])] = self.create_exception_condition_exclude_pattern + self.apply_exceptions[frozenset([R, C])] = self.create_exception_condition_response_pattern + self.apply_exceptions[frozenset([C, N])] = self.create_exception_condition_no_response_pattern + self.apply_exceptions[frozenset([M, N])] = self.create_exception_milestone_no_response_pattern + self.apply_exceptions[frozenset([M, E])] = self.create_exception_milestone_exclude_pattern + self.apply_exceptions[frozenset([M, I])] = self.create_exception_milestone_include_pattern + self.apply_exceptions[frozenset([M, R])] = self.create_exception_milestone_response_pattern + # 0 constrain + 2 effect relations (6 - 2 [{R,N},{I,E}]) = 4 + self.apply_exceptions[frozenset([I, R])] = self.create_exception_response_include_pattern + self.apply_exceptions[frozenset([E, R])] = self.create_exception_response_exclude_pattern + self.apply_exceptions[frozenset([N, E])] = self.create_exception_no_response_exclude_pattern + self.apply_exceptions[frozenset([N, I])] = self.create_exception_no_response_include_pattern + # 2 constrain + 0 effect relations (1) = 1 + self.apply_exceptions[frozenset([C, M])] = self.create_exception_condition_milestone_pattern + + def filter_exceptional_cases(self, G): + for e in G['events']: + for e_prime in G['events']: + if e == e_prime: + # same event multiple self relations + if (e in G['responseTo'] and e_prime in G['responseTo'][e]) and ( + e in G['excludesTo'] and e_prime in G['excludesTo'][e]) and \ + (e in G['conditionsFor'] and e_prime in G['conditionsFor'][e]) and ( + e in G['milestonesFor'] and e_prime in G['milestonesFor'][e]) and \ + (e in G['includesTo'] and e_prime in G['includesTo'][e]) and ( + e in G['noResponseTo'] and e_prime in G['noResponseTo'][e]): + G['conditionsFor'][e].remove(e_prime) + G['milestonesFor'][e].remove(e_prime) + G['responseTo'][e].remove(e_prime) + G['excludesTo'][e].remove(e_prime) + G['includesTo'][e].remove(e_prime) + G['noResponseTo'][e].remove(e_prime) + self.helper_struct[e]['t_types'] = ['event'] + self.self_exceptions['responseTo'].add(e) + self.self_exceptions[frozenset(['conditionsFor', 'milestonesFor'])].add(e) + + if (e in G['responseTo'] and e_prime in G['responseTo'][e]) and ( + e in G['excludesTo'] and e_prime in G['excludesTo'][e]): + G['responseTo'][e].remove(e_prime) + G['excludesTo'][e].remove(e_prime) + self.self_exceptions[frozenset(['excludesTo', 'responseTo'])].add(e) + if (e in G['conditionsFor'] and e_prime in G['conditionsFor'][e]) and ( + e in G['milestonesFor'] and e_prime in G['milestonesFor'][e]): + G['conditionsFor'][e].remove(e_prime) + G['milestonesFor'][e].remove(e_prime) + self.helper_struct[e]['t_types'] = ['event'] + self.self_exceptions[frozenset(['conditionsFor', 'milestonesFor'])].add(e) + if (e in G['includesTo'] and e_prime in G['includesTo'][e]) and ( + e in G['excludesTo'] and e_prime in G['excludesTo'][e]): + G['excludesTo'][e].remove(e_prime) + # same event one self relation + for rel in self.all_relations: + if e in G[rel] and e_prime in G[rel][e]: + G[rel][e].remove(e_prime) + self.self_exceptions[rel].add(e) + match rel: + case 'conditionsFor': + # removes the creation of the init and initpend transitions + self.helper_struct[e]['t_types'] = ['event', 'pend'] + case 'milestonesFor': + # removes the creation of the pend and initpend transitions + self.helper_struct[e]['t_types'] = ['event', 'init'] + else: + # distinct events + for exception in self.exceptions.keys(): + has_multiple_rel = True + for rel in exception: + has_multiple_rel = has_multiple_rel and (e in G[rel] and e_prime in G[rel][e]) + if has_multiple_rel: + remove_from_g = True + if I in exception and E in exception: + G[E][e].remove(e_prime) + remove_from_g = False + if R in exception and N in exception: + G[N][e].remove(e_prime) + remove_from_g = False + if remove_from_g: + self.exceptions[exception].add((e, e_prime)) + for rel in exception: + G[rel][e].remove(e_prime) + + return G + + def map_exceptional_cases_between_events(self, tapn, m=None) -> PetriNet: + for exception, pairs in self.exceptions.items(): + if len(pairs) > 0: + tapn = self.apply_exceptions[exception](tapn, m) + return tapn + + def create_exception_condition_milestone_exclude_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, R, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 and 2 + copies = [1, 2] if pend_excl_place_e_prime else [1] + for i in copies: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + if i == 1: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + elif i == 2: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_exclude_no_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, N, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 and 2 + copies = [1, 2] if pend_excl_place_e_prime else [1] + for i in copies: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + if i == 1: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + elif i == 2: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_include_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, R, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 and 2 + copies = [1, 2] if pend_excl_place_e_prime else [1] + for i in copies: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + if i == 1: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + elif i == 2: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_include_no_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, N, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 and 2 + copies = [1, 2] if pend_excl_place_e_prime else [1] + for i in copies: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + if i == 1: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + elif i == 2: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([R, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 and 2 + copies = [1, 2] if pend_excl_place_e_prime else [1] + for i in copies: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + if i == 1: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + elif i == 2: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_no_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 and 2 + copies = [1, 2] if pend_excl_place_e_prime else [1] + for i in copies: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + if i == 1: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + elif i == 2: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_include_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 and 2 + copies = [1, 2] if pend_excl_place_e_prime else [1] + for i in copies: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + if i == 1: + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + elif i == 2: + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_exclude_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_no_response_include_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, N, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if pend_place_e_prime: + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_no_response_exclude_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, N, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if pend_place_e_prime: + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_response_include_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, R, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime and pend_excluded_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + # copy 0 + if pend_excluded_place_e_prime: + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_response_exclude_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, R, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime and pend_excluded_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excluded_place_e_prime, tapn) + + # copy 2 + if inc_place_e_prime and pend_excluded_place_e_prime and pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excluded_place_e_prime, tapn) + + # copy 0 + if pend_excluded_place_e_prime: + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excluded_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_no_response_include_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C, I])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + # copy 2 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if pend_place_e_prime: + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_no_response_exclude_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C, E])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + # copy 2 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if pend_place_e_prime: + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_response_include_pattern(self, tapn, m=None) -> PetriNet: + ''' + TODO: Make the if places statements + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([I, R, C])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + # copy 2 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 3 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_response_exclude_pattern(self, tapn, m=None) -> PetriNet: + ''' + TODO: Make the if places statements + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([E, R, C])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + # copy 2 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + # copy 3 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_include_pattern(self, tapn, m=None) -> PetriNet: + ''' + TODO: Test the if places statements + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([I, C])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, + self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 2 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_exclude_pattern(self, tapn, m=None) -> PetriNet: + ''' + TODO: Test the if places statements + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([E, C])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + # copy 2 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_response_pattern(self, tapn, m=None) -> PetriNet: + ''' + Done + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([R, C])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + # copy 2 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + # copy 3 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_response_include_pattern(self, tapn, m=None) -> PetriNet: + ''' + DONE + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([I, R])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 2 + if inc_place_e_prime and pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_response_exclude_pattern(self, tapn, m=None) -> PetriNet: + ''' + DONE + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([E, R])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + # copy 2 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_no_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + # copy 2 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_no_response_exclude_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, N])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 2 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_no_response_include_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, N])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 2 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_no_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_condition_milestone_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([C, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_exclude_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_include_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if pend_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + # copy 2 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # map the copy_0 last but before adding the new transitions + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exception_milestone_response_pattern(self, tapn, m=None) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([R, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if pend_excluded_place_e_prime or inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_excluded_place_e_prime, tapn) + + # copy 2 + if pend_excluded_place_e_prime and inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excluded_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn diff --git a/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/preoptimizer.py b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/preoptimizer.py new file mode 100644 index 0000000000..4f50528b22 --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/preoptimizer.py @@ -0,0 +1,77 @@ +from pm4py.objects.dcr.obj import TemplateRelations as Relations + +class Preoptimizer(object): + need_included_place = set() + need_executed_place = set() + need_pending_place = set() + need_pending_excluded_place = set() + un_executable_events = set() + + def pre_optimize_based_on_dcr_behaviour(self, G): + need_pending_excluded_place = set() + + inclusion_events = set() + exclusion_events = set() + + condition_events = set() + + response_events = set() + no_response_events = set() + milestone_events = set() + + for event in G['events']: + inclusion_events = inclusion_events.union(set(G['includesTo'][event] if event in G['includesTo'] else set())) + exclusion_events = exclusion_events.union(set(G['excludesTo'][event] if event in G['excludesTo'] else set())) + + condition_events = condition_events.union(set(G['conditionsFor'][event] if event in G['conditionsFor'] else set())) + + response_events = response_events.union(set(G['responseTo'][event] if event in G['responseTo'] else set())) + no_response_events = no_response_events.union(set(G['noResponseTo'][event] if event in G['noResponseTo'] else set())) + milestone_events = milestone_events.union(set(G['milestonesFor'][event] if event in G['milestonesFor'] else set())) + + not_included_events = set(G['events']).difference(set(G['marking']['included'])) + not_pending_events = set(G['events']).difference(set(G['marking']['pending'])) + not_included_become_included = not_included_events.intersection(inclusion_events) + included_become_excluded = set(G['marking']['included']).intersection(exclusion_events) + need_included_place = not_included_become_included.union(included_become_excluded) + unexecutable_events = not_included_events.difference(inclusion_events) + + need_executed_place = set(G['marking']['executed']).union(condition_events) + need_pending_place = set(G['marking']['pending']).union(response_events).union(milestone_events).union(no_response_events) + need_pending_excluded_place = need_pending_place.intersection(need_included_place) + + self.no_init_t = set(G['marking']['pending']).difference(no_response_events) + self.no_initpend_t = not_pending_events.difference(response_events) + + self.need_included_place = need_included_place + self.need_executed_place = need_executed_place + self.need_pending_place = need_pending_place + self.need_pending_excluded_place = need_pending_excluded_place + self.un_executable_events = unexecutable_events + + def preoptimize_based_on_exceptional_cases(self,G, exceptional_cases): + self.remove_init = set() + self.remove_initpend = set() + for k, values in exceptional_cases.exceptions.items(): + for v in values: + for e in G['events']: + if Relations.C.value in k and Relations.M.value in k and e in v[1]: + if e in self.no_init_t: + self.remove_init.add(e) + if e in self.no_initpend_t: + self.remove_initpend.add(e) + + def remove_un_executable_events_from_dcr(self, G): + + for rule in ['conditionsFor', 'milestonesFor', 'responseTo', 'noResponseTo', 'includesTo', 'excludesTo']: + for re in self.un_executable_events: + G[rule].pop(re, None) + for event in G['events']: + if event not in self.un_executable_events and event in G[rule]: + G[rule][event] = G[rule][event].difference(self.un_executable_events) + + G['marking']['included'] = set(G['marking']['included']).difference(self.un_executable_events) + G['marking']['executed'] = set(G['marking']['executed']).difference(self.un_executable_events) + G['marking']['pending'] = set(G['marking']['pending']).difference(self.un_executable_events) + G['events'] = set(G['events']).difference(self.un_executable_events) + return G \ No newline at end of file diff --git a/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/single_relations.py b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/single_relations.py new file mode 100644 index 0000000000..ad5c68a383 --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/single_relations.py @@ -0,0 +1,256 @@ +from pm4py.objects.petri_net.obj import * + +from pm4py.objects.conversion.dcr.variants.to_petri_net_submodules import utils + +class SingleRelations(object): + + def __init__(self, helper_struct, mapping_exceptions) -> None: + self.helper_struct = helper_struct + self.mapping_exceptions = mapping_exceptions + + def create_include_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + # copy 2 + if pend_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # map the copy_0 last but before adding the new transitions + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exclude_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + # check if removing t works + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if pend_place_e_prime and pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_response_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 2 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_no_response_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_place_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 2 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_condition_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_milestone_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct[event_prime]['places']['pending'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = len(self.helper_struct[event]['t_types']) + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn diff --git a/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/utils.py b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/utils.py new file mode 100644 index 0000000000..8fb34aa371 --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_petri_net_submodules/utils.py @@ -0,0 +1,139 @@ +from pm4py.objects.petri_net import properties +from pm4py.objects.petri_net.obj import * +from pm4py.objects.dcr.obj import TemplateRelations as Relations + +def check_arc_exists(source, target, tapn:PetriNet): + if source in tapn.arc_matrix and target in tapn.arc_matrix[source]: + return tapn.arc_matrix[source][target] + else: + return False + +def add_arc_from_to_with_check(fr, to, net: PetriNet, weight=1, type=None, with_check=False) -> PetriNet.Arc: + """ + TODO: merge add_arc_from_to into add_arc_from_to_apt + Adds an arc from a specific element to another element in some net. Assumes from and to are in the net! + + Parameters + ---------- + fr: transition/place from + to: transition/place to + net: net to use + weight: weight associated to the arc + + Returns + ------- + None + """ + a = PetriNet.Arc(fr, to, weight) + if with_check and (fr and to): + with_check = check_arc_exists(fr, to, net) + if (fr and to) and not with_check: # and not check_arc_exists(fr,to,net): + if type is not None: + a.properties[properties.ARCTYPE] = type + net.arcs.add(a) + fr.out_arcs.add(a) + to.in_arcs.add(a) + if fr not in net.arc_matrix: + net.arc_matrix[fr] = {} + net.arc_matrix[fr][to] = True + + return a + +def map_existing_transitions_of_copy_0(delta, copy_0, t, tapn) -> (PetriNet, PetriNet.Transition): + trans = copy_0[delta] + # if trans in tapn.transitions: # since this is a copy this cannot be checked here. trust me bro + in_arcs = trans.in_arcs + for arc in in_arcs: + source = arc.source + type = arc.properties['arctype'] if 'arctype' in arc.properties else None + add_arc_from_to_with_check(source, t, tapn, type=type, with_check=True) + out_arcs = trans.out_arcs + for arc in out_arcs: + target = arc.target + type = arc.properties['arctype'] if 'arctype' in arc.properties else None + add_arc_from_to_with_check(t, target, tapn, type=type, with_check=True) + return tapn, t + + +def create_event_pattern_transitions_and_arcs(tapn, event, helper_struct, mapping_exceptions): + ''' + TODO: handle self no-response (do nothing) and self milestone (cannot execute the event if it is pending) + Parameters + ---------- + tapn + event + helper_struct + mapping_exceptions + + Returns + ------- + + ''' + inc_place = helper_struct[event]['places']['included'] + exec_place = helper_struct[event]['places']['executed'] + pend_place = helper_struct[event]['places']['pending'] + pend_exc_place = helper_struct[event]['places']['pending_excluded'] + i_copy = helper_struct[event]['trans_group_index'] + ts = [] + for t_name in helper_struct[event]['t_types']: # ['event','init','initpend','pend']: + t = PetriNet.Transition(f'{t_name}_{event}{i_copy}', f'{t_name}_{event}{i_copy}_label') + tapn.transitions.add(t) + # this if statement handles self response exclude + if event in mapping_exceptions.self_exceptions[frozenset([Relations.E.value, Relations.R.value])]: + add_arc_from_to_with_check(t, pend_exc_place, tapn) + + add_arc_from_to_with_check(inc_place, t, tapn) + # this if statement handles self exclude and self response exclude + if not ((event in mapping_exceptions.self_exceptions[Relations.E.value]) or ( + event in mapping_exceptions.self_exceptions[frozenset([Relations.E.value, Relations.R.value])])): + add_arc_from_to_with_check(t, inc_place, tapn) + + # this if statement handles self response + if event in mapping_exceptions.self_exceptions[Relations.R.value]: + add_arc_from_to_with_check(t, pend_place, tapn) + + if t_name.__contains__('init'): + add_arc_from_to_with_check(t, exec_place, tapn) + add_arc_from_to_with_check(exec_place, t, tapn, type='inhibitor') + else: + add_arc_from_to_with_check(t, exec_place, tapn) + add_arc_from_to_with_check(exec_place, t, tapn) + + if t_name.__contains__('pend'): + add_arc_from_to_with_check(pend_place, t, tapn) + else: + add_arc_from_to_with_check(pend_place, t, tapn, type='inhibitor') + ts.append(t) + helper_struct[event]['trans_group_index'] += 1 + return tapn, ts + + +def get_expected_places_transitions_arcs(G): + # 3^(conditions + milestones) * 2^((inc+exc)+(resp+no_resp))*2 for each event in relations + expected_transitions = 0 + # 3*no of events + expected_places = 4 * len(G['events']) + # arcs: + # - events * 12 + # - conditions * 9 + # - milestones * 8 + # - responses * 2 + # - noResponses * 2 + # - includes * 2 + # - exludes * 2 + expected_arcs = 0 + + for event in G['events']: + expected_transitions += ((3 ** (len(G['conditionsFor'][event]) if event in G['conditionsFor'] else 0 + +len(G['milestonesFor'][event]) if event in G['milestonesFor'] else 0)) * (3 ** ((len(G['includesTo'][event]) if event in G['includesTo'] else 0 + +len(G['excludesTo'][event]) if event in G['excludesTo'] else 0)) * (4 ** (len(G['responseTo'][event]) if event in G['responseTo'] else 0 + +len(G['noResponseTo'][event]) if event in G['noResponseTo'] else 0)))) * 4 + expected_arcs += 2 ^ ((3 ^ (len(set(G['includesTo'][event] if event in G['includesTo'] else set()).union( + set(G['excludesTo'][event] if event in G['excludesTo'] else set()))))) * + (4 ^ (len(set(G['responseTo'][event] if event in G['responseTo'] else set()).union( + set(G['noResponseTo'][event] if event in G['noResponseTo'] else set()))))) * + (3 ^ ((len(set(G['conditionsFor'][event])) if event in G['conditionsFor'] else 0))) * + (3 ^ ((len(set(G['milestonesFor'][event])) if event in G['milestonesFor'] else 0)))) + + expected_arcs += len(G['events']) * 24 + return expected_places, expected_transitions, expected_arcs diff --git a/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net.py b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net.py new file mode 100644 index 0000000000..eebdad6956 --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net.py @@ -0,0 +1,384 @@ +import os +from copy import deepcopy + +from pm4py.objects.petri_net.timed_arc_net.obj import * +from pm4py.objects.petri_net.exporter import exporter as pnml_exporter +from pm4py.objects.petri_net import properties as pn_props + +from pm4py.objects.conversion.dcr.variants.to_timed_arc_petri_net_submodules import (timed_exceptional_cases, + timed_single_relations, + timed_preoptimizer, + timed_utils) + + +class Dcr2TimedArcPetri(object): + + def __init__(self, preoptimize=True, postoptimize=True, map_unexecutable_events=False, debug=False, **kwargs) -> None: + self.in_t_types = ['event', 'init', 'initpend', 'pend'] + self.helper_struct = {} + self.preoptimize = preoptimize + self.postoptimize = postoptimize + self.map_unexecutable_events = map_unexecutable_events + self.preoptimizer = timed_preoptimizer.TimedPreoptimizer() + self.transitions = {} + self.helper_struct['pend_matrix'] = {} + self.helper_struct['pend_exc_matrix'] = {} + self.mapping_exceptions = None + self.reachability_timeout = None + self.print_steps = debug + self.debug = debug + + def initialize_helper_struct(self, G) -> None: + self.helper_struct['transport_index'] = 0 + for event in G['events']: + self.helper_struct[event] = {} + self.helper_struct[event]['places'] = {} + self.helper_struct[event]['places']['included'] = None + self.helper_struct[event]['places']['pending'] = set() + self.helper_struct[event]['places']['pending_excluded'] = set() + self.helper_struct[event]['places']['executed'] = None + self.helper_struct[event]['transitions'] = [] + self.helper_struct[event]['t_types'] = self.in_t_types + self.helper_struct[event]['pending_pairs'] = {} + self.helper_struct[event]['trans_group_index'] = 0 + + self.helper_struct[event]['firstResp'] = True + self.helper_struct[event]['firstNoResp'] = True + + self.transitions[event] = {} + self.helper_struct['pend_matrix'][event] = {} + self.helper_struct['pend_exc_matrix'][event] = {} + for event_prime in G['events']: + self.transitions[event][event_prime] = [] + self.helper_struct['pend_matrix'][event][event_prime] = None + self.helper_struct['pend_exc_matrix'][event][event_prime] = None + # if effect (resp or noresp) > 1 between event -> multiple event_prime + # then the default makes pending or makes not pending has to have the same effect on all + # therefore you do not copy that transition for multiple relations + + def create_event_pattern_places(self, event, G, tapn, m) -> (TimedArcNet, TimedMarking): + default_make_included = True + default_make_pend = True + default_make_pend_ex = True + default_make_exec = True + if self.preoptimize: + default_make_included = event in self.preoptimizer.need_included_place + default_make_pend = event in self.preoptimizer.need_pending_place + default_make_pend_ex = event in self.preoptimizer.need_pending_excluded_place + default_make_exec = event in self.preoptimizer.need_executed_place + + if default_make_included: + inc_place = TimedArcNet.Place(f'included_{event}') + tapn.places.add(inc_place) + self.helper_struct[event]['places']['included'] = inc_place + # fill the marking + if event in G['marking']['included']: + m[inc_place] = 1 + + if default_make_pend: + if event in G['marking']['pendingDeadline']: + init_pend_place = TimedArcNet.Place(f'init_pending_{event}') + init_pend_place.properties['ageinvariant'] = G['marking']['pendingDeadline'][event] + tapn.places.add(init_pend_place) + self.helper_struct[event]['places']['pending'].add((init_pend_place, event)) + self.helper_struct['pend_matrix'][event][event] = init_pend_place + self.helper_struct[event]['pending_pairs'][event] = init_pend_place + if event in G['marking']['pending'] and event in G['marking']['included']: + m[init_pend_place] = 1 + + if default_make_pend_ex: + if event in G['marking']['pendingDeadline']: + init_pend_excl_place = TimedArcNet.Place(f'init_pending_excluded_{event}') + tapn.places.add(init_pend_excl_place) + self.helper_struct[event]['places']['pending_excluded'].add((init_pend_excl_place, event)) + self.helper_struct['pend_exc_matrix'][event][event] = init_pend_excl_place + self.helper_struct[event]['pending_pairs'][event] = ( + self.helper_struct[event]['pending_pairs'][event], init_pend_excl_place) + if event in G['marking']['pending'] and event not in G['marking']['included']: + m[init_pend_excl_place] = 1 + + e_prime_pending_by_e = {} + for k, v1 in G['responseToDeadlines'].items(): + for v in v1: + if v not in e_prime_pending_by_e: + e_prime_pending_by_e[v] = set() + e_prime_pending_by_e[v].add(k) + for k, v1 in G['responseTo'].items(): + for v in v1: + if v not in e_prime_pending_by_e: + e_prime_pending_by_e[v] = set() + e_prime_pending_by_e[v].add(k) + if event in e_prime_pending_by_e: + if default_make_pend: + for event_prime in e_prime_pending_by_e[event]: + pend_by_place = TimedArcNet.Place(f'pending_{event}_by_{event_prime}') + if event_prime in G['responseToDeadlines'] and event in G['responseToDeadlines'][event_prime]: + pend_by_place.properties['ageinvariant'] = G['responseToDeadlines'][event_prime][event] + tapn.places.add(pend_by_place) + self.helper_struct[event]['places']['pending'].add((pend_by_place, event_prime)) + self.helper_struct['pend_matrix'][event][event_prime] = pend_by_place + self.helper_struct[event]['pending_pairs'][event_prime] = pend_by_place + + if default_make_pend_ex: + for event_prime in e_prime_pending_by_e[event]: + pend_excl_by_place = TimedArcNet.Place(f'pending_excluded_{event}_by_{event_prime}') + tapn.places.add(pend_excl_by_place) + self.helper_struct[event]['places']['pending_excluded'].add((pend_excl_by_place, event_prime)) + self.helper_struct['pend_exc_matrix'][event][event_prime] = pend_excl_by_place + self.helper_struct[event]['pending_pairs'][event_prime] = (self.helper_struct[event]['pending_pairs'][event_prime], pend_excl_by_place) + else: + if default_make_pend: + pend_place = TimedArcNet.Place(f'pending_{event}') + tapn.places.add(pend_place) + self.helper_struct[event]['places']['pending'] = set([(pend_place, '')]) + # fill the marking + if event in G['marking']['pending'] and event in G['marking']['included']: + m[pend_place] = 1 + + if default_make_pend_ex: + pend_excl_place = TimedArcNet.Place(f'pending_excluded_{event}') + tapn.places.add(pend_excl_place) + self.helper_struct[event]['places']['pending_excluded'] = set([(pend_excl_place, '')]) + # fill the marking + if event in G['marking']['pending'] and not event in G['marking']['included']: + m[pend_excl_place] = 1 + + if default_make_exec: + exec_place = TimedArcNet.Place(f'executed_{event}') + tapn.places.add(exec_place) + self.helper_struct[event]['places']['executed'] = exec_place + # fill the marking + if event in G['marking']['executed']: + m[exec_place] = 1 + if self.preoptimize: + ts = ['event'] + if default_make_exec and not event in G['marking']['executed'] and not event in self.preoptimizer.no_init_t: + ts.append('init') + if default_make_exec and default_make_pend and not event in self.preoptimizer.no_initpend_t: + ts.append('initpend') + if default_make_pend: + ts.append('pend') + self.helper_struct[event]['t_types'] = ts + return tapn, m + + def create_event_pattern(self, event, G, tapn, m) -> (TimedArcNet, TimedMarking): + tapn, m = self.create_event_pattern_places(event, G, tapn, m) + + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, + self.mapping_exceptions) + self.helper_struct[event]['transitions'].extend(ts) + self.helper_struct[event]['len_internal'] = len(ts) + return tapn, m + + def post_optimize_petri_net_reachability_graph(self, tapn, m, G=None) -> TimedArcNet: + from pm4py.objects.petri_net.utils import petri_utils + from pm4py.objects.conversion.dcr.variants import reachability_analysis + # from pm4py.visualization.transition_system import visualizer as ts_visualizer + from pm4py.objects.petri_net.timed_arc_net import semantics as tapn_semantics + from pm4py.objects.petri_net.inhibitor_reset import semantics as inhibitor_semantics + max_elab_time = 2 * 60 * 60 # 2 hours + if self.reachability_timeout: + max_elab_time = self.reachability_timeout + trans_sys = reachability_analysis.construct_reachability_graph(tapn, m, use_trans_name=True, + parameters={ + # 'petri_semantics': inhibitor_semantics.InhibitorResetSemantics(), + 'petri_semantics': tapn_semantics.TimedArcSemantics(), + 'max_elab_time': max_elab_time}) + + fired_transitions = set() + + for transition in trans_sys.transitions: + fired_transitions.add(transition.name) + + ts_to_remove = set() + for t in tapn.transitions: + if t.name not in fired_transitions: + ts_to_remove.add(t) + for t in ts_to_remove: + tapn = petri_utils.remove_transition(tapn, t) + + changed_places = set() + for state_list in trans_sys.states: + for state in state_list.name: + changed_places.add(state) + + parallel_places = set() + places_to_rename = {} + ps_to_remove = set(tapn.places).difference(changed_places) + if G: + for event in G['events']: + for type, event_place in self.helper_struct[event]['places'].items(): + for type_prime, event_place_prime in self.helper_struct[event]['places'].items(): + # if type_prime is (pending or pending_excluded) then event_place_prime is a set + if type in ['pending', 'pending_excluded'] and type_prime in ['pending', 'pending_excluded']: + for ep, _ in event_place: + for epp, _ in event_place_prime: + self.post_optimize_parallel_places(ep, epp, parallel_places, places_to_rename, type_prime, m) + elif type in ['pending', 'pending_excluded']: + for ep, _ in event_place: + self.post_optimize_parallel_places(ep, event_place_prime, parallel_places, places_to_rename, type_prime, m) + elif type_prime in ['pending', 'pending_excluded']: + for epp, _ in event_place_prime: + self.post_optimize_parallel_places(event_place, epp, parallel_places, places_to_rename, type_prime, m) + else: + self.post_optimize_parallel_places(event_place, event_place_prime, parallel_places, places_to_rename, type_prime, m) + + ps_to_remove = ps_to_remove.union(parallel_places) + for p in ps_to_remove: + tapn = petri_utils.remove_place(tapn, p) + + for p, name in places_to_rename.items(): + p.name = name + + return tapn + + @staticmethod + def post_optimize_parallel_places(event_place, event_place_prime, parallel_places, places_to_rename, type_prime, m): + if event_place and event_place_prime and event_place.name != event_place_prime.name and event_place not in parallel_places: + is_parallel = False + ep_ins = event_place.in_arcs + epp_ins = event_place_prime.in_arcs + ep_outs = event_place.out_arcs + epp_outs = event_place_prime.out_arcs + if len(ep_ins) == len(epp_ins) and len(ep_outs) == len(epp_outs): + ep_sources = set() + epp_sources = set() + for ep_in in ep_ins: + ep_sources.add(ep_in.source) + for epp_in in epp_ins: + epp_sources.add(epp_in.source) + ep_targets = set() + epp_targets = set() + for ep_out in ep_outs: + ep_targets.add(ep_out.target) + for epp_out in epp_outs: + epp_targets.add(epp_out.target) + if ep_sources == epp_sources and ep_targets == epp_targets: + is_parallel = True + if is_parallel and m[event_place] == m[event_place_prime]: + parallel_places.add(event_place_prime) + by_who = '' + if pn_props.AGE_INVARIANT not in event_place.properties and pn_props.AGE_INVARIANT in event_place_prime.properties: + event_place.properties[pn_props.AGE_INVARIANT] = event_place_prime.properties[pn_props.AGE_INVARIANT] + by_who = f"_by_{str.split(event_place_prime.name,'_')[-1]}" + places_to_rename[event_place] = f'{type_prime}_{event_place.name}{by_who}' + + def export_debug_net(self, tapn, m, path, step, pn_export_format): + path_without_extension, extens = os.path.splitext(path) + debug_save_path = f'{path_without_extension}_{step}{extens}' + pnml_exporter.apply(tapn, m, debug_save_path, variant=pn_export_format, parameters={'isTimed': True}) + + def apply(self, G, tapn_path=None, **kwargs) -> (TimedArcNet, TimedMarking): + self.transport_idx = 0 + self.initialize_helper_struct(G) + self.mapping_exceptions = timed_exceptional_cases.TimedExceptionalCases(self.helper_struct) + self.preoptimizer = timed_preoptimizer.TimedPreoptimizer() + induction_step = 0 + pn_export_format = pnml_exporter.TAPN + if tapn_path and tapn_path.endswith("pnml"): + pn_export_format = pnml_exporter.PNML + + tapn = TimedArcNet("Dcr2Tapn") + m = TimedMarking() + # pre-optimize mapping based on DCR graph behaviour + if self.preoptimize: + if self.print_steps: + print('[i] preoptimizing') + self.preoptimizer.pre_optimize_based_on_dcr_behaviour(G) + if not self.map_unexecutable_events: + G = self.preoptimizer.remove_un_executable_events_from_dcr(G) + + # including the handling of exception cases from the induction step + if self.preoptimize: + if self.print_steps: + print('[i] finding exceptional behaviour') + self.preoptimizer.preoptimize_based_on_exceptional_cases(G, self.mapping_exceptions) + + G, original_G = self.mapping_exceptions.filter_exceptional_cases(G) + # map events + if self.print_steps: + print('[i] mapping events') + for event in G['events']: + tapn, m = self.create_event_pattern(event, original_G, tapn, m) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}event', pn_export_format) + induction_step += 1 + + sr = timed_single_relations.TimedSingleRelations(self.helper_struct, self.mapping_exceptions) + # map constraining relations + if self.print_steps: + print('[i] map constraining relations') + for event in G['conditionsFor']: + for event_prime in G['conditionsFor'][event]: + delay = None + if event in G['conditionsForDelays'] and event_prime in G['conditionsForDelays'][event]: + delay = G['conditionsForDelays'][event][event_prime] + tapn = sr.create_condition_pattern(event, event_prime, tapn, delay=delay) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}conditionsFor', pn_export_format) + induction_step += 1 + for event in G['milestonesFor']: + for event_prime in G['milestonesFor'][event]: + tapn = sr.create_milestone_pattern(event, event_prime, tapn) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}milestonesFor', pn_export_format) + induction_step += 1 + + # map effect relations + if self.print_steps: + print('[i] map effect relations') + for event in G['responseTo']: + for event_prime in G['responseTo'][event]: + tapn = sr.create_response_pattern(event, event_prime, tapn) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}responseTo', pn_export_format) + induction_step += 1 + for event in G['noResponseTo']: + for event_prime in G['noResponseTo'][event]: + tapn = sr.create_no_response_pattern(event, event_prime, tapn) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}noResponseTo', pn_export_format) + induction_step += 1 + for event in G['includesTo']: + for event_prime in G['includesTo'][event]: + tapn = sr.create_include_pattern(event, event_prime, tapn) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}includesTo', pn_export_format) + induction_step += 1 + for event in G['excludesTo']: + for event_prime in G['excludesTo'][event]: + tapn = sr.create_exclude_pattern(event, event_prime, tapn) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}{event}excludesTo{event_prime}', pn_export_format) + induction_step += 1 + + # handle all relation exceptions + if self.print_steps: + print('[i] handle all relation exceptions') + tapn = self.mapping_exceptions.map_exceptional_cases_between_events(tapn, m, tapn_path, induction_step, pn_export_format, self.debug) + if self.debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions', pn_export_format) + induction_step += 1 + + # post-optimize based on the petri net reachability graph + if self.postoptimize: + if self.print_steps: + print('[i] post optimizing') + for k in tapn.places: + m.timed_dict[k] = 0 + tapn = self.post_optimize_petri_net_reachability_graph(tapn, m, G) + + if tapn_path: + if self.print_steps: + print(f'[i] export to {tapn_path}') + + pnml_exporter.apply(tapn, m, tapn_path, variant=pn_export_format, parameters={'isTimed': True}) + + return tapn, m + + +def apply(dcr, parameters): + d2p = Dcr2TimedArcPetri(**parameters) + G = deepcopy(dcr) + tapn, m = d2p.apply(G, **parameters) + return tapn, m diff --git a/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/__init__.py b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_exceptional_cases.py b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_exceptional_cases.py new file mode 100644 index 0000000000..cd7cc8c85d --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_exceptional_cases.py @@ -0,0 +1,2164 @@ +import os +from pm4py.objects.petri_net.obj import * +from pm4py.objects.dcr.obj import TemplateRelations +from pm4py.objects.conversion.dcr.variants.to_timed_arc_petri_net_submodules import timed_utils +from pm4py.objects.petri_net.exporter import exporter as pnml_exporter + +from itertools import combinations + +I = TemplateRelations.I.value +E = TemplateRelations.E.value +R = TemplateRelations.R.value +N = TemplateRelations.N.value +C = TemplateRelations.C.value +M = TemplateRelations.M.value + + +class TimedExceptionalCases(object): + + def __init__(self, helper_struct) -> None: + self.G = None + self.helper_struct = helper_struct + + self.effect_relations = [I, E, R, N] + self.constrain_relations = [C, M] + self.all_relations = self.effect_relations + self.constrain_relations + + self.self_exceptions = {} + for r in self.all_relations: + self.self_exceptions[r] = set() + self.self_exceptions[frozenset([E, R])] = set() + self.self_exceptions[frozenset([C, M])] = set() + self.exceptions = {} + self.apply_exceptions = {} + for i in range(6, 1, -1): + for comb in combinations(self.all_relations, i): + self.exceptions[frozenset(comb)] = set() + apply_comb = set(comb) + if I in apply_comb and E in apply_comb: + apply_comb.remove(E) + if R in apply_comb and N in apply_comb: + apply_comb.remove(N) + self.apply_exceptions[frozenset(apply_comb)] = None + + # 2 constrain + 4 effect relations (permutations 1 - 1 [because {CMIERN}=={CMIR}]) = 0 + # 2 constrain + 3 effect relations (permutations 4 - 4 [all reduce to 2 constrain 2 effects]) = 0 + # 2 constrain + 2 effect relations (permutations 6 - 2 [{CMIE}=={CMI} and {CMRN}=={CMR}]) = 4 + self.apply_exceptions[ + frozenset([C, M, E, R])] = self.create_exception_condition_milestone_exclude_response_pattern + self.apply_exceptions[ + frozenset([C, M, E, N])] = self.create_exception_condition_milestone_exclude_no_response_pattern + self.apply_exceptions[ + frozenset([C, M, I, R])] = self.create_exception_condition_milestone_include_response_pattern + self.apply_exceptions[ + frozenset([C, M, I, N])] = self.create_exception_condition_milestone_include_no_response_pattern + # 1 constrain + 4 effect relations (permutations 2 - 2 [all reduce to 1 constrain 2 effects]) = 0 + # 1 constrain + 3 effect relations (permutations 8 - 8 [all reduce to 1 constrain 2 effects]) = 0 + # 0 constrain + 4 effect relations (1-1 [because {I,E,R,N}=={I,R}]) = 0 + # 2 constrain + 1 effect (4) + self.apply_exceptions[frozenset([C, M, R])] = self.create_exception_condition_milestone_response_pattern + self.apply_exceptions[frozenset([C, M, N])] = self.create_exception_condition_milestone_no_response_pattern + self.apply_exceptions[frozenset([C, M, I])] = self.create_exception_condition_milestone_include_pattern + self.apply_exceptions[frozenset([C, M, E])] = self.create_exception_condition_milestone_exclude_pattern + # 1 constrain + 2 effect relations (12 - 4 [{C,R,N},{C,I,E},{M,R,N},{M,I,E}]) = 8 + self.apply_exceptions[frozenset([M, N, I])] = self.create_exception_milestone_no_response_include_pattern + self.apply_exceptions[frozenset([M, N, E])] = self.create_exception_milestone_no_response_exclude_pattern + self.apply_exceptions[frozenset([M, R, I])] = self.create_exception_milestone_response_include_pattern + self.apply_exceptions[frozenset([M, R, E])] = self.create_exception_milestone_response_exclude_pattern + self.apply_exceptions[frozenset([C, N, I])] = self.create_exception_condition_no_response_include_pattern + self.apply_exceptions[frozenset([C, N, E])] = self.create_exception_condition_no_response_exclude_pattern + self.apply_exceptions[frozenset([C, R, I])] = self.create_exception_condition_response_include_pattern + self.apply_exceptions[frozenset([C, R, E])] = self.create_exception_condition_response_exclude_pattern + # 0 constrain + 3 effect relations (4 - 4 [all reduce to 2 effects]) = 0 + # 1 constrain + 1 effect relation (8) = 8 + self.apply_exceptions[frozenset([I, C])] = self.create_exception_condition_include_pattern + self.apply_exceptions[frozenset([E, C])] = self.create_exception_condition_exclude_pattern + self.apply_exceptions[frozenset([R, C])] = self.create_exception_condition_response_pattern + self.apply_exceptions[frozenset([C, N])] = self.create_exception_condition_no_response_pattern + self.apply_exceptions[frozenset([M, N])] = self.create_exception_milestone_no_response_pattern + self.apply_exceptions[frozenset([M, E])] = self.create_exception_milestone_exclude_pattern + self.apply_exceptions[frozenset([M, I])] = self.create_exception_milestone_include_pattern + self.apply_exceptions[frozenset([M, R])] = self.create_exception_milestone_response_pattern + # 0 constrain + 2 effect relations (6 - 2 [{R,N},{I,E}]) = 4 + self.apply_exceptions[frozenset([I, R])] = self.create_exception_response_include_pattern + self.apply_exceptions[frozenset([E, R])] = self.create_exception_response_exclude_pattern + self.apply_exceptions[frozenset([N, E])] = self.create_exception_no_response_exclude_pattern + self.apply_exceptions[frozenset([N, I])] = self.create_exception_no_response_include_pattern + # 2 constrain + 0 effect relations (1) = 1 + self.apply_exceptions[frozenset([C, M])] = self.create_exception_condition_milestone_pattern + + def filter_exceptional_cases(self, G): + G_copy = deepcopy(G) + for e in G['events']: + for e_prime in G['events']: + if e == e_prime: + # same event multiple self relations + if (e in G['responseTo'] and e_prime in G['responseTo'][e]) and ( + e in G['excludesTo'] and e_prime in G['excludesTo'][e]) and \ + (e in G['conditionsFor'] and e_prime in G['conditionsFor'][e]) and ( + e in G['milestonesFor'] and e_prime in G['milestonesFor'][e]) and \ + (e in G['includesTo'] and e_prime in G['includesTo'][e]) and ( + e in G['noResponseTo'] and e_prime in G['noResponseTo'][e]): + G['conditionsFor'][e].remove(e_prime) + G['milestonesFor'][e].remove(e_prime) + G['responseTo'][e].remove(e_prime) + G['excludesTo'][e].remove(e_prime) + G['includesTo'][e].remove(e_prime) + G['noResponseTo'][e].remove(e_prime) + self.helper_struct[e]['t_types'] = ['event'] + self.self_exceptions['responseTo'].add(e) + self.self_exceptions[frozenset(['conditionsFor', 'milestonesFor'])].add(e) + + if (e in G['responseTo'] and e_prime in G['responseTo'][e]) and ( + e in G['excludesTo'] and e_prime in G['excludesTo'][e]): + G['responseTo'][e].remove(e_prime) + G['excludesTo'][e].remove(e_prime) + self.self_exceptions[frozenset(['excludesTo', 'responseTo'])].add(e) + if (e in G['conditionsFor'] and e_prime in G['conditionsFor'][e]) and ( + e in G['milestonesFor'] and e_prime in G['milestonesFor'][e]): + G['conditionsFor'][e].remove(e_prime) + G['milestonesFor'][e].remove(e_prime) + self.helper_struct[e]['t_types'] = ['event'] + self.self_exceptions[frozenset(['conditionsFor', 'milestonesFor'])].add(e) + if (e in G['includesTo'] and e_prime in G['includesTo'][e]) and ( + e in G['excludesTo'] and e_prime in G['excludesTo'][e]): + G['excludesTo'][e].remove(e_prime) + # same event one self relation + for rel in self.all_relations: + if e in G[rel] and e_prime in G[rel][e]: + G[rel][e].remove(e_prime) + self.self_exceptions[rel].add(e) + match rel: + case 'conditionsFor': + # removes the creation of the init and initpend transitions + self.helper_struct[e]['t_types'] = ['event', 'pend'] + case 'milestonesFor': + # removes the creation of the pend and initpend transitions + self.helper_struct[e]['t_types'] = ['event', 'init'] + else: + # distinct events + for exception in self.exceptions.keys(): + has_multiple_rel = True + for rel in exception: + has_multiple_rel = has_multiple_rel and (e in G[rel] and e_prime in G[rel][e]) + if has_multiple_rel: + remove_from_g = True + if I in exception and E in exception: + G[E][e].remove(e_prime) + remove_from_g = False + if R in exception and N in exception: + G[N][e].remove(e_prime) + remove_from_g = False + if remove_from_g: + self.exceptions[exception].add((e, e_prime)) + for rel in exception: + G[rel][e].remove(e_prime) + self.G = G + return G, G_copy + + def export_debug_net(self, tapn, m, path, step, pn_export_format): + path_without_extension, extens = os.path.splitext(path) + debug_save_path = f'{path_without_extension}_{step}{extens}' + pnml_exporter.apply(tapn, m, debug_save_path, variant=pn_export_format, parameters={'isTimed': True}) + + def map_exceptional_cases_between_events(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for exception, pairs in self.exceptions.items(): + if len(pairs) > 0: + tapn = self.apply_exceptions[exception](tapn, m, tapn_path, induction_step, pn_export_format, debug) + return tapn + + def create_exception_condition_milestone_exclude_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, R, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + own_pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + own_pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if len(pend_excluded_places_e_prime)>0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_exclude_no_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, N, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if len(pend_excluded_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_include_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, R, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + own_pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + own_pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if len(pend_excluded_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_include_no_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, N, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if len(pend_excluded_places_e_prime)>0: + for pend_excl_place_e_prime,_ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([R, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + own_pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + own_pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if len(pend_excluded_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_no_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if len(pend_excluded_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + for _, (pend_place_e_prime, pend_excl_place_e_prime) in self.helper_struct[event_prime]['pending_pairs'].items(): + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_no_response_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, N, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and len(pend_excluded_places_e_prime)>0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if len(pend_places_e_prime)>0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_no_response_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, N, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if len(pend_places_e_prime)>0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_response_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, R, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + own_pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + own_pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime and len(pend_excluded_places_e_prime)>0: + for pend_excluded_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn) + + # copy 2 + if inc_place_e_prime and len(pend_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + + # copy 0 + if len(pend_excluded_places_e_prime) > 0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(own_pend_place_e_prime, t, tapn, type='inhibitor') + + for pend_excluded_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_response_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, R, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + own_pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + own_pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excluded_places_e_prime if x[1] != event] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(own_pend_excl_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + for pending_exc_other in pending_exc_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pending_exc_other, t, tapn) + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + # copy 2 + if inc_place_e_prime and own_pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(own_pend_excl_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + + # copy 0 + if own_pend_excl_place_e_prime: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(own_pend_excl_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_no_response_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C, I])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if len(pend_places_e_prime) > 0: + for pend_place_e_prime, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + # copy 2 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and len(pend_excl_places_e_prime)>0: + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if len(pend_places_e_prime) > 0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + def create_exception_condition_no_response_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C, E])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if len(pend_places_e_prime) > 0: + for pend_place_e_prime, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + # copy 2 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if len(pend_places_e_prime)>0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_response_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, R, C])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + own_pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + own_pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excl_places_e_prime if x[1] != event] + # copy 1 + if inc_place_e_prime or len(pend_places_e_prime) > 0: + for pend_place_e_prime, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + + # copy 2 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for pend_excl_place_e_prime,_ in pend_excl_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 3 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(own_pend_place_e_prime, t, tapn, type='inhibitor') + + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + if len(pend_places_e_prime) > 0: + # has to make its place pending and remove the pending from all others + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(t, own_pend_place_e_prime, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_response_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, R, C])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + own_pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + own_pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excl_places_e_prime if x[1] != event] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + for pend_place_e_prime, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + + # copy 2 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + + for pend_excl_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_e_prime, t, type='inhibitor') + + # copy 3 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(own_pend_excl_place_e_prime, t, tapn) + # copy 3X + for pend_excl_other in pending_exc_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_other, t, tapn) + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(t, own_pend_excl_place_e_prime, tapn) + + for pend_place_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, C])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime and len(pend_places_e_prime)>0: + for _, (pend_place_e_prime, pend_excl_place_e_prime) in self.helper_struct[event_prime]['pending_pairs'].items(): + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + pex_to_t = timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='transport') + t_to_p = timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn, type='transport') + pex_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime:# and len(pend_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, C])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if len(pend_places_e_prime) > 0: + for _, (pend_place_e_prime, pend_excl_place_e_prime) in self.helper_struct[event_prime]['pending_pairs'].items(): + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + pen_to_t = timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='transport') + t_to_pex = timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn, type='transport') + pen_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + t_to_pex.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + + # copy 2 + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn) + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn) + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([R, C])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excl_places_e_prime if x[1] != event] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime or len(pend_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + # has to make its place pending and remove the pending from all others + for pend_other in pending_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_other, t, tapn) + + # copy 2 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + for pend_exc_other in pending_exc_others: + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn, type='inhibitor') + for pend_exc_other in pending_exc_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn) + + # copy 3 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + for pend_other in pending_others: + timed_utils.add_arc_from_to_with_check(pend_other, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_response_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + ''' + DONE + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([I, R])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excl_places_e_prime if x[1] != event] + # copy 1 + if pend_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 1X + for pend_other in pending_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_other, t, tapn) + + # copy 2 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + for pe, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pe, t, tapn, type='inhibitor') + + # copy 3 + if pend_excl_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 3X + for pend_exc_other in pending_exc_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn) + + # copy 0 + if len(pend_places_e_prime) > 0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + for pend_other in pending_others: + timed_utils.add_arc_from_to_with_check(pend_other, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_response_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + ''' + DONE + :param tapn: + :param m: + :return: + ''' + for (event, event_prime) in self.exceptions[frozenset([E, R])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excl_places_e_prime if x[1] != event] + # copy 1 + if len(pend_places_e_prime) > 0: + for pp, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(pp, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + # copy 2 + if len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + for pend_exc_other in pending_exc_others: + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn, type='inhibitor') + for pend_exc_other in pending_exc_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn) + # copy 3 + if len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if inc_place_e_prime or len(pend_places_e_prime) > 0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_no_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, C])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if len(pend_places_e_prime)>0: + for pend_place_e_prime, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + # copy 2 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excluded_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for pend_excluded_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excluded_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_no_response_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, N])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if len(pend_places_e_prime) > 0: + for pend_place_e_prime, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 2 + if inc_place_e_prime and len(pend_excluded_places_e_prime)>0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and len(pend_excluded_places_e_prime)>0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_no_response_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, N])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and len(pend_places_e_prime)>0: + for pend_place_e_prime, _ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + # copy 2 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if inc_place_e_prime or len(pend_places_e_prime)>0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_no_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([N, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and len(pend_excluded_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime: + for pend_excl_place_e_prime, _ in pend_excluded_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if inc_place_e_prime or len(pend_places_e_prime)>0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_condition_milestone_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([C, M])]: + delay = None + if event in self.G['conditionsForDelays'] and event_prime in self.G['conditionsForDelays'][event]: + delay = self.G['conditionsForDelays'][event][event_prime] + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_exclude_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([E, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_include_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([I, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + + pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_pairs = self.helper_struct[event_prime]['pending_pairs'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excluded_places_e_prime if x[1] != event] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime and len(pend_places_e_prime) > 0 and len(pend_excluded_places_e_prime) > 0: + for _, (pp, pe) in pending_pairs.items(): + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + t_to_p = timed_utils.add_arc_from_to_with_check(t, pp, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(pe, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + # copy 2 + if inc_place_e_prime and len(pend_excluded_places_e_prime)>0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pe, _ in pend_excluded_places_e_prime: + timed_utils.add_arc_from_to_with_check(pe, t, tapn, type='inhibitor') + + # map the copy_0 last but before adding the new transitions + # copy 0 + if inc_place_e_prime: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pp, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pp, t, tapn, type='inhibitor') + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn + + def create_exception_milestone_response_pattern(self, tapn, m=None, tapn_path=None, induction_step=None, pn_export_format=None,debug=False) -> PetriNet: + for (event, event_prime) in self.exceptions[frozenset([R, M])]: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + + pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excluded_places_e_prime if x[1] != event] + pending_pairs = self.helper_struct[event_prime]['pending_pairs'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if len(pend_excluded_places_e_prime) > 0 or inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + for pend_excl_other in pending_exc_others: + timed_utils.add_arc_from_to_with_check(pend_excl_other, t, tapn, type='inhibitor') + # copy 1X + for pend_exc_other in pending_exc_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn) + + # copy 2 + if pend_excl_place_e_prime or inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if inc_place_e_prime or pend_place_e_prime: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + + for pend_other in pending_others: + timed_utils.add_arc_from_to_with_check(pend_other, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + if debug and tapn_path: + self.export_debug_net(tapn, m, tapn_path, f'{induction_step}exceptions_{event}_{event_prime}', pn_export_format) + induction_step += 1 + return tapn diff --git a/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_preoptimizer.py b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_preoptimizer.py new file mode 100644 index 0000000000..f23605321f --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_preoptimizer.py @@ -0,0 +1,76 @@ +from pm4py.objects.conversion.dcr.variants.to_petri_net_submodules.utils import Relations + +class TimedPreoptimizer(object): + need_included_place = set() + need_executed_place = set() + need_pending_place = set() + need_pending_excluded_place = set() + un_executable_events = set() + + def pre_optimize_based_on_dcr_behaviour(self, G): + + inclusion_events = set() + exclusion_events = set() + + condition_events = set() + + response_events = set() + no_response_events = set() + milestone_events = set() + + for event in G['events']: + inclusion_events = inclusion_events.union(set(G['includesTo'][event] if event in G['includesTo'] else set())) + exclusion_events = exclusion_events.union(set(G['excludesTo'][event] if event in G['excludesTo'] else set())) + + condition_events = condition_events.union(set(G['conditionsFor'][event] if event in G['conditionsFor'] else set())) + milestone_events = milestone_events.union(set(G['milestonesFor'][event] if event in G['milestonesFor'] else set())) + + response_events = response_events.union(set(G['responseTo'][event] if event in G['responseTo'] else set())) + no_response_events = no_response_events.union(set(G['noResponseTo'][event] if event in G['noResponseTo'] else set())) + + not_included_events = set(G['events']).difference(set(G['marking']['included'])) + not_pending_events = set(G['events']).difference(set(G['marking']['pending'])) + not_included_become_included = not_included_events.intersection(inclusion_events) + included_become_excluded = set(G['marking']['included']).intersection(exclusion_events) + need_included_place = not_included_become_included.union(included_become_excluded) + unexecutable_events = not_included_events.difference(inclusion_events) + + need_executed_place = set(G['marking']['executed']).union(condition_events) + need_pending_place = set(G['marking']['pending']).union(response_events).union(milestone_events).union(no_response_events) + need_pending_excluded_place = need_pending_place.intersection(need_included_place) + + self.no_init_t = set(G['marking']['pending']).difference(no_response_events) + self.no_initpend_t = not_pending_events.difference(response_events) + + self.need_included_place = need_included_place + self.need_executed_place = need_executed_place + self.need_pending_place = need_pending_place + self.need_pending_excluded_place = need_pending_excluded_place + self.un_executable_events = unexecutable_events + + def preoptimize_based_on_exceptional_cases(self,G, exceptional_cases): + self.remove_init = set() + self.remove_initpend = set() + for k, values in exceptional_cases.exceptions.items(): + for v in values: + for e in G['events']: + if Relations.C.value in k and Relations.M.value in k and e in v[1]: + if e in self.no_init_t: + self.remove_init.add(e) + if e in self.no_initpend_t: + self.remove_initpend.add(e) + + def remove_un_executable_events_from_dcr(self, G): + + for rule in ['conditionsFor', 'milestonesFor', 'responseTo', 'noResponseTo', 'includesTo', 'excludesTo']: + for re in self.un_executable_events: + G[rule].pop(re, None) + for event in G['events']: + if event not in self.un_executable_events and event in G[rule]: + G[rule][event] = G[rule][event].difference(self.un_executable_events) + + G['marking']['included'] = set(G['marking']['included']).difference(self.un_executable_events) + G['marking']['executed'] = set(G['marking']['executed']).difference(self.un_executable_events) + G['marking']['pending'] = set(G['marking']['pending']).difference(self.un_executable_events) + G['events'] = set(G['events']).difference(self.un_executable_events) + return G \ No newline at end of file diff --git a/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_single_relations.py b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_single_relations.py new file mode 100644 index 0000000000..5048057ddd --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_single_relations.py @@ -0,0 +1,386 @@ +from pm4py.objects.petri_net.obj import * + +from pm4py.objects.conversion.dcr.variants.to_timed_arc_petri_net_submodules import timed_utils + +class TimedSingleRelations(object): + + def __init__(self, helper_struct, mapping_exceptions) -> None: + self.helper_struct = helper_struct + self.mapping_exceptions = mapping_exceptions + + def create_include_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime and len(pend_places_e_prime) > 0 and len(pend_excl_places_e_prime) > 0: + for _, (pend_place_e_prime, pend_excl_place_e_prime) in self.helper_struct[event_prime]['pending_pairs'].items(): + for delta in range(len_delta): + # (exists) for each event create a transition with a transport arc link (independent of the other pending places) + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + # timed_utils.add_arc_from_to(inc_place_e_prime, t, tapn, type='inhibitor') + + pex_to_t = timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='transport') + t_to_p = timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn, type='transport') + pex_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + # copy 2 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + # timed_utils.add_arc_from_to(inc_place_e_prime, t, tapn, type='inhibitor') + # (for all) inhibitor arcs to all pending excluded places + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # map the copy_0 last but before adding the new transitions + # copy 0 + if inc_place_e_prime: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_exclude_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + #(for all) no pending event executes this transition + for pend_place_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and len(pend_places_e_prime) > 0 and len(pend_excl_places_e_prime) > 0: + for _, (pend_place_e_prime, pend_excl_place_e_prime) in self.helper_struct[event_prime]['pending_pairs'].items(): + for delta in range(len_delta): + # (for each) pairwise transport arcs for each pair of pending places + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + p_to_t = timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='transport') + t_to_pex = timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn, type='transport') + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + t_to_pex.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + + # copy 0 + if inc_place_e_prime: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_response_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + pend_excl_place_e_prime = self.helper_struct['pend_exc_matrix'][event_prime][event] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + pending_exc_others = [x[0] for x in pend_excl_places_e_prime if x[1] != event] + # copy 1 + if len(pend_places_e_prime) > 0:# and self.helper_struct[event]['firstResp']: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + for pend_other in pending_others: + # timed_utils.add_arc_from_to(t, pend_other, tapn) + timed_utils.add_arc_from_to_with_check(pend_other, t, tapn, type='inhibitor') + # timed_utils.add_arc_from_to(t, inc_place_e_prime, tapn) + # timed_utils.add_arc_from_to(inc_place_e_prime, t, tapn) + # + # timed_utils.add_arc_from_to(t, pend_place_e_prime, tapn) + # timed_utils.add_arc_from_to(pend_place_e_prime, t, tapn) + # + # # for pend_other in pending_others: + # # timed_utils.add_arc_from_to(pend_other, t, tapn, type='inhibitor') + + # copy 2 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + #if self.helper_struct[event]['firstResp']: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + for pend_exc_other in pending_exc_others: + # timed_utils.add_arc_from_to(t, pend_exc_other, tapn) + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn, type='inhibitor') + # copy 2X + for pend_exc_other in pending_exc_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + # timed_utils.add_arc_from_to(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_exc_other, t, tapn) + + # copy 3 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(t, pend_excl_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + # for pend_exc_other in pending_exc_others: + # timed_utils.add_arc_from_to(pend_exc_other,t,tapn,type='inhibitor') + + # copy 0 + if len(pend_places_e_prime) > 0: + # copy 0X + for pend_other in pending_others: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + # TODO: check if I was right in removing this + # timed_utils.add_arc_from_to(pend_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_other, t, tapn) + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, pend_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn) + + # timed_utils.add_arc_from_to(t, inc_place_e_prime, tapn) + # timed_utils.add_arc_from_to(inc_place_e_prime, t, tapn) + # + # timed_utils.add_arc_from_to(t, pend_place_e_prime, tapn) + # timed_utils.add_arc_from_to(pend_place_e_prime, t, tapn, type='inhibitor') + # for pend_other in pending_others: + # timed_utils.add_arc_from_to(t, pend_other, tapn) + # timed_utils.add_arc_from_to(pend_other, t, tapn, type='inhibitor') + + # self.helper_struct[event]['firstResp'] = False + # when here I ask: have I done the first response? + # If the answer is yes. Then + # Do not create a new transition (do not copy any past behaviour) + # Simply retrieve the transition that behaves towards the other place in that way and + # add the same behaviour towards this transition + # this applies the same way to a response or a no-response + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_no_response_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + pend_excl_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + + # pend_place_e_prime = self.helper_struct['pend_matrix'][event_prime][event] + # pending_others = [x[0] for x in pend_places_e_prime if x[1] != event] + # copy 1 + if len(pend_places_e_prime) > 0:# and self.helper_struct[event]['firstResp']: + # (for all) if included and not pending then fire + # for delta in range(len_delta): + # tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + # new_transitions.extend(ts) + # for t in ts: + # tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + # timed_utils.add_arc_from_to(t, inc_place_e_prime, tapn) + # timed_utils.add_arc_from_to(inc_place_e_prime, t, tapn) + # for pp_e_prime, _ in pend_places_e_prime: + # timed_utils.add_arc_from_to(pp_e_prime, t, tapn, type='inhibitor') + + for pp_e_prime,_ in pend_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(pp_e_prime, t, tapn) + # copy 2 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0:# and self.helper_struct[event]['firstNoResp']: + # (for all) if no pending excl place is pending and not included then it fires + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn, type='inhibitor') + + # copy 3 + if inc_place_e_prime and len(pend_excl_places_e_prime) > 0: + # (exists) for each pending excluded place if it is pending make it unpending when event is not included + for pend_excl_place_e_prime, _ in pend_excl_places_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + timed_utils.add_arc_from_to_with_check(pend_excl_place_e_prime, t, tapn) + + # copy 0 + if len(pend_places_e_prime) > 0: + # (exists) for each pending incl place we need to make the specific place unpending and inhibitor arcs to the rest + # for pend_other in pending_others: + # for delta in range(len_delta): + # tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + # new_transitions.extend(ts) + # for t in ts: + # tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta * len_internal, copy_0, t, tapn) + # timed_utils.add_arc_from_to(t, inc_place_e_prime, tapn) + # timed_utils.add_arc_from_to(inc_place_e_prime, t, tapn) + # + # timed_utils.add_arc_from_to(pend_other, t, tapn) + for t in copy_0: + # timed_utils.add_arc_from_to(t, inc_place_e_prime, tapn) + # timed_utils.add_arc_from_to(inc_place_e_prime, t, tapn) + # + # timed_utils.add_arc_from_to(pend_place_e_prime, t, tapn) + + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + for pp_e_prime, _ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pp_e_prime, t, tapn, type='inhibitor') + + # self.helper_struct[event]['firstResp'] = False + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_condition_pattern(self, event, event_prime, tapn, delay=0) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + exec_place_e_prime = self.helper_struct[event_prime]['places']['executed'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime and exec_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + if exec_place_e_prime: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + t_to_p = timed_utils.add_arc_from_to_with_check(t, exec_place_e_prime, tapn, type='transport') + p_to_t = timed_utils.add_arc_from_to_with_check(exec_place_e_prime, t, tapn, type='transport') + t_to_p.properties['transportindex'] = self.helper_struct['transport_index'] + p_to_t.properties['transportindex'] = self.helper_struct['transport_index'] + self.helper_struct['transport_index'] = self.helper_struct['transport_index'] + 1 + if delay and delay > 0: + p_to_t.properties['agemin'] = delay + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn + + def create_milestone_pattern(self, event, event_prime, tapn) -> PetriNet: + inc_place_e_prime = self.helper_struct[event_prime]['places']['included'] + pend_places_e_prime = self.helper_struct[event_prime]['places']['pending'] + # pend_excluded_places_e_prime = self.helper_struct[event_prime]['places']['pending_excluded'] + + copy_0 = self.helper_struct[event]['transitions'] + len_copy_0 = len(copy_0) + len_internal = self.helper_struct[event]['len_internal'] + len_delta = int(len_copy_0 / len_internal) + new_transitions = [] + # copy 1 + if inc_place_e_prime: + for delta in range(len_delta): + tapn, ts = timed_utils.create_event_pattern_transitions_and_arcs(tapn, event, self.helper_struct, self.mapping_exceptions) + new_transitions.extend(ts) + for t in ts: + tapn, t = timed_utils.map_existing_transitions_of_copy_0(delta*len_internal, copy_0, t, tapn) + + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn, type='inhibitor') + + # copy 0 + if len(pend_places_e_prime) > 0: + for t in copy_0: + timed_utils.add_arc_from_to_with_check(t, inc_place_e_prime, tapn) + timed_utils.add_arc_from_to_with_check(inc_place_e_prime, t, tapn) + + for pend_place_e_prime,_ in pend_places_e_prime: + timed_utils.add_arc_from_to_with_check(pend_place_e_prime, t, tapn, type='inhibitor') + + self.helper_struct[event]['transitions'].extend(new_transitions) + return tapn diff --git a/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_utils.py b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_utils.py new file mode 100644 index 0000000000..15902c3e0f --- /dev/null +++ b/pm4py/objects/conversion/dcr/variants/to_timed_arc_petri_net_submodules/timed_utils.py @@ -0,0 +1,185 @@ +from pm4py.objects.petri_net import properties +from pm4py.objects.petri_net.timed_arc_net.obj import * +from pm4py.objects.dcr.obj import TemplateRelations as Relations + +def check_arc_exists(source, target, tapn: PetriNet): + if source in tapn.arc_matrix and target in tapn.arc_matrix[source]: + return tapn.arc_matrix[source][target] + else: + return False + +def add_arc_from_to_with_check(fr, to, net: PetriNet, weight=1, type=None, with_check=False) -> PetriNet.Arc: + """ + TODO: merge add_arc_from_to into add_arc_from_to_apt + Adds an arc from a specific element to another element in some net. Assumes from and to are in the net! + + Parameters + ---------- + fr: transition/place from + to: transition/place to + net: net to use + weight: weight associated to the arc + + Returns + ------- + None + """ + a = PetriNet.Arc(fr, to, weight) + if with_check and (fr and to): + with_check = check_arc_exists(fr, to, net) + if (fr and to) and not with_check: # and not check_arc_exists(fr,to,net): + if type is not None: + a.properties[properties.ARCTYPE] = type + net.arcs.add(a) + fr.out_arcs.add(a) + to.in_arcs.add(a) + if fr not in net.arc_matrix: + net.arc_matrix[fr] = {} + net.arc_matrix[fr][to] = True + + return a + +def map_existing_transitions_of_copy_0(delta, copy_0, t, tapn) -> (TimedArcNet, TimedArcNet.Transition): + trans = copy_0[delta] + # if trans in tapn.transitions: # since this is a copy this cannot be checked here. trust me bro + # TODO: t is a new transition so, although not nice, it is safe to copy the transport index + # if this is not true than I need to update the transport index in the converter after each call of this method + in_arcs = trans.in_arcs + for arc in in_arcs: + source = arc.source + type = arc.properties['arctype'] if 'arctype' in arc.properties else None + s_to_t = add_arc_from_to_with_check(source, t, tapn, type=type, with_check=True) + s_to_t.properties['agemin'] = arc.properties['agemin'] if 'agemin' in arc.properties else 0 + s_to_t.properties['transportindex'] = arc.properties['transportindex'] if 'transportindex' in arc.properties else None + out_arcs = trans.out_arcs + for arc in out_arcs: + target = arc.target + type = arc.properties['arctype'] if 'arctype' in arc.properties else None + t_to_t = add_arc_from_to_with_check(t, target, tapn, type=type, with_check=True) + t_to_t.properties['agemin'] = arc.properties['agemin'] if 'agemin' in arc.properties else 0 + t_to_t.properties['transportindex'] = arc.properties['transportindex'] if 'transportindex' in arc.properties else None + return tapn, t + + +def create_event_pattern_transitions_and_arcs(tapn, event, helper_struct, mapping_exceptions): + inc_place = helper_struct[event]['places']['included'] + exec_place = helper_struct[event]['places']['executed'] + pend_places = helper_struct[event]['places']['pending'] + pend_exc_places = helper_struct[event]['places']['pending_excluded'] + i_copy = helper_struct[event]['trans_group_index'] + ts = [] + for t_name in set(helper_struct[event]['t_types']).intersection(set(['event','init'])): # ['event','init'] - copy arcs: + t = TimedArcNet.Transition(f'{t_name}_{event}{i_copy}', f'{t_name}_{event}{i_copy}_label') + tapn.transitions.add(t) + # this if statement handles self response exclude + if event in mapping_exceptions.self_exceptions[frozenset([Relations.E.value, Relations.R.value])]: + for pend_exc_place, _ in pend_exc_places: + add_arc_from_to_with_check(t, pend_exc_place, tapn) + + add_arc_from_to_with_check(inc_place, t, tapn) + # this if statement handles self exclude and self response exclude + if not ((event in mapping_exceptions.self_exceptions[Relations.E.value]) or ( + event in mapping_exceptions.self_exceptions[frozenset([Relations.E.value, Relations.R.value])])): + add_arc_from_to_with_check(t, inc_place, tapn) + + # this if statement handles self response + if event in mapping_exceptions.self_exceptions[Relations.R.value]: + for pend_place, _ in pend_places: + add_arc_from_to_with_check(t, pend_place, tapn) + + if t_name.__contains__('init'): + add_arc_from_to_with_check(t, exec_place, tapn) + add_arc_from_to_with_check(exec_place, t, tapn, type='inhibitor') + else: + add_arc_from_to_with_check(t, exec_place, tapn) + add_arc_from_to_with_check(exec_place, t, tapn) + + if t_name.__contains__('pend'): + for pend_place, _ in pend_places: + add_arc_from_to_with_check(pend_place, t, tapn) + else: + for pend_place, _ in pend_places: + add_arc_from_to_with_check(pend_place, t, tapn, type='inhibitor') + ts.append(t) + for t_name in set(helper_struct[event]['t_types']).intersection(set(['initpend', 'pend'])): # ['initpend','pend'] - copy transitions: + for k in range(len(pend_places)): + pend_place, e_prime = list(pend_places)[k] + name = f'{t_name}_{event}_by_{e_prime}{i_copy}' if len(e_prime) > 0 else f'{t_name}_{event}{i_copy}' + t = PetriNet.Transition(name, f'{name}_label') + tapn.transitions.add(t) + # this if statement handles self response exclude + # TODO: test this mf + if event in mapping_exceptions.self_exceptions[frozenset([Relations.E.value, Relations.R.value])]: + pend_exc_place, _ = list(pend_exc_places)[k] + add_arc_from_to_with_check(t, pend_exc_place, tapn) + + add_arc_from_to_with_check(inc_place, t, tapn) + # this if statement handles self exclude and self response exclude + if not ((event in mapping_exceptions.self_exceptions[Relations.E.value]) or ( + event in mapping_exceptions.self_exceptions[frozenset([Relations.E.value, Relations.R.value])])): + add_arc_from_to_with_check(t, inc_place, tapn) + + # this if statement handles self response + if event in mapping_exceptions.self_exceptions[Relations.R.value]: + add_arc_from_to_with_check(t, pend_place, tapn) + + if t_name.__contains__('init'): + add_arc_from_to_with_check(t, exec_place, tapn) + add_arc_from_to_with_check(exec_place, t, tapn, type='inhibitor') + else: + add_arc_from_to_with_check(t, exec_place, tapn) + add_arc_from_to_with_check(exec_place, t, tapn) + + if t_name.__contains__('pend'): + add_arc_from_to_with_check(pend_place, t, tapn) + else: + add_arc_from_to_with_check(pend_place, t, tapn, type='inhibitor') + ts.append(t) + helper_struct[event]['trans_group_index'] += 1 + return tapn, ts + + +def get_expected_places_transitions_arcs(G): + # 3^(conditions + milestones) * 2^((inc+exc)+(resp+no_resp))*2 for each event in relations + expected_transitions = 0 + # 3*no of events + expected_places = 4 * len(G['events']) + # arcs: + # - events * 12 + # - conditions * 9 + # - milestones * 8 + # - responses * 2 + # - noResponses * 2 + # - includes * 2 + # - exludes * 2 + expected_arcs = 0 + + for event in G['events']: + expected_transitions += ((3 ** (len(G['conditionsFor'][event]) if event in G['conditionsFor'] else 0 + + len(G[ + 'milestonesFor'][ + event]) if event in + G[ + 'milestonesFor'] else 0)) * + (3 ** ((len(G['includesTo'][event]) if event in G['includesTo'] else 0 + + len(G[ + 'excludesTo'][ + event]) if event in + G[ + 'excludesTo'] else 0)) * + (4 ** (len(G['responseTo'][event]) if event in G['responseTo'] else 0 + + len(G[ + 'noResponseTo'][ + event]) if event in + G[ + 'noResponseTo'] else 0)))) * 4 + + expected_arcs += 2 ^ ((3 ^ (len(set(G['includesTo'][event] if event in G['includesTo'] else set()).union( + set(G['excludesTo'][event] if event in G['excludesTo'] else set()))))) * + (4 ^ (len(set(G['responseTo'][event] if event in G['responseTo'] else set()).union( + set(G['noResponseTo'][event] if event in G['noResponseTo'] else set()))))) * + (3 ^ ((len(set(G['conditionsFor'][event])) if event in G['conditionsFor'] else 0))) * + (3 ^ ((len(set(G['milestonesFor'][event])) if event in G['milestonesFor'] else 0)))) + + expected_arcs += len(G['events']) * 24 + return expected_places, expected_transitions, expected_arcs diff --git a/pm4py/objects/dcr/__init__.py b/pm4py/objects/dcr/__init__.py new file mode 100644 index 0000000000..cc4d5a7193 --- /dev/null +++ b/pm4py/objects/dcr/__init__.py @@ -0,0 +1 @@ +from pm4py.objects.dcr import obj, semantics, distributed, exporter, importer \ No newline at end of file diff --git a/pm4py/objects/dcr/__pycache__/__init__.cpython-311.pyc b/pm4py/objects/dcr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..6c9cd2f633 Binary files /dev/null and b/pm4py/objects/dcr/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/__pycache__/obj.cpython-311.pyc b/pm4py/objects/dcr/__pycache__/obj.cpython-311.pyc new file mode 100644 index 0000000000..9c3b843458 Binary files /dev/null and b/pm4py/objects/dcr/__pycache__/obj.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/__pycache__/semantics.cpython-311.pyc b/pm4py/objects/dcr/__pycache__/semantics.cpython-311.pyc new file mode 100644 index 0000000000..c41b87a1af Binary files /dev/null and b/pm4py/objects/dcr/__pycache__/semantics.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/distributed/__init__.py b/pm4py/objects/dcr/distributed/__init__.py new file mode 100644 index 0000000000..d9a905714c --- /dev/null +++ b/pm4py/objects/dcr/distributed/__init__.py @@ -0,0 +1 @@ +from pm4py.objects.dcr.distributed import obj \ No newline at end of file diff --git a/pm4py/objects/dcr/distributed/obj.py b/pm4py/objects/dcr/distributed/obj.py new file mode 100644 index 0000000000..80980b95fa --- /dev/null +++ b/pm4py/objects/dcr/distributed/obj.py @@ -0,0 +1,128 @@ +from typing import Set +from pm4py.objects.dcr.obj import DcrGraph + + +class DistributedDcrGraph(DcrGraph): + """ + A class representing a Role-based DCR graph. + + This class wraps around a DCR graph structure, extending it with role-based features such as principals, + distributed, role assignments, and principals assignments. It provides an interface to integrate distributed into the + DCR model and to compute role-based constraints as part of the graph. + Attributes derived according to dcr graphs with distributed in [1]_. + + References + ---------- + .. [1] Thomas T. Hildebrandt and Raghava Rao Mukkamala, "Declarative Event-BasedWorkflow as Distributed Dynamic Condition Response Graphs", + Electronic Proceedings in Theoretical Computer Science — 2011, Volume 69, 59–73. `DOI <10.4204/EPTCS.69.5>`_. + + Parameters + ---------- + g : DCRGraph + The underlying DCR graph structure. + template : dict, optional + A template dictionary to initialize the distributed and assignments from, if provided. + + Attributes + ---------- + + self.__g : DCRGraph + The underlying DCR graph structure. + self.__principals : Set[str] + A set of principal identifiers within the graph. + self.__roles : Set[str] + A set of role identifiers within the graph. + self.__roleAssignments : Dict[str, Set[str]] + A dictionary where keys are activity identifiers and values are sets of distributed assigned to those activities. + self.__principalsAssignment : Dict[str, Set[str]] + A dictionary where keys are activity identifiers and values are sets of principals assigned to those activities. + + Methods + ------- + getConstraints() -> int: + Computes the total number of constraints in the DCR graph, including those derived from role assignments. + + Examples + -------- + dcr_graph = DCRGraph(...)\n + role_graph = RoleDCR_Graph(dcr_graph, template={\n + "principals": {"principal1", "principal2"},\n + "roles": {"role1", "role2"},\n + "roleAssignments": {"activity1": {"role1"}},\n + "principalsAssignments": {"activity1": {"principal1"}}\n + })\n + + \nAccess role-based attributes\n + principals = role_graph.principals\n + roles = role_graph.distributed\n + role_assignments = role_graph.roleAssignments\n + principals_assignment = role_graph.principalsAssignment\n + + \nCompute the number of constraints\n + total_constraints = role_graph.getConstraints()\n + + """ + def __init__(self, template=None): + super().__init__(template) + self.__principals = set() if template is None else template.pop("principals", set()) + self.__roles = set() if template is None else template.pop("roles", set()) + self.__roleAssignments = {} if template is None else template.pop("roleAssignments", set()) + self.__principalsAssignments = {} if template is None else template.pop("principalsAssignments", set()) + + def obj_to_template(self): + res = super().obj_to_template() + res['principals'] = self.__principals + res['roles'] = self.__roles + res['roleAssignments'] = self.__roleAssignments + res['principalsAssignment'] = self.__principalsAssignments + return res + + @property + def principals(self) -> Set[str]: + return self.__principals + + @property + def roles(self): + return self.__roles + + @property + def role_assignments(self): + return self.__roleAssignments + + @property + def principals_assignments(self): + return self.__principalsAssignments + + def get_constraints(self): + """ + compute role assignments as constraints in DCR Graph + and the constraints in the underlying graph + + Returns + ------- + int + number of constraints in dcr graph + """ + no = super().get_constraints() + for i in self.__roleAssignments.values(): + no += len(i) + return no + + def __repr__(self): + string = str(super()) + for key, value in vars(self).items(): + if value is super(): + continue + string += str(key.split("_")[-1])+": "+str(value)+"\n" + return string + + def __getattr__(self, name): + return getattr(super(), name) + + def __getitem__(self, item): + if hasattr(super(), item): + return super().__getitem__(item) + for key, value in vars(self).items(): + if item == key.split("_")[-1]: + return value + return set() diff --git a/pm4py/objects/dcr/distributed/semantics.py b/pm4py/objects/dcr/distributed/semantics.py new file mode 100644 index 0000000000..068a11142e --- /dev/null +++ b/pm4py/objects/dcr/distributed/semantics.py @@ -0,0 +1 @@ +# TODO: semantics based on distributed \ No newline at end of file diff --git a/pm4py/objects/dcr/exporter/__init__.py b/pm4py/objects/dcr/exporter/__init__.py new file mode 100644 index 0000000000..9bf2b0ed43 --- /dev/null +++ b/pm4py/objects/dcr/exporter/__init__.py @@ -0,0 +1 @@ +from pm4py.objects.dcr.exporter import exporter, variants \ No newline at end of file diff --git a/pm4py/objects/dcr/exporter/__pycache__/__init__.cpython-311.pyc b/pm4py/objects/dcr/exporter/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..541cdfe53e Binary files /dev/null and b/pm4py/objects/dcr/exporter/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/exporter/__pycache__/exporter.cpython-311.pyc b/pm4py/objects/dcr/exporter/__pycache__/exporter.cpython-311.pyc new file mode 100644 index 0000000000..6293c1a6bf Binary files /dev/null and b/pm4py/objects/dcr/exporter/__pycache__/exporter.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/exporter/exporter.py b/pm4py/objects/dcr/exporter/exporter.py new file mode 100644 index 0000000000..7cd36dbd1d --- /dev/null +++ b/pm4py/objects/dcr/exporter/exporter.py @@ -0,0 +1,42 @@ +from enum import Enum +from pm4py.objects.dcr.exporter.variants import xml_dcr_portal, dcr_js_portal, xml_simple + + +class Variants(Enum): + XML_SIMPLE = xml_simple + XML_DCR_PORTAL = xml_dcr_portal + DCR_JS_PORTAL = dcr_js_portal + + +XML_SIMPLE = Variants.XML_SIMPLE +XML_DCR_PORTAL = Variants.XML_DCR_PORTAL +DCR_JS_PORTAL = Variants.DCR_JS_PORTAL + +VERSIONS = {XML_SIMPLE, XML_DCR_PORTAL, DCR_JS_PORTAL} + + +def apply(dcr_graph, path, variant=XML_SIMPLE, **parameters): + """ + Writes a DCR graph object to file. + + Parameters + ----------- + dcr_graph + DCR graph object + path + Path to the file + variant + Variant of the exporter to use: + - XML_SIMPLE + - XML_DCR_PORTAL + - DCR_JS_PORTAL + parameters + Algorithm related params + white_space_replacement: a character + """ + if variant is Variants.XML_DCR_PORTAL: + xml_dcr_portal.export_dcr_xml(dcr_graph, output_file_name=path, **parameters) + elif variant is Variants.XML_SIMPLE: + xml_simple.export_dcr_xml(dcr_graph, output_file_name=path, **parameters) + elif variant is Variants.DCR_JS_PORTAL: + dcr_js_portal.export_dcr_xml(dcr_graph, output_file_name=path, **parameters) diff --git a/pm4py/objects/dcr/exporter/variants/__init__.py b/pm4py/objects/dcr/exporter/variants/__init__.py new file mode 100644 index 0000000000..0b0df173f8 --- /dev/null +++ b/pm4py/objects/dcr/exporter/variants/__init__.py @@ -0,0 +1 @@ +from pm4py.objects.dcr.exporter.variants import xml_simple, xml_dcr_portal, dcr_js_portal \ No newline at end of file diff --git a/pm4py/objects/dcr/exporter/variants/__pycache__/__init__.cpython-311.pyc b/pm4py/objects/dcr/exporter/variants/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..8141bc0e5a Binary files /dev/null and b/pm4py/objects/dcr/exporter/variants/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/exporter/variants/__pycache__/dcr_js_portal.cpython-311.pyc b/pm4py/objects/dcr/exporter/variants/__pycache__/dcr_js_portal.cpython-311.pyc new file mode 100644 index 0000000000..19f043de47 Binary files /dev/null and b/pm4py/objects/dcr/exporter/variants/__pycache__/dcr_js_portal.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/exporter/variants/__pycache__/xml_dcr_portal.cpython-311.pyc b/pm4py/objects/dcr/exporter/variants/__pycache__/xml_dcr_portal.cpython-311.pyc new file mode 100644 index 0000000000..d122a07972 Binary files /dev/null and b/pm4py/objects/dcr/exporter/variants/__pycache__/xml_dcr_portal.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/exporter/variants/__pycache__/xml_simple.cpython-311.pyc b/pm4py/objects/dcr/exporter/variants/__pycache__/xml_simple.cpython-311.pyc new file mode 100644 index 0000000000..811c1204fe Binary files /dev/null and b/pm4py/objects/dcr/exporter/variants/__pycache__/xml_simple.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/exporter/variants/dcr_js_portal.py b/pm4py/objects/dcr/exporter/variants/dcr_js_portal.py new file mode 100644 index 0000000000..1b916d9a54 --- /dev/null +++ b/pm4py/objects/dcr/exporter/variants/dcr_js_portal.py @@ -0,0 +1,209 @@ +from lxml import etree + +from pm4py.objects.dcr.utils.utils import clean_input + + +def export_dcr_xml(graph, output_file_name, dcr_title='DCR from pm4py', replace_whitespace=' '): + ''' + Writes a DCR graph object to disk in the ``.xml`` file format (exported as ``.xml`` file). + The file is to be visualised using the following link: https://hugoalopez-dtu.github.io/dcr-js/ + Tamo et al. "An Open-Source Modeling Editor for Declarative Process Models" https://ceur-ws.org/Vol-3552/paper-5.pdf + Parameters + ----------- + dcr + the DCR graph + output_file_name + dcrxml file name + dcr_title + title of the DCR graph + replace_whitespace + replace any white space characters with a character of your choice + ''' + graph = clean_input(graph, white_space_replacement=replace_whitespace, all=True) + # event_labels = list(graph.label_map.keys()) + # event_ids = [] + # for event in list(graph.label_map.values()): + # for event_id in event: + # event_ids.append(event_id) + + root = etree.Element("dcrgraph") + if dcr_title: + root.set("title", dcr_title) + specification = etree.SubElement(root, "specification") + resources = etree.SubElement(specification, "resources") + events = etree.SubElement(resources, "events") + subprocesses = etree.SubElement(resources, "subProcesses") + labels = etree.SubElement(resources, "labels") + labelMappings = etree.SubElement(resources, "labelMappings") + + constraints = etree.SubElement(specification, "constraints") + conditions = etree.SubElement(constraints, "conditions") + responses = etree.SubElement(constraints, "responses") + excludes = etree.SubElement(constraints, "excludes") + includes = etree.SubElement(constraints, "includes") + + runtime = etree.SubElement(root, "runtime") + marking = etree.SubElement(runtime, "marking") + executed = etree.SubElement(marking, "executed") + included = etree.SubElement(marking, "included") + pendingResponse = etree.SubElement(marking, "pendingResponses") + + # Each event's coordinates for visualisation + xcoord = {} + ycoord = {} + x = 0 + y = 0 + for event in graph.events: + xcoord[event] = x + ycoord[event] = y + x += 300 + + if x > 1200: + x = 0 + y += 300 + + for event in graph.events: + xml_event = etree.SubElement(events, "event") + xml_event.set("id", event) + xml_event_custom = etree.SubElement(xml_event, "custom") + xml_visual = etree.SubElement(xml_event_custom, "visualization") + xml_location = etree.SubElement(xml_visual, "location") + xml_location.set("xLoc", str(xcoord[event])) + xml_location.set("yLoc", str(ycoord[event])) + xml_size = etree.SubElement(xml_visual, "size") + xml_size.set("width", "130") + xml_size.set("height", "150") + xml_label = etree.SubElement(labels, "label") + xml_label.set("id", event) + xml_labelMapping = etree.SubElement(labelMappings, "labelMapping") + xml_labelMapping.set("eventId", event) + # label_id = event_labels[event_ids.index(event)] + label_id = graph.label_map[event] if event in graph.label_map else event + xml_labelMapping.set("labelId", label_id) + + for event_prime in graph.events: + if event_prime in graph.conditions and event in graph.conditions[event_prime]: + xml_condition = etree.SubElement(conditions, "condition") + xml_condition.set("sourceId", event) + xml_condition.set("targetId", event_prime) + xml_condition_custom = etree.SubElement(xml_condition, "custom") + xml_waypoints = etree.SubElement(xml_condition_custom, "waypoints") + create_arrows(xml_waypoints, xcoord,ycoord, event, event_prime) + xml_custom_id = etree.SubElement(xml_condition_custom, "id") + xml_custom_id.set("id", "Relation_" + event + "_" + event_prime + "_condition") + if event in graph.responses and event_prime in graph.responses[event]: + xml_response = etree.SubElement(responses, "response") + xml_response.set("sourceId", event) + xml_response.set("targetId", event_prime) + xml_response_custom = etree.SubElement(xml_response, "custom") + xml_waypoints = etree.SubElement(xml_response_custom, "waypoints") + create_arrows(xml_waypoints, xcoord, ycoord, event, event_prime) + xml_custom_id = etree.SubElement(xml_response_custom, "id") + xml_custom_id.set("id", "Relation_" + event + "_" + event_prime + "_response") + if event in graph.includes and event_prime in graph.includes[event]: + xml_include = etree.SubElement(includes, "include") + xml_include.set("sourceId", event) + xml_include.set("targetId", event_prime) + xml_include_custom = etree.SubElement(xml_include, "custom") + xml_waypoints = etree.SubElement(xml_include_custom, "waypoints") + create_arrows(xml_waypoints, xcoord, ycoord, event, event_prime) + xml_custom_id = etree.SubElement(xml_include_custom, "id") + xml_custom_id.set("id", "Relation_" + event + "_" + event_prime + "_include") + if event in graph.excludes and event_prime in graph.excludes[event]: + xml_exclude = etree.SubElement(excludes, "exclude") + xml_exclude.set("sourceId", event) + xml_exclude.set("targetId", event_prime) + xml_exclude_custom = etree.SubElement(xml_exclude, "custom") + xml_waypoints = etree.SubElement(xml_exclude_custom, "waypoints") + + # Creates a self-exclude arrow to avoid having just the arrowhead sitting at the centre of the event + if event == event_prime: + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str(xcoord[event]+65)) + xml_waypoint.set("y", str(ycoord[event]+150)) + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str(xcoord[event]+65)) + xml_waypoint.set("y", str(ycoord[event]+175)) + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str(xcoord[event]-25)) + xml_waypoint.set("y", str(ycoord[event]+175)) + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str(xcoord[event]-25)) + xml_waypoint.set("y", str(ycoord[event]+75)) + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str(xcoord[event])) + xml_waypoint.set("y", str(ycoord[event]+75)) + else: + create_arrows(xml_waypoints, xcoord, ycoord, event, event_prime) + xml_custom_id = etree.SubElement(xml_exclude_custom, "id") + xml_custom_id.set("id", "Relation_" + event + "_" + event_prime + "_exclude") + + if event in graph.marking.executed: + marking_exec = etree.SubElement(executed, "event") + marking_exec.set("id", event) + if event in graph.marking.included: + marking_incl = etree.SubElement(included, "event") + marking_incl.set("id", event) + if event in graph.marking.pending: + marking_pend = etree.SubElement(pendingResponse, "event") + marking_pend.set("id", event) + + tree = etree.ElementTree(root) + tree.write(output_file_name, pretty_print=True, xml_declaration=True, encoding="utf-8", standalone="yes") + + +def create_arrows(xml_waypoints, xcoord, ycoord, event, event_prime): + # Helper function that connects two events with corresponding constraint arrow + if xcoord[event] < xcoord[event_prime] and ycoord[event] < ycoord[event_prime]: + xoffset = 130 + xprimeoffset = 0 + yoffset = 75 + yprimeoffset = 75 + elif xcoord[event] < xcoord[event_prime] and ycoord[event] > ycoord[event_prime]: + xoffset = 130 + xprimeoffset = 0 + yoffset = 75 + yprimeoffset = 75 + elif xcoord[event] > xcoord[event_prime] and ycoord[event] < ycoord[event_prime]: + xoffset = 0 + xprimeoffset = 130 + yoffset = 75 + yprimeoffset = 75 + elif xcoord[event] > xcoord[event_prime] and ycoord[event] > ycoord[event_prime]: + xoffset = 0 + xprimeoffset = 130 + yoffset = 75 + yprimeoffset = 75 + elif xcoord[event] == xcoord[event_prime] and ycoord[event] < ycoord[event_prime]: + xoffset = 65 + xprimeoffset = 65 + yoffset = 150 + yprimeoffset = 0 + elif xcoord[event] == xcoord[event_prime] and ycoord[event] > ycoord[event_prime]: + xoffset = 65 + xprimeoffset = 65 + yoffset = 0 + yprimeoffset = 150 + elif xcoord[event] < xcoord[event_prime] and ycoord[event] == ycoord[event_prime]: + xoffset = 130 + xprimeoffset = 0 + yoffset = 75 + yprimeoffset = 75 + elif xcoord[event] > xcoord[event_prime] and ycoord[event] == ycoord[event_prime]: + xoffset = 0 + xprimeoffset = 130 + yoffset = 75 + yprimeoffset = 75 + + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str(xcoord[event]+xoffset)) + xml_waypoint.set("y", str(ycoord[event]+yoffset)) + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str((xcoord[event]+xoffset+xcoord[event_prime]+xprimeoffset)/2)) + xml_waypoint.set("y", str(ycoord[event]+yoffset)) + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str((xcoord[event]+xoffset+xcoord[event_prime]+xprimeoffset)/2)) + xml_waypoint.set("y", str(ycoord[event_prime]+yprimeoffset)) + xml_waypoint = etree.SubElement(xml_waypoints, "waypoint") + xml_waypoint.set("x", str(xcoord[event_prime]+xprimeoffset)) + xml_waypoint.set("y", str(ycoord[event_prime]+yprimeoffset)) diff --git a/pm4py/objects/dcr/exporter/variants/xml_dcr_portal.py b/pm4py/objects/dcr/exporter/variants/xml_dcr_portal.py new file mode 100644 index 0000000000..5e6c1510d3 --- /dev/null +++ b/pm4py/objects/dcr/exporter/variants/xml_dcr_portal.py @@ -0,0 +1,78 @@ +from lxml import etree + +from pm4py.objects.dcr.obj import DcrGraph + + +def export_dcr_xml(graph:DcrGraph, output_file_name, dcr_title='DCR from pm4py',**parameters): + ''' + Writes a DCR graph object to disk in the ``.xml`` file format (exported as ``.xml`` file). + Marquard et al. "Web-Based Modelling and Collaborative Simulation of Declarative Processes" https://doi.org/10.1007/978-3-319-23063-4_15 + Parameters + ----------- + dcr + the DCR graph + output_file_name + dcrxml file name + dcr_title + title of the DCR graph + ''' + root = etree.Element("dcrgraph") + if dcr_title: + root.set("title", dcr_title) + specification = etree.SubElement(root, "specification") + resources = etree.SubElement(specification, "resources") + events = etree.SubElement(resources, "events") + labels = etree.SubElement(resources, "labels") + labelMappings = etree.SubElement(resources, "labelMappings") + + constraints = etree.SubElement(specification, "constraints") + conditions = etree.SubElement(constraints, "conditions") + responses = etree.SubElement(constraints, "responses") + excludes = etree.SubElement(constraints, "excludes") + includes = etree.SubElement(constraints, "includes") + + runtime = etree.SubElement(root, "runtime") + marking = etree.SubElement(runtime, "marking") + executed = etree.SubElement(marking, "executed") + included = etree.SubElement(marking, "included") + pendingResponse = etree.SubElement(marking, "pendingResponses") + + for event in graph.events: + xml_event = etree.SubElement(events, "event") + xml_event.set("id", event) + xml_label = etree.SubElement(labels, "label") + xml_label.set("id", event) + xml_labelMapping = etree.SubElement(labelMappings, "labelMapping") + xml_labelMapping.set("eventId", event) + xml_labelMapping.set("labelId", event) + + for event_prime in graph.events: + if event in graph.conditions and event_prime in graph.conditions[event]: + xml_condition = etree.SubElement(conditions, "condition") + xml_condition.set("sourceId", event_prime) + xml_condition.set("targetId", event) + if event in graph.responses and event_prime in graph.responses[event]: + xml_response = etree.SubElement(responses, "response") + xml_response.set("sourceId", event) + xml_response.set("targetId", event_prime) + if event in graph.includes and event_prime in graph.includes[event]: + xml_include = etree.SubElement(includes, "include") + xml_include.set("sourceId", event) + xml_include.set("targetId", event_prime) + if event in graph.excludes and event_prime in graph.excludes[event]: + xml_exclude = etree.SubElement(excludes, "exclude") + xml_exclude.set("sourceId", event) + xml_exclude.set("targetId", event_prime) + # TODO: allow for more advanced graphs than just the core ones + if event in graph.marking.executed: + marking_exec = etree.SubElement(executed, "event") + marking_exec.set("id", event) + if event in graph.marking.included: + marking_incl = etree.SubElement(included, "event") + marking_incl.set("id", event) + if event in graph.marking.pending: + marking_pend = etree.SubElement(pendingResponse, "event") + marking_pend.set("id", event) + + tree = etree.ElementTree(root) + tree.write(output_file_name, pretty_print=True) diff --git a/pm4py/objects/dcr/exporter/variants/xml_simple.py b/pm4py/objects/dcr/exporter/variants/xml_simple.py new file mode 100644 index 0000000000..f3b54f79d8 --- /dev/null +++ b/pm4py/objects/dcr/exporter/variants/xml_simple.py @@ -0,0 +1,172 @@ +from lxml import etree + +from pm4py.objects.dcr.obj import DcrGraph +from pm4py.objects.dcr.timed.obj import TimedDcrGraph + + +def export_dcr_graph(graph : DcrGraph, root, parents_dict=None, replace_whitespace=' ', time_precision='H'): + ''' + + Parameters + ---------- + dcr + root + parents_dict + replace_whitespace + time_precision: valid values are D H M S + + Returns + ------- + + ''' + for event in graph.events: + xml_event = etree.SubElement(root, "events") + xml_event_id = etree.SubElement(xml_event, "id") + xml_event_id.text = event.replace(' ', replace_whitespace) + xml_event_label = etree.SubElement(xml_event, "label") + xml_event_label.text = event.replace(' ', replace_whitespace) + if parents_dict and event in parents_dict: + xml_event_parent = etree.SubElement(xml_event, "parent") + xml_event_parent.text = parents_dict[event].replace(' ', replace_whitespace) + + for event_prime in graph.events: + if event in graph.conditions and event_prime in graph.conditions[event]: + xml_condition = etree.SubElement(root, "rules") + xml_type = etree.SubElement(xml_condition, "type") + xml_type.text = "condition" + xml_source = etree.SubElement(xml_condition, "source") + xml_source.text = event_prime.replace(' ', replace_whitespace) + xml_target = etree.SubElement(xml_condition, "target") + xml_target.text = event.replace(' ', replace_whitespace) + if hasattr(graph, 'timedconditions') and event in graph.timedconditions and event_prime in graph.timedconditions[event]: + time = graph.timedconditions[event][event_prime] + if time.floor(freq='S').to_numpy() > 0: + xml_target = etree.SubElement(xml_condition, "duration") + iso_time = time.floor(freq='S').isoformat() + if time_precision: + iso_time = iso_time.split(time_precision)[0] + time_precision + xml_target.text = iso_time + if event in graph.responses and event_prime in graph.responses[event]: + xml_response = etree.SubElement(root, "rules") + xml_type = etree.SubElement(xml_response, "type") + xml_type.text = "response" + xml_source = etree.SubElement(xml_response, "source") + xml_source.text = event.replace(' ', replace_whitespace) + xml_target = etree.SubElement(xml_response, "target") + xml_target.text = event_prime.replace(' ', replace_whitespace) + if hasattr(graph, 'timedresponses') and event in graph.timedresponses and event_prime in graph.timedresponses[event]: + time = graph.timedresponses[event][event_prime] + if time.floor(freq='S').to_numpy() > 0: + xml_target = etree.SubElement(xml_response, "duration") + iso_time = time.floor(freq='S').isoformat() + if time_precision: + iso_time = iso_time.split(time_precision)[0] + time_precision + xml_target.text = iso_time + if event in graph.includes and event_prime in graph.includes[event]: + xml_include = etree.SubElement(root, "rules") + xml_type = etree.SubElement(xml_include, "type") + xml_type.text = "include" + xml_source = etree.SubElement(xml_include, "source") + xml_source.text = event.replace(' ', replace_whitespace) + xml_target = etree.SubElement(xml_include, "target") + xml_target.text = event_prime.replace(' ', replace_whitespace) + if event in graph.excludes and event_prime in graph.excludes[event]: + xml_exclude = etree.SubElement(root, "rules") + xml_type = etree.SubElement(xml_exclude, "type") + xml_type.text = "exclude" + xml_source = etree.SubElement(xml_exclude, "source") + xml_source.text = event.replace(' ', replace_whitespace) + xml_target = etree.SubElement(xml_exclude, "target") + xml_target.text = event_prime.replace(' ', replace_whitespace) + if hasattr(graph, 'milestones') and event in graph.milestones and event_prime in graph.milestones[event]: + xml_exclude = etree.SubElement(root, "rules") + xml_type = etree.SubElement(xml_exclude, "type") + xml_type.text = "milestone" + xml_source = etree.SubElement(xml_exclude, "source") + xml_source.text = event.replace(' ', replace_whitespace) + xml_target = etree.SubElement(xml_exclude, "target") + xml_target.text = event_prime.replace(' ', replace_whitespace) + if hasattr(graph, 'noresponses') and event in graph.noresponses and event_prime in graph.noresponses[event]: + xml_exclude = etree.SubElement(root, "rules") + xml_type = etree.SubElement(xml_exclude, "type") + xml_type.text = "coresponse" + xml_source = etree.SubElement(xml_exclude, "source") + xml_source.text = event.replace(' ', replace_whitespace) + xml_target = etree.SubElement(xml_exclude, "target") + xml_target.text = event_prime.replace(' ', replace_whitespace) + + # TODO: export the marking with XML simple + # if event in dcr['marking']['executed']: + # marking_exec = etree.SubElement(executed, "event") + # marking_exec.set("id", event) + # if event in dcr['marking']['included']: + # marking_incl = etree.SubElement(included, "event") + # marking_incl.set("id", event) + # if event in dcr['marking']['pending']: + # marking_pend = etree.SubElement(pendingResponse,"event") + # marking_pend.set("id",event) + + +def export_dcr_xml(graph: DcrGraph, output_file_name, dcr_title='DCR from pm4py', dcr_description=None, replace_whitespace=' '): + ''' + Writes a DCR graph object to disk in the ``.xml`` file format (exported as ``.xml`` file). + The file can be imported and visualised in the DCR solutions portal (https://dcrgraphs.net/) + + Parameters + ----------- + dcr + the DCR graph + output_file_name + dcrxml file name + dcr_title + title of the DCR graph + dcr_description + description of the DCR graph + replace_whitespace + a character to replace white space + ''' + root = etree.Element("DCRModel") + if dcr_title: + title = etree.SubElement(root, "title") + title.text = dcr_title + if dcr_description: + desc = etree.SubElement(root, "description") + desc.text = dcr_description + graph_type = etree.SubElement(root, "graphType") + graph_type.text = "DCRModel" + # this needs to exist so it can be imported inside dcr graphs with the app + role = etree.SubElement(root, "roles") + role_title = etree.SubElement(role, "title") + role_title.text = "User" + role_description = etree.SubElement(role, "description") + role_description.text = "Dummy user" + parents_dict = {} + if hasattr(graph, 'subprocesses'): + for sp_name, sp_events in graph.subprocesses.items(): + xml_event = etree.SubElement(root, "events") + xml_event_id = etree.SubElement(xml_event, "id") + xml_event_id.text = sp_name + xml_event_label = etree.SubElement(xml_event, "label") + xml_event_label.text = sp_name + xml_event_type = etree.SubElement(xml_event, "type") + xml_event_type.text = "subprocess" + for sp_event in sp_events: + parents_dict[sp_event] = sp_name + if hasattr(graph, 'nestedgroups'): + for n_name, n_events in graph.nestedgroups.items(): + xml_event = etree.SubElement(root, "events") + xml_event_id = etree.SubElement(xml_event, "id") + xml_event_id.text = n_name + xml_event_label = etree.SubElement(xml_event, "label") + xml_event_label.text = n_name + xml_event_type = etree.SubElement(xml_event, "type") + xml_event_type.text = "nesting" + for n_event in n_events: + parents_dict[n_event] = n_name + if len(parents_dict) > 0: + export_dcr_graph(graph, root, parents_dict, replace_whitespace=replace_whitespace) + else: + export_dcr_graph(graph, root, None, replace_whitespace=replace_whitespace) + + tree = etree.ElementTree(root) + tree.write(output_file_name, pretty_print=True) \ No newline at end of file diff --git a/pm4py/objects/dcr/extended/__init__.py b/pm4py/objects/dcr/extended/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/dcr/extended/obj.py b/pm4py/objects/dcr/extended/obj.py new file mode 100644 index 0000000000..6458775b33 --- /dev/null +++ b/pm4py/objects/dcr/extended/obj.py @@ -0,0 +1,76 @@ +""" +This module extends the RoleDcrGraph class to include support for milestone and +no-response relations within Dynamic Condition Response (DCR) Graphs. + +The module adds functionality to handle milestone and no-response constraints, +allowing for more expressive process models with additional types of relations +between events. + +Classes: + MilestoneNoResponseDcrGraph: Extends RoleDcrGraph to include milestone and no-response relations. + +This class provides methods to manage and manipulate milestone and no-response +relations within a DCR Graph, enhancing the model's ability to represent complex +process behaviors and dependencies. + +References +---------- +.. [1] Hildebrandt, T., Mukkamala, R.R., Slaats, T. (2012). Nested Dynamic Condition Response Graphs. In: Arbab, F., Sirjani, M. (eds) Fundamentals of Software Engineering. FSEN 2011. Lecture Notes in Computer Science, vol 7141. Springer, Berlin, Heidelberg. `DOI `_. + +.. [2] Hildebrandt, T.T., Normann, H., Marquard, M., Debois, S., Slaats, T. (2022). Decision Modelling in Timed Dynamic Condition Response Graphs with Data. In: Marrella, A., Weber, B. (eds) Business Process Management Workshops. BPM 2021. Lecture Notes in Business Information Processing, vol 436. Springer, Cham. `DOI `_. +""" +from typing import Dict, Set + +from pm4py.objects.dcr.distributed.obj import DistributedDcrGraph + + +class ExtendedDcrGraph(DistributedDcrGraph): + """ + This class extends the RoleDcrGraph to include milestone and no-response + relations, allowing for more expressive DCR Graphs with additional constraints. + + + Attributes + ---------- + self.__milestonesFor: Dict[str, Set[str]] + A dictionary mapping events to sets of their milestone events. + self.__noResponseTo: Dict[str, Set[str]] + A dictionary mapping events to sets of their no-response events. + + Methods + ------- + obj_to_template(self) -> dict: + Converts the object to a template dictionary, including milestone and no-response relations. + get_constraints(self) -> int: + Computes the total number of constraints in the DCR Graph, including milestone and no-response relations. + """ + def __init__(self, template=None): + super().__init__(template) + self.__milestonesFor = {} if template is None else template['milestonesFor'] + self.__noResponseTo = {} if template is None else template['noResponseTo'] + + def obj_to_template(self): + res = super().obj_to_template() + res['milestonesFor'] = self.__milestonesFor + res['noResponseTo'] = self.__noResponseTo + return res + + @property + def milestones(self) -> Dict[str, Set[str]]: + return self.__milestonesFor + + @property + def noresponses(self) -> Dict[str, Set[str]]: + return self.__noResponseTo + + def get_constraints(self) -> int: + no = super().get_constraints() + for i in self.__milestonesFor.values(): + no += len(i) + for i in self.__noResponseTo.values(): + no += len(i) + return no + + def __eq__(self, other): + return super().__eq__(other) and self.milestones == other.milestones and self.noresponses == other.noresponses + diff --git a/pm4py/objects/dcr/extended/semantics.py b/pm4py/objects/dcr/extended/semantics.py new file mode 100644 index 0000000000..2779a3ecb3 --- /dev/null +++ b/pm4py/objects/dcr/extended/semantics.py @@ -0,0 +1,25 @@ +from typing import Set + +from pm4py.objects.dcr.semantics import DcrSemantics + + +class ExtendedSemantics(DcrSemantics): + + @classmethod + def enabled(cls, graph) -> Set[str]: + res = super().enabled(graph) + for e in set(graph.milestones.keys()).intersection(res): + if len(graph.milestones[e].intersection( + graph.marking.included.intersection(graph.marking.pending))) > 0: + res.discard(e) + return res + + @classmethod + def weak_execute(cls, event, graph): + if event in graph.noresponses: + for e_prime in graph.noresponses[event]: + graph.marking.pending.discard(e_prime) + + return super().weak_execute(event, graph) + + diff --git a/pm4py/objects/dcr/hierarchical/__init__.py b/pm4py/objects/dcr/hierarchical/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/dcr/hierarchical/obj.py b/pm4py/objects/dcr/hierarchical/obj.py new file mode 100644 index 0000000000..35b79ddd5a --- /dev/null +++ b/pm4py/objects/dcr/hierarchical/obj.py @@ -0,0 +1,85 @@ +""" +This module extends the MilestoneNoResponseDcrGraph class to include support for +nested groups and subprocesses within Dynamic Condition Response (DCR) Graphs. + +The module adds functionality to handle hierarchical structures in DCR Graphs, +allowing for more complex process models with nested elements and subprocesses. + +Classes: + NestingSubprocessDcrGraph: Extends MilestoneNoResponseDcrGraph to include nested groups and subprocesses. + +This class provides methods to manage and manipulate nested groups and subprocesses +within a DCR Graph, enhancing the model's ability to represent complex organizational +structures and process hierarchies. + +References +---------- +.. [1] Hildebrandt, T., Mukkamala, R.R., Slaats, T. (2012). Nested Dynamic Condition Response Graphs. In: Arbab, F., Sirjani, M. (eds) Fundamentals of Software Engineering. FSEN 2011. Lecture Notes in Computer Science, vol 7141. Springer, Berlin, Heidelberg. `DOI `_. + +.. [2] Normann, H., Debois, S., Slaats, T., Hildebrandt, T.T. (2021). Zoom and Enhance: Action Refinement via Subprocesses in Timed Declarative Processes. In: Polyvyanyy, A., Wynn, M.T., Van Looy, A., Reichert, M. (eds) Business Process Management. BPM 2021. Lecture Notes in Computer Science(), vol 12875. Springer, Cham. `DOI `_. +""" +from pm4py.objects.dcr.extended.obj import ExtendedDcrGraph +from typing import Set, Dict + + +class HierarchicalDcrGraph(ExtendedDcrGraph): + """ + This class extends the MilestoneNoResponseDcrGraph to include nested groups + and subprocesses, allowing for more complex hierarchical structures in DCR Graphs. + + Attributes + ---------- + self.__nestedgroups: Dict[str, Set[str]] + A dictionary mapping group names to sets of event IDs within each group. + self.__subprocesses: Dict[str, Set[str]] + A dictionary mapping subprocess names to sets of event IDs within each subprocess. + self.__nestedgroups_map: Dict[str, str] + A dictionary mapping event IDs to their corresponding group names. + + Methods + ------- + obj_to_template(self) -> dict: + Converts the object to a template dictionary, including nested groups and subprocesses. + + """ + def __init__(self, template=None): + super().__init__(template) + self.__nestedgroups = {} if template is None else template['nestedgroups'] + self.__subprocesses = {} if template is None else template['subprocesses'] + self.__nestedgroups_map = {} if template is None else template['nestedgroupsMap'] + if len(self.__nestedgroups_map) == 0 and len(self.__nestedgroups) > 0: + self.__nestedgroups_map = {} + for group, events in self.__nestedgroups.items(): + for e in events: + self.__nestedgroups_map[e] = group + + def obj_to_template(self): + res = super().obj_to_template() + res['nestedgroups'] = self.__nestedgroups + res['subprocesses'] = self.__subprocesses + res['nestedgroupsMap'] = self.__nestedgroups_map + return res + + @property + def nestedgroups(self) -> Dict[str, Set[str]]: + return self.__nestedgroups + + @nestedgroups.setter + def nestedgroups(self, ng): + self.__nestedgroups = ng + + @property + def nestedgroups_map(self) -> Dict[str, str]: + return self.__nestedgroups_map + + @nestedgroups_map.setter + def nestedgroups_map(self, ngm): + self.__nestedgroups_map = ngm + + @property + def subprocesses(self) -> Dict[str, Set[str]]: + return self.__subprocesses + + @subprocesses.setter + def subprocesses(self, sps): + self.__subprocesses = sps diff --git a/pm4py/objects/dcr/importer/__init__.py b/pm4py/objects/dcr/importer/__init__.py new file mode 100644 index 0000000000..6fce6738bd --- /dev/null +++ b/pm4py/objects/dcr/importer/__init__.py @@ -0,0 +1 @@ +from pm4py.objects.dcr.importer import importer, variants \ No newline at end of file diff --git a/pm4py/objects/dcr/importer/__pycache__/__init__.cpython-311.pyc b/pm4py/objects/dcr/importer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..f4610cebe2 Binary files /dev/null and b/pm4py/objects/dcr/importer/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/importer/__pycache__/importer.cpython-311.pyc b/pm4py/objects/dcr/importer/__pycache__/importer.cpython-311.pyc new file mode 100644 index 0000000000..7c3da9b0c6 Binary files /dev/null and b/pm4py/objects/dcr/importer/__pycache__/importer.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/importer/importer.py b/pm4py/objects/dcr/importer/importer.py new file mode 100644 index 0000000000..f9f14d0722 --- /dev/null +++ b/pm4py/objects/dcr/importer/importer.py @@ -0,0 +1,43 @@ +from enum import Enum + +from pm4py.objects.dcr.importer.variants import xml_dcr_portal, xml_simple +from pm4py.util import exec_utils + + +class Variants(Enum): + XML_DCR_PORTAL = xml_dcr_portal + XML_SIMPLE = xml_simple + DCR_JS_PORTAL = xml_dcr_portal + + +XML_SIMPLE = Variants.XML_SIMPLE +XML_DCR_PORTAL = Variants.XML_DCR_PORTAL +DCR_JS_PORTAL = Variants.DCR_JS_PORTAL + + +def apply(path, variant=XML_DCR_PORTAL, parameters=None): + ''' + Reads a DCR Graph from an XML file + + Parameters + ---------- + path + Path to the XML file + variant + Variants of the importer to use: + - Variants.XML_DCR_PORTAL + - Variants.XML_SIMPLE + parameters + Parameters of the importer + ''' + if parameters is None: + parameters = {} + + return exec_utils.get_variant(variant).apply(path, parameters=parameters) + + +def deserialize(dcr_string, variant=XML_DCR_PORTAL, parameters=None): + if parameters is None: + parameters = {} + + return exec_utils.get_variant(variant).import_from_string(dcr_string, parameters=parameters) diff --git a/pm4py/objects/dcr/importer/variants/__init__.py b/pm4py/objects/dcr/importer/variants/__init__.py new file mode 100644 index 0000000000..4ff8c0e6c9 --- /dev/null +++ b/pm4py/objects/dcr/importer/variants/__init__.py @@ -0,0 +1 @@ +from pm4py.objects.dcr.importer.variants import xml_dcr_portal, xml_simple diff --git a/pm4py/objects/dcr/importer/variants/__pycache__/__init__.cpython-311.pyc b/pm4py/objects/dcr/importer/variants/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000..c120cae251 Binary files /dev/null and b/pm4py/objects/dcr/importer/variants/__pycache__/__init__.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/importer/variants/__pycache__/xml_dcr_portal.cpython-311.pyc b/pm4py/objects/dcr/importer/variants/__pycache__/xml_dcr_portal.cpython-311.pyc new file mode 100644 index 0000000000..6cfdf91bcc Binary files /dev/null and b/pm4py/objects/dcr/importer/variants/__pycache__/xml_dcr_portal.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/importer/variants/__pycache__/xml_simple.cpython-311.pyc b/pm4py/objects/dcr/importer/variants/__pycache__/xml_simple.cpython-311.pyc new file mode 100644 index 0000000000..3c2e1b5fea Binary files /dev/null and b/pm4py/objects/dcr/importer/variants/__pycache__/xml_simple.cpython-311.pyc differ diff --git a/pm4py/objects/dcr/importer/variants/xml_dcr_portal.py b/pm4py/objects/dcr/importer/variants/xml_dcr_portal.py new file mode 100644 index 0000000000..ff92bc885f --- /dev/null +++ b/pm4py/objects/dcr/importer/variants/xml_dcr_portal.py @@ -0,0 +1,226 @@ +import copy + +import isodate + +from pm4py.util import constants +from copy import deepcopy +from pm4py.objects.dcr.obj import Relations, dcr_template +from pm4py.objects.dcr.utils.utils import cast_to_dcr_object, clean_input, clean_input_as_dict + +I = Relations.I.value +E = Relations.E.value +R = Relations.R.value +N = Relations.N.value +C = Relations.C.value +M = Relations.M.value + + +def apply(path, parameters=None): + ''' + Reads a DCR graph from an XML file + Marquard et al. "Web-Based Modelling and Collaborative Simulation of Declarative Processes" https://doi.org/10.1007/978-3-319-23063-4_15 + Parameters + ---------- + path + Path to the XML file + parameters + Params + Returns + ------- + dcr + DCR graph object + ''' + if parameters is None: + parameters = {} + + from lxml import etree, objectify + + parser = etree.XMLParser(remove_comments=True) + xml_tree = objectify.parse(path, parser=parser) + + return import_xml_tree_from_root(xml_tree.getroot(), **parameters) + + +def import_xml_tree_from_root(root, white_space_replacement=' ', as_dcr_object=True, labels_as_ids=True): + dcr = copy.deepcopy(dcr_template) + dcr = __parse_element__(root, None, dcr) + dcr = clean_input_as_dict(dcr, white_space_replacement=white_space_replacement) + + if labels_as_ids: + from pm4py.objects.dcr.utils.utils import map_labels_to_events + dcr = map_labels_to_events(dcr) + ''' + Transform the dictionary into a DCRGraph object + ''' + if as_dcr_object: + return cast_to_dcr_object(dcr) + else: + return dcr + + +def import_from_string(dcr_string, parameters=None): + if parameters is None: + parameters = {} + + if type(dcr_string) is str: + dcr_string = dcr_string.encode(constants.DEFAULT_ENCODING) + + from lxml import etree, objectify + + parser = etree.XMLParser(remove_comments=True) + root = objectify.fromstring(dcr_string, parser=parser) + + return import_xml_tree_from_root(root) + + +def __parse_element__(curr_el, parent, dcr): + # Create the DCR graph + tag = curr_el.tag.lower() + match tag: + case 'event': + id = curr_el.get('id') + if id: + dcr['events'].add(id) + event_type = curr_el.get('type') + match event_type: + case 'subprocess': + dcr['subprocesses'][id] = set() + case 'nesting': + dcr['nestedgroups'][id] = set() + pass + case _: + pass + match parent.get('type'): + case 'subprocess': + dcr['subprocesses'][parent.get('id')].add(id) + case 'nesting': + dcr['nestedgroups'][parent.get('id')].add(id) + pass + case _: + pass + match parent.tag: + case 'included' | 'executed': + dcr['marking'][parent.tag].add(id) + case 'pendingResponses': + dcr['marking']['pending'].add(id) + case _: + pass + for role in curr_el.findall('.//role'): + if role.text: + if role.text not in dcr['roleAssignments']: + dcr['roleAssignments'][role.text] = set([id]) + else: + dcr['roleAssignments'][role.text].add(id) + for role in curr_el.findall('.//readRole'): + if role.text: + if role.text not in dcr['readRoleAssignments']: + dcr['readRoleAssignments'][role.text] = set([id]) + else: + dcr['readRoleAssignments'][role.text].add(id) + case 'label': + id = curr_el.get('id') + dcr['labels'].add(id) + case 'labelmapping': + eventId = curr_el.get('eventId') + labelId = curr_el.get('labelId') + if eventId not in dcr['labelMapping']: + dcr['labelMapping'][eventId] = labelId + # dcr['labelMapping'][eventId] = set() + # dcr['labelMapping'][eventId].add(labelId) + case 'condition': + event = curr_el.get('sourceId') + event_prime = curr_el.get('targetId') + filter_level = curr_el.get('filterLevel') + iso_description = curr_el.get('description') # might have an ISO format duration + description = None + if iso_description: + description = iso_description.strip() # might have an ISO format duration + delay = curr_el.get('time') + groups = curr_el.get('groups') + if not dcr['conditionsFor'].__contains__(event_prime): + dcr['conditionsFor'][event_prime] = set() + dcr['conditionsFor'][event_prime].add(event) + + if delay: + if not dcr['conditionsForDelays'].__contains__(event_prime): + dcr['conditionsForDelays'][event_prime] = {} + if delay.isdecimal(): + delay = int(delay) + else: + delay = isodate.parse_duration(delay) + dcr['conditionsForDelays'][event_prime][event] = delay + + case 'response': + event = curr_el.get('sourceId') + event_prime = curr_el.get('targetId') + filter_level = curr_el.get('filterLevel') + iso_description = curr_el.get('description') # might have an ISO format duration + description = None + if iso_description: + description = iso_description.strip() # might have an ISO format duration + deadline = curr_el.get('time') + groups = curr_el.get('groups') + if not dcr['responseTo'].__contains__(event): + dcr['responseTo'][event] = set() + dcr['responseTo'][event].add(event_prime) + + if deadline: + if not dcr['responseToDeadlines'].__contains__(event): + dcr['responseToDeadlines'][event] = {} + if deadline.isdecimal(): + deadline = int(deadline) + else: + deadline = isodate.parse_duration(deadline) + dcr['responseToDeadlines'][event][event_prime] = deadline + case 'role': + if curr_el.text: + dcr['roles'].add(curr_el.text) + if curr_el.text not in dcr['roleAssignments']: + dcr['roleAssignments'][curr_el.text] = set() + if curr_el.text not in dcr['readRoleAssignments']: + dcr['readRoleAssignments'][curr_el.text] = set() + case 'include' | 'exclude': + event = curr_el.get('sourceId') + event_prime = curr_el.get('targetId') + filter_level = curr_el.get('filterLevel') + iso_description = curr_el.get('description') # might have an ISO format duration + description = None + if iso_description: + description = iso_description.strip() # might have an ISO format duration + deadline = curr_el.get('time') + groups = curr_el.get('groups') + if not dcr[f'{tag}sTo'].__contains__(event): + dcr[f'{tag}sTo'][event] = set() + dcr[f'{tag}sTo'][event].add(event_prime) + case 'coresponse' | 'noresponse': + event = curr_el.get('sourceId') + event_prime = curr_el.get('targetId') + filter_level = curr_el.get('filterLevel') + iso_description = curr_el.get('description') # might have an ISO format duration + description = None + if iso_description: + description = iso_description.strip() # might have an ISO format duration + deadline = curr_el.get('time') + groups = curr_el.get('groups') + if not dcr[f'noResponseTo'].__contains__(event): + dcr[f'noResponseTo'][event] = set() + dcr[f'noResponseTo'][event].add(event_prime) + case 'milestone': + event = curr_el.get('sourceId') + event_prime = curr_el.get('targetId') + filter_level = curr_el.get('filterLevel') + iso_description = curr_el.get('description') # might have an ISO format duration + description = None + if iso_description: + description = iso_description.strip() # might have an ISO format duration + deadline = curr_el.get('time') + groups = curr_el.get('groups') + if not dcr[f'{tag}sFor'].__contains__(event_prime): + dcr[f'{tag}sFor'][event_prime] = set() + dcr[f'{tag}sFor'][event_prime].add(event) + case _: + pass + for child in curr_el: + dcr = __parse_element__(child, curr_el, dcr) + + return dcr diff --git a/pm4py/objects/dcr/importer/variants/xml_simple.py b/pm4py/objects/dcr/importer/variants/xml_simple.py new file mode 100644 index 0000000000..060e1a49e4 --- /dev/null +++ b/pm4py/objects/dcr/importer/variants/xml_simple.py @@ -0,0 +1,148 @@ +import copy + +from datetime import timedelta +import isodate +from pandas import Timedelta + +from pm4py.objects.dcr.extended.obj import ExtendedDcrGraph +from pm4py.objects.dcr.timed.obj import TimedDcrGraph +from pm4py.util import constants +from copy import deepcopy +from pm4py.objects.dcr.obj import Relations, dcr_template, DcrGraph + +I = Relations.I.value +E = Relations.E.value +R = Relations.R.value +N = Relations.N.value +C = Relations.C.value +M = Relations.M.value + + +def apply(path, parameters=None): + ''' + Reads a DCR Graph from an XML file + + Parameters + ---------- + path + Path to the XML file + + Returns + ------- + DCR_Graph + DCR Graph object + ''' + if parameters is None: + parameters = {} + + from lxml import etree, objectify + + parser = etree.XMLParser(remove_comments=True) + xml_tree = objectify.parse(path, parser=parser) + + return import_xml_tree_from_root(xml_tree.getroot()) + + +def import_xml_tree_from_root(root, replace_whitespace=' ', **kwargs): + ''' + Transform the dictionary into a DCR_Graph object + ''' + + dcr = copy.deepcopy(dcr_template) + for event_elem in root.findall('.//events'): + event_id = event_elem.find('id').text.replace(' ', replace_whitespace) + label = event_elem.find('label').text.replace(' ', replace_whitespace) + dcr['events'].add(event_id) + dcr['marking']['included'].add(event_id) + dcr['labelMapping'][event_id] = label + dcr['labels'].add(label) + + for rule_elem in root.findall('.//rules'): + rule_type = rule_elem.find('type').text + source = rule_elem.find('source').text.replace(' ', replace_whitespace) + target = rule_elem.find('target').text.replace(' ', replace_whitespace) + + if rule_type == 'condition': + if 'conditionsFor' not in dcr: + dcr['conditionsFor'] = {} + if target not in dcr['conditionsFor']: + dcr['conditionsFor'][target] = set() + dcr['conditionsFor'][target].add(source) + + # Handle duration + duration_elem = rule_elem.find('duration') + if duration_elem is not None: + duration = timedelta(seconds=float(duration_elem.text)) + if 'conditionsForDelays' not in dcr: + dcr['conditionsForDelays'] = {} + if target not in dcr['conditionsForDelays']: + dcr['conditionsForDelays'][target] = {} + dcr['conditionsForDelays'][target][source] = duration + + elif rule_type == 'response': + if 'responseTo' not in dcr: + dcr['responseTo'] = {} + if source not in dcr['responseTo']: + dcr['responseTo'][source] = set() + dcr['responseTo'][source].add(target) + + # Handle duration + duration_elem = rule_elem.find('duration') + if duration_elem is not None: + duration = timedelta(seconds=float(duration_elem.text)) + if 'responseToDeadlines' not in dcr: + dcr['responseToDeadlines'] = {} + if source not in dcr['responseToDeadlines']: + dcr['responseToDeadlines'][source] = {} + dcr['responseToDeadlines'][source][target] = duration + + elif rule_type == 'include': + if 'includesTo' not in dcr: + dcr['includesTo'] = {} + if source not in dcr['includesTo']: + dcr['includesTo'][source] = set() + dcr['includesTo'][source].add(target) + + elif rule_type == 'exclude': + if 'excludesTo' not in dcr: + dcr['excludesTo'] = {} + if source not in dcr['excludesTo']: + dcr['excludesTo'][source] = set() + dcr['excludesTo'][source].add(target) + + elif rule_type == 'milestone': + if 'milestonesFor' not in dcr: + dcr['milestonesFor'] = {} + if target not in dcr['milestonesFor']: + dcr['milestonesFor'][target] = set() + dcr['milestonesFor'][target].add(source) + + elif rule_type == 'coresponse': + if 'noResponseTo' not in dcr: + dcr['noResponseTo'] = {} + if source not in dcr['noResponseTo']: + dcr['noResponseTo'][source] = set() + dcr['noResponseTo'][source].add(target) + + if len(dcr['noResponseTo'])>0 or len(dcr['milestonesFor'])>0: + graph = ExtendedDcrGraph(dcr) + elif len(dcr['responseToDeadlines'])>0 or len(dcr['conditionsForDelays'])>0: + graph = TimedDcrGraph(dcr) + else: + graph = DcrGraph(dcr) + return graph + + +def import_from_string(dcr_string, parameters=None): + if parameters is None: + parameters = {} + + if type(dcr_string) is str: + dcr_string = dcr_string.encode(constants.DEFAULT_ENCODING) + + from lxml import etree, objectify + + parser = etree.XMLParser(remove_comments=True) + root = objectify.fromstring(dcr_string, parser=parser) + + return import_xml_tree_from_root(root) diff --git a/pm4py/objects/dcr/obj.py b/pm4py/objects/dcr/obj.py new file mode 100644 index 0000000000..e6e8970fe8 --- /dev/null +++ b/pm4py/objects/dcr/obj.py @@ -0,0 +1,384 @@ +""" +This module defines the core components for modelling Declarative Process Models as +Dynamic Condition Response (DCR) Graphs. + +The module encapsulates the essential elements of DCR Graphs, such as events, +relations, markings, and constraints, providing a foundational framework for +working with DCR Graphs within PM4Py. + +Classes: + Relations: An enumeration of possible relations between events in a DCR Graph. + Marking: Represents the state of events in terms of executed, included, and pending. + DCR_Graph: Encapsulates the structure and behavior of a DCR Graph, offering methods to query and manipulate it. + +The `dcr_template` dictionary provides a blueprint for initializing new DCR Graphs with default settings. +""" +from copy import deepcopy +from enum import Enum +from typing import Set, Dict + + +class Relations(Enum): + I = 'includes' + E = 'excludes' + R = 'responses' + N = 'noresponses' + C = 'conditions' + M = 'milestones' + + +class TemplateRelations(Enum): + I = 'includesTo' + E = 'excludesTo' + R = 'responseTo' + N = 'noResponseTo' + C = 'conditionsFor' + M = 'milestonesFor' + + +dcr_template = { + 'events': set(), + 'conditionsFor': {}, + 'milestonesFor': {}, + 'responseTo': {}, + 'noResponseTo': {}, + 'includesTo': {}, + 'excludesTo': {}, + 'marking': {'executed': set(), + 'included': set(), + 'pending': set(), + 'executedTime': {}, # Gives the time since a event was executed + 'pendingDeadline': {} # The deadline until an event must be executed + }, + 'conditionsForDelays': {}, + 'responseToDeadlines': {}, + 'subprocesses': {}, + 'nestedgroups': {}, + 'nestedgroupsMap': {}, + 'labels': set(), + 'labelMapping': {}, + 'roles': set(), + 'principals': set(), + 'roleAssignments': {}, + 'readRoleAssignments': {}, + 'principalsAssignments': {} +} + +class Marking: + """ + This class contains the set of all markings M(G), in which it contains three sets: + M(G) = executed x included x pending + + Attributes + ---------- + self.__executed: Set[str] + The set of executed events + self.__included: Set[str] + The set of included events + self.__pending: Set[str] + the set of pending events + + Methods + -------- + reset(self, initial_marking) -> None: + Given the initial marking of the DCR Graph, reset the marking, to restart execution of traces + + + """ + def __init__(self, executed, included, pending) -> None: + self.__executed = executed + self.__included = included + self.__pending = pending + + # getters and setters for datamanipulation, mainly used for DCR semantics + @property + def executed(self): + return self.__executed + + @executed.setter + def executed(self, value): + self.__executed = value + + @property + def included(self): + return self.__included + + @included.setter + def included(self, value): + self.__included = value + + @property + def pending(self): + return self.__pending + + @pending.setter + def pending(self, value): + self.__pending = value + + def reset(self, initial_marking) -> None: + """ + Resets the marking of a DCR graph, uses the graphs event to reset included marking + + Parameters + ---------- + initial_marking + the events in the DCR Graphs + + """ + self.__executed = set(initial_marking['executed']) + self.__included = set(initial_marking['included']) + self.__pending = set(initial_marking['pending']) + + # built-in functions for printing a visual string representation + def __str__(self) -> str: + return self.__repr__() + + def __repr__(self): + return f'{{executed: {self.__executed}, included: {self.__included}, pending: {self.__pending}}}' + + def __getitem__(self, item): + for key, value in vars(self).items(): + if item == key.split("_")[-1]: + return value + + def __setitem__(self, item, value): + for key, _ in vars(self).items(): + if item == key.split("_")[-1]: + setattr(self, key, value) + + def __lt__(self, other): + return str(self) < str(other) + + +class DcrGraph(object): + """ + The DCR Structure was implemented according to definition 3 in [1]_. + Follows the idea of DCR graph as a set of tuples + G = (E,Act,M,->*,*->,->{+,-},l) + G graphs consist of a tuple of the events the activities, + the marking of executed, included and pending events, all the relations, and the mapping of events to activities. + + References + ---------- + .. [1] Thomas T. Hildebrandt and Raghava Rao Mukkamala, "Declarative Event-BasedWorkflow as Distributed Dynamic Condition Response Graphs", + Electronic Proceedings in Theoretical Computer Science — 2011, Volume 69, 59–73. `DOI <10.4204/EPTCS.69.5>`_. + + Attributes + ---------- + self.__events: Set[str] + The set of all events in graph + self.__marking: Marking + the marking of the DCR graph loaded in + self.__labels: Set[str] + The set of activities in Graphs + self.__labelMapping: Dict[str, Set[str]]: + The set of event and their corresponding activity + self.__condiditionsFor: Dict[str, Set[str]]: + attribute containing all the conditions relation between events + self.__responseTo: Dict[str, Set[str]]: + attribute containing all the response relation between events + self.__includesTo: Dict[str, Set[str]]: + attribute containing all the include relations between events + self.__excludesTo: Dict[str, Set[str]]: + attribute containing all the exclude relations between events + + Methods + -------- + getEvent(activity) -> str: + returns the event of the associated activity + getActivity(event) -> str: + returns the activity of the given event + getConstraints() -> int: + returns the size of the model based on number of constraints + + Parameters + ---------- + template : dict, optional + A template dictionary to initialize the distributed and assignments from, if provided. + + Examples + -------- + call this module and call the following + graph = DCR_graph(dcr_template) + + Notes + ------- + * DCR graph can not be initialized with a partially created template, use DCR_template for easy instantiation + """ + + # initiate the objects: contains events ID, activity, the 4 relations, markings, distributed and principals + def __init__(self, template=None): + # DisCoveR uses bijective labelling, each event has one label + # + self.__events = set() if template is None else template['events'] + self.__marking = Marking(set(), set(), set()) if template is None else ( + Marking(template['marking']['executed'], template['marking']['included'], template['marking']['pending'])) + self.__labels = set() if template is None else template['labels'] + self.__conditionsFor = {} if template is None else template['conditionsFor'] + self.__responseTo = {} if template is None else template['responseTo'] + self.__includesTo = {} if template is None else template['includesTo'] + self.__excludesTo = {} if template is None else template['excludesTo'] + self.__labelMap = {} if template is None else template['labelMapping'] + + def obj_to_template(self): + res = deepcopy(dcr_template) + res['events'] = self.__events + res['marking']['executed'] = self.__marking.executed + res['marking']['included'] = self.__marking.included + res['marking']['pending'] = self.__marking.pending + res['labels'] = self.__labels + res['conditionsFor'] = self.__conditionsFor + res['responseTo'] = self.__responseTo + res['includesTo'] = self.__includesTo + res['excludesTo'] = self.__excludesTo + res['labelMapping'] = self.__labelMap + return res + + # @property functions to extract values used for data manipulation and testing + @property + def events(self) -> Set[str]: + return self.__events + + @events.setter + def events(self, value: Set[str]): + self.__events = value + + @property + def marking(self) -> Marking: + return self.__marking + + @marking.setter + def marking(self, value: Marking) -> None: + self.__marking = value + + @property + def labels(self) -> Set[str]: + return self.__labels + + @labels.setter + def labels(self, value: Set[str]): + self.__labels = value + + @property + def conditions(self) -> Dict[str, Set[str]]: + return self.__conditionsFor + + @conditions.setter + def conditions(self, value: Dict[str, Set[str]]): + self.__conditionsFor = value + @property + def responses(self) -> Dict[str, Set[str]]: + return self.__responseTo + + @responses.setter + def responses(self, value: Dict[str, Set[str]]): + self.__responseTo = value + @property + def includes(self) -> Dict[str, Set[str]]: + return self.__includesTo + + @includes.setter + def includes(self, value): + self.__includesTo = value + + @property + def excludes(self) -> Dict[str, Set[str]]: + return self.__excludesTo + + @excludes.setter + def excludes(self, value: Dict[str, Set[str]]): + self.__excludesTo = value + @property + # def label_map(self) -> Dict[str, Set[str]]: + def label_map(self) -> Dict[str, str]: + return self.__labelMap + + @label_map.setter + # def label_map(self, value: Dict[str, Set[str]]): + def label_map(self, value: Dict[str, str]): + self.__labelMap = value + + def get_event(self, activity: str) -> str: + """ + Get the event ID of an activity from graph. + + Parameters + ---------- + activity + the activity of an event + + Returns + ------- + event + the event ID of activity + """ + for event, label in self.label_map.items(): + if activity == label: + return event + + def get_activity(self, event: str) -> str: + """ + get the activity of an Event + + Parameters + ---------- + event + event ID + + Returns + ------- + activity + the activity of the event + """ + return self.label_map[event] + + def get_constraints(self) -> int: + """ + compute constraints in DCR Graph + - conditions + - responses + - includes + - excludes + + Returns + ------- + no + number of constraints + """ + no = 0 + for i in self.__conditionsFor.values(): + no += len(i) + for i in self.__responseTo.values(): + no += len(i) + for i in self.__excludesTo.values(): + no += len(i) + for i in self.__includesTo.values(): + no += len(i) + return no + + def __repr__(self): + string = "" + for key, value in vars(self).items(): + string += str(key.split("_")[-1])+": "+str(value)+"\n" + return string + + def __str__(self): + return self.__repr__() + + def __eq__(self, other): + return self.conditions == other.conditions and self.responses == other.responses and self.includes == other.includes and self.excludes == other.excludes + + def __lt__(self, other): + return str(self.obj) < str(other.obj) + + def __getitem__(self, item): + for key, value in vars(self).items(): + if item == key.split("_")[-1]: + return value + return set() + + def __setitem__(self, item, value): + for key,_ in vars(self).items(): + if item == key.split("_")[-1]: + setattr(self, key, value) + diff --git a/pm4py/objects/dcr/semantics.py b/pm4py/objects/dcr/semantics.py new file mode 100644 index 0000000000..d66b5801d8 --- /dev/null +++ b/pm4py/objects/dcr/semantics.py @@ -0,0 +1,114 @@ +from typing import Set + +from pm4py.objects.dcr.obj import DcrGraph + +""" +We will implement the semantics according to the papers given in: +DCR 2011, and +Efficient optimal alignment between dynamic condition response graphs and traces +Following the schematic as the pm4py, by using definition function and no class function for this +""" + + +class DcrSemantics(object): + """ + the semantics functions implemented is based on the paper by: + + Author: Thomas T. Hildebrandt and Raghava Rao Mukkamala, + Title: Declarative Event-BasedWorkflow as Distributed Dynamic Condition Response Graphs + publisher: Electronic Proceedings in Theoretical Computer Science. EPTCS, Open Publishing Association, 2010, pp. 59–73. doi: 10.4204/EPTCS.69.5. + """ + @classmethod + def is_enabled(cls, event, graph: DcrGraph) -> bool: + """ + Verify that the given event is enabled for execution in the DCR graph + + Parameters + ---------- + :param event: the instance of event being check for if enabled + :param graph: DCR graph that it check for being enabled + + Returns + ------- + :return: true if enabled, false otherwise + """ + # check if event is enabled, calls function that returns a graph, of enabled events + return event in cls.enabled(graph) + + @classmethod + def enabled(cls, graph: DcrGraph) -> Set[str]: + """ + Creates a list of enabled events, based on included events and conditions constraints met + + Parameters + ---------- + :param graph: takes the current state of the DCR + + Returns + ------- + :param res: set of enabled activities + """ + # can be extended to check for milestones + res = set(graph.marking.included) + for e in set(graph.conditions.keys()).intersection(res): + if len(graph.conditions[e].intersection(graph.marking.included.difference( + graph.marking.executed))) > 0: + res.discard(e) + return res + + @classmethod + def execute(cls, graph: DcrGraph, event): + """ + Function based on semantics of execution a DCR graph + will update the graph according to relations of the executed activity + + can extend to allow of execution of milestone activity + + Parameters + ---------- + :param graph: DCR graph + :param event: the event being executed + + Returns + --------- + :return: DCR graph with updated marking + """ + # each event is called for execution is called + if event in graph.marking.pending: + graph.marking.pending.discard(event) + graph.marking.executed.add(event) + + # the following if statements are used to provide to update DCR graph + # depending on prime event structure within conditions relations + if event in graph.excludes: + for e_prime in graph.excludes[event]: + graph.marking.included.discard(e_prime) + + if event in graph.includes: + for e_prime in graph.includes[event]: + graph.marking.included.add(e_prime) + + if event in graph.responses: + for e_prime in graph.responses[event]: + graph.marking.pending.add(e_prime) + + return graph + + @classmethod + def is_accepting(cls, graph: DcrGraph) -> bool: + """ + Checks if the graph is accepting, no included events are pending + + Parameters + ---------- + :param graph: DCR Graph + + Returns + --------- + :return: True if graph is accepting, false otherwise + """ + res = graph.marking.pending.intersection(graph.marking.included) + if len(res) > 0: + return False + else: + return True \ No newline at end of file diff --git a/pm4py/objects/dcr/timed/__init__.py b/pm4py/objects/dcr/timed/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/dcr/timed/obj.py b/pm4py/objects/dcr/timed/obj.py new file mode 100644 index 0000000000..691b6e404b --- /dev/null +++ b/pm4py/objects/dcr/timed/obj.py @@ -0,0 +1,126 @@ +""" +This module extends the Dynamic Condition Response (DCR) Graph framework to +include timed constraints and behaviors. It builds upon the NestingSubprocessDcrGraph +class to incorporate time-based elements into the DCR Graph model. + +The module introduces timing aspects to both the marking of events and the +relations between events, allowing for more sophisticated process models that +can represent time-dependent behaviors and constraints. + +Classes: + TimedMarking: Extends the basic Marking class to include timing information. + TimedDcrGraph: Extends NestingSubprocessDcrGraph to incorporate timed conditions and responses. + +This module enhances the DCR Graph model with the ability to represent and +manage time-based constraints, enabling more accurate modelling of real-world +processes where timing plays a crucial role. + +References +---------- +.. [1] Hildebrandt, T., Mukkamala, R.R., Slaats, T., Zanitti, F. (2013). Contracts for cross-organizational workflows as timed Dynamic Condition Response Graphs. The Journal of Logic and Algebraic Programming, 82(5-7), 164-185. `DOI `_. +""" +from datetime import timedelta + +from pm4py.objects.dcr.obj import Marking +from pm4py.objects.dcr.hierarchical.obj import HierarchicalDcrGraph + +from typing import Dict + + +class TimedMarking(Marking): + """ + This class extends the basic Marking class to include timing information + for executed events and pending deadlines. + + Attributes + ---------- + self.__executed_time: Dict[str, datetime] + A dictionary mapping events to their execution times. + self.__pending_deadline: Dict[str, datetime] + A dictionary mapping events to their pending deadlines. + + Methods + ------- + No additional methods are explicitly defined in this class. + """ + def __init__(self, executed, included, pending, executed_time=None, pending_deadline=None) -> None: + super().__init__(executed, included, pending) + self.__executed_time = {} if executed_time is None else executed_time + self.__pending_deadline = {} if pending_deadline is None else pending_deadline + + @property + def executed_time(self): + return self.__executed_time + + @property + def pending_deadline(self): + return self.__pending_deadline + + +class TimedDcrGraph(HierarchicalDcrGraph): + """ + This class extends the NestingSubprocessDcrGraph to incorporate timed + conditions and responses, allowing for time-based constraints in DCR Graphs. + + Attributes + ---------- + self.__marking: TimedMarking + The marking of the DCR graph, including timing information. + self.__timedconditions: Dict[str, Dict[str, timedelta]] + A nested dictionary mapping events to their timed conditions. + self.__timedresponses: Dict[str, Dict[str, timedelta]] + A nested dictionary mapping events to their timed responses. + + Methods + ------- + timed_dict_to_graph(self, timing_dict: Dict) -> None: + Converts a timing dictionary to graph format, populating timed conditions and responses. + obj_to_template(self) -> dict: + Converts the object to a template dictionary, including timed conditions and responses. + """ + def __init__(self, template=None, timing_dict=None): + super().__init__(template) + self.__marking = TimedMarking(set(), set(), set()) if template is None else ( + TimedMarking(template['marking']['executed'], template['marking']['included'], template['marking']['pending'], + template['marking']['executedTime'], template['marking']['pendingDeadline'])) + self.__timedconditions = {} if template is None else template['conditionsForDelays'] + self.__timedresponses = {} if template is None else template['responseToDeadlines'] + if timing_dict is not None: + self.timed_dict_to_graph(timing_dict) + + def timed_dict_to_graph(self, timing_dict): + for timing, value in timing_dict.items(): + if timing[0] == 'CONDITION': + e1 = timing[2] + e2 = timing[1] + if e1 not in self.__timedconditions: + self.__timedconditions[e1] = {} + self.__timedconditions[e1][e2] = value + elif timing[0] == 'RESPONSE': + e1 = timing[1] + e2 = timing[2] + if e1 not in self.__timedresponses: + self.__timedresponses[e1] = {} + self.__timedresponses[e1][e2] = value + + def obj_to_template(self): + res = super().obj_to_template() + res['conditionsForDelays'] = self.__timedconditions + res['responseToDeadlines'] = self.__timedresponses + return res + + @property + def timedconditions(self) -> Dict[str, Dict[str, timedelta]]: + return self.__timedconditions + + @timedconditions.setter + def timedconditions(self, value: Dict[str, Dict[str, timedelta]]): + self.__timedconditions = value + + @property + def timedresponses(self) -> Dict[str, Dict[str, timedelta]]: + return self.__timedresponses + + @timedresponses.setter + def timedresponses(self, value: Dict[str, Dict[str, timedelta]]): + self.__timedresponses = value diff --git a/pm4py/objects/dcr/timed/semantics.py b/pm4py/objects/dcr/timed/semantics.py new file mode 100644 index 0000000000..4860bd09ec --- /dev/null +++ b/pm4py/objects/dcr/timed/semantics.py @@ -0,0 +1,89 @@ +from datetime import timedelta +from typing import Set + +from pm4py.objects.dcr.extended.semantics import ExtendedSemantics + + +class TimedSemantics(ExtendedSemantics): + + def __init__(self, graph): + self.__can_execute_time = self.create_can_execute_time_dict(graph) + + @classmethod + def execute(cls, graph, event_or_tics): + if isinstance(event_or_tics, timedelta): + return cls.time_step(graph, event_or_tics) + elif isinstance(event_or_tics, int): + return cls.time_step(graph, timedelta(event_or_tics)) + elif event_or_tics in graph.events: + return super().execute(graph, event_or_tics) + else: + raise ValueError('event_or_tics must be either timedelta, int or event') + + @classmethod + def enabled(cls, graph) -> Set[str]: + res = super().enabled(graph) + for e in res: + if e in graph.timedconditions: + for (e_prime, k) in graph.timedconditions[e].items(): + if (e_prime in graph.marking.included.intersection(graph.marking.executed) and + graph.marking.executed_time[e_prime] < k): + res.discard(e) + return res + + @classmethod + def weak_execute(cls, event, graph): + graph.marking.executed_time[event] = 0 + + if event in graph.timedresponses: + for (e_prime, k) in graph.timedresponses[event].items(): + graph.marking.pending_deadline[e_prime] = k + + return super().weak_execute(event, graph) + + @classmethod + def time_step(cls, graph, tics): + deadline = cls.next_deadline(graph) + # we can only time step if no included pending event deadline is exceeded + if tics <= deadline: + for e in graph.marking.pending_deadline: + # for each existing deadline we update the deadline time until the event must be made not pending by removing tics + # Note the events here do not need to be included + # For an excluded pending event the deadline becomes 0 if the deadline is passed while its excluded. So it must be executed immediately after it has been included. + graph.marking.pending_deadline[e] = max(graph.marking.pending_deadline[e] - tics, timedelta(0)) + for e in graph.marking.executed: + # for each executed event we care about adding tics until we reach the + # maximum of all its delays so that it can fire (we stop counting the executed time afterwards) + graph.marking.executed_time[e] = min(graph.marking.executed_time[e] + tics, cls.__can_execute_time[e]) + return graph + + @staticmethod + def next_deadline(graph): + next_deadline = None + for e in graph.marking.pending_deadline: + if e in graph.marking.included: + if (next_deadline is None) or (graph.marking.pending_deadline[e] < next_deadline): + next_deadline = graph.marking.pending_deadline[e] + return next_deadline + + @staticmethod + def next_delay(graph): + next_delay = None + for e in graph.timedconditions: + for (e_prime, k) in graph.timedconditions[e].items(): + if e_prime in graph.marking.included and e_prime in graph.marking.executed: + delay = k - graph.marking.executed_time[e_prime] + if delay > timedelta(0) and (next_delay is None or delay < next_delay): + next_delay = delay + return next_delay + + @staticmethod + def create_can_execute_time_dict(graph): + d = {} + for e in graph.events: + d[e] = timedelta(0) + for e in graph.timedconditions: + for (e_prime, k) in graph.timedconditions[e].items(): + if k > d[e_prime]: + d[e_prime] = k + return d diff --git a/pm4py/objects/dcr/utils/__init__.py b/pm4py/objects/dcr/utils/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/objects/dcr/utils/utils.py b/pm4py/objects/dcr/utils/utils.py new file mode 100644 index 0000000000..21090968d4 --- /dev/null +++ b/pm4py/objects/dcr/utils/utils.py @@ -0,0 +1,303 @@ +import re + +from pandas import Timedelta + +from pm4py.objects.dcr.hierarchical.obj import HierarchicalDcrGraph +from pm4py.objects.dcr.obj import DcrGraph, TemplateRelations, Relations, dcr_template +from copy import deepcopy + +from pm4py.objects.dcr.timed.obj import TimedDcrGraph + + +def time_to_iso_string(time, time_precision='D'): + ''' + + Parameters + ---------- + time + time_precision: valid values are D H M S + + Returns + ------- + + ''' + if not isinstance(time,Timedelta): + time = Timedelta(time) + iso_time = time.floor(freq='s').isoformat() + if time_precision: + iso_time = iso_time.split(time_precision)[0] + time_precision + return iso_time + +def clean_input(graph: DcrGraph, white_space_replacement=None, all=False): + pattern = '[^0-9a-zA-Z_]+' + if white_space_replacement is None: + return graph + #white_space_replacement = ' ' + # remove all space characters and put conditions and milestones in the correct order (according to the actual arrows) + # for k, v in deepcopy(dcr).items(): + for k in [r.value for r in Relations]: + if hasattr(graph, k): + v_new = {} + for k2, v2 in graph.__getattribute__(k).items(): + v_new[re.sub(pattern, '', k2.strip()).replace(' ', white_space_replacement)] = set( + [re.sub(pattern, '', v3.strip()).replace(' ', white_space_replacement) for v3 in v2]) + graph.__setattr__(k, v_new) + + for k in ['timedconditions', 'timedresponses']: + if hasattr(graph, k): + v_new = {} + for k2, v2 in graph.__getattribute__(k).items(): + v_new[re.sub(pattern, '', k2.strip()).replace(' ', white_space_replacement)] = { + re.sub(pattern, '', v3.strip()).replace(' ', white_space_replacement): d for v3, d in v2.items()} + graph.__setattr__(k, v_new) + + for k2 in ['executed', 'included', 'pending']: + if hasattr(graph.marking, k2): + new_v = set([re.sub(pattern, '', v2.strip()).replace(' ', white_space_replacement) for v2 in graph.marking.__getattribute__(k2)]) + graph.marking.__setattr__(k2, new_v) + + for k in ['subprocesses', 'nestedgroups', 'role_assignments', 'principals_assignments']: + if hasattr(graph, k): + v_new = {} + for k2, v2 in graph.__getattribute__(k).items(): + v_new[re.sub(pattern, '', k2.strip()).replace(' ', white_space_replacement)] = set( + [re.sub(pattern, '', v3.strip()).replace(' ', white_space_replacement) for v3 in v2]) + graph.__setattr__(k, v_new) + + k = 'nestedgroups_map' + if hasattr(graph, k): + v_new = {} + for k2, v2 in graph.__getattribute__(k).items(): + v_new[re.sub(pattern, '', k2.strip()).replace(' ', white_space_replacement)] = v2.strip().replace(' ', white_space_replacement) + graph.__setattr__(k, v_new) + + k = 'label_map' + if hasattr(graph, k): + v_new = {} + for k2, v2 in graph.__getattribute__(k).items(): + if all: + v_new[re.sub(pattern, '', k2.strip()).replace(' ', white_space_replacement)] = v2.strip().replace(' ', white_space_replacement) + else: + v_new[re.sub(pattern, '', k2.strip()).replace(' ', white_space_replacement)] = v2 + graph.__setattr__(k, v_new) + # these are just sets + remaining_k = ['events', 'roles', 'principals'] + if all: + remaining_k.append('labels') + for k in remaining_k: + if hasattr(graph, k): + new_v = set([re.sub(pattern, '', v2.strip()).replace(' ', white_space_replacement) for v2 in graph.__getattribute__(k)]) + graph.__setattr__(k, new_v) + #TODO for any other k + # new_v = set([re.sub(pattern, '', v2.strip()).replace(' ', white_space_replacement) for v2 in graph.__getattribute__(k)]) + # graph.__setattr__(k, new_v) + + return graph + + +def clean_input_as_dict(dcr, white_space_replacement=None): + if white_space_replacement is None: + white_space_replacement = ' ' + # remove all space characters and put conditions and milestones in the correct order (according to the actual arrows) + for k, v in deepcopy(dcr).items(): + if k in [tr.value for tr in TemplateRelations]: + v_new = {} + for k2, v2 in v.items(): + v_new[k2.strip().replace(' ', white_space_replacement)] = set( + [v3.strip().replace(' ', white_space_replacement) for v3 in v2]) + dcr[k] = v_new + elif k in ['conditionsForDelays', 'responseToDeadlines']: + v_new = {} + for k2, v2 in v.items(): + v_new[k2.strip().replace(' ', white_space_replacement)] = { + v3.strip().replace(' ', white_space_replacement): d for v3, d in v2.items()} + dcr[k] = v_new + elif k == 'marking': + for k2 in ['executed', 'included', 'pending']: + new_v = set([v2.strip().replace(' ', white_space_replacement) for v2 in dcr[k][k2]]) + dcr[k][k2] = new_v + elif k in ['subprocesses', 'nestedgroups', 'roleAssignments', 'readRoleAssignments', 'principalsAssignments']: + v_new = {} + for k2, v2 in v.items(): + v_new[k2.strip().replace(' ', white_space_replacement)] = set( + [v3.strip().replace(' ', white_space_replacement) for v3 in v2]) + dcr[k] = v_new + elif k in ['labelMapping']: + v_new = {} + for k2, v2 in v.items(): + v_new[k2.strip().replace(' ', white_space_replacement)] = v2.strip().replace(' ', white_space_replacement) + dcr[k] = v_new + else: + new_v = set([v2.strip().replace(' ', white_space_replacement) for v2 in dcr[k]]) + dcr[k] = new_v + return dcr + + +def map_labels_to_events(graph): + ''' + Events, ids are unique (and are often derived from the concept:name attribute) + Labels or activities are not unique (in general do not have an equivalent in event log nomenclature). Many events or ids can map to an activity or label. + At most one label/activity for an event/id. + In Dcr Discovery algorithms usually 1 event/id = 1 label/activity. So we can simplify the mapping. + ''' + is_dcr_object = isinstance(graph, DcrGraph) + if is_dcr_object: + dcr = graph.obj_to_template() + else: + dcr = graph + id_to_label = dcr['labelMapping'] + dcr_res = deepcopy(dcr_template) + new_label_map = {v:v for k,v in id_to_label.items()} + for k, v in dcr.items(): + if k in id_to_label: + k = id_to_label[k] + if isinstance(v, dict): + for k2, v2 in v.items(): + if k2 in id_to_label: + k2 = id_to_label[k2] + if isinstance(v2, dict): + for k22, v22 in v2.items(): + if k22 in id_to_label: + k22 = id_to_label[k22] + if isinstance(v22, dict): + for k3, v3 in v22.items(): + if k3 in id_to_label: + k3 = id_to_label[k3] + dcr_res[k][k2][k3] = v3 + elif k in ['conditionsForDelays', 'responseToDeadlines']: + dcr_res[k][k2] = {id_to_label[i0]: i1 for i0, i1 in v2.items()} + elif k2 == 'pendingDeadline': + dcr_res[k][k2][k22] = v22 + else: + dcr_res[k][k2][k22] = set([id_to_label[i] for i in v22]) + + elif k not in ['labelMapping']: + dcr_res[k][k2] = set([id_to_label[i] for i in v2]) + + else: + if k not in ['labels', 'roles']: + dcr_res[k] = set([id_to_label[i] for i in v]) + dcr_res['labelMapping'] = new_label_map + if is_dcr_object: + return cast_to_dcr_object(dcr_res) + else: + return dcr_res + + +def cast_to_dcr_object(dcr): + if len(dcr['conditionsForDelays']) > 0 or len(dcr['responseToDeadlines']) > 0: + from pm4py.objects.dcr.timed.obj import TimedDcrGraph + return TimedDcrGraph(dcr) + elif len(dcr['subprocesses']) > 0 or len(dcr['nestedgroups']) > 0: + from pm4py.objects.dcr.hierarchical.obj import HierarchicalDcrGraph + return HierarchicalDcrGraph(dcr) + elif len(dcr['noResponseTo']) > 0 or len(dcr['milestonesFor']): + from pm4py.objects.dcr.extended.obj import ExtendedDcrGraph + return ExtendedDcrGraph(dcr) + elif len(dcr['roles']) > 0: + from pm4py.objects.dcr.distributed.obj import DistributedDcrGraph + return DistributedDcrGraph(dcr) + else: + return DcrGraph(dcr) + + +def time_to_int(graph: TimedDcrGraph, precision='days', inplace=False): + if not inplace: + graph = deepcopy(graph) + for k in ['timedconditions', 'timedresponses']: + if hasattr(graph, k): + v = graph.__getattribute__(k) + v_new = {} + for k2, v2 in v.items(): + v_new[k2] = {} + for v3, duration in v2.items(): + try: + total_seconds = duration.total_seconds() + hours = int(total_seconds / 3600) + minutes = int(total_seconds / 60) + days = int(hours / 24) + if precision == 'hours': + v_new[k2][v3] = hours + elif precision == 'minutes': + v_new[k2][v3] = minutes + elif precision == 'seconds': + v_new[k2][v3] = int(total_seconds) + elif precision == 'days': + v_new[k2][v3] = days + except: + pass + graph.__setattr__(k, v_new) + if not inplace: + return graph + + +def get_reverse_nesting(graph: HierarchicalDcrGraph): + reverse_nesting = {} + for k, v in graph.nestedgroups_map.items(): + if v not in reverse_nesting: + reverse_nesting[v] = set() + reverse_nesting[v].add(k) + return reverse_nesting + + +def nested_groups_and_sps_to_flat_dcr(graph: HierarchicalDcrGraph) -> DcrGraph: + graph.nestedgroups = {**graph.nestedgroups, **graph.subprocesses} + for group, events in graph.subprocesses.items(): + for e in events: + graph.nestedgroupsmap[e] = group + graph.subprocesses = {} + + if len(graph.nestedgroups) == 0: + return graph + + reverse_nesting = get_reverse_nesting(graph) + all_atomic_events = set() + nesting_top = {} + for event in graph.events: + atomic_events = set() + + def find_lowest(e): + if e in reverse_nesting: + for nested_event in reverse_nesting[e]: + if nested_event in reverse_nesting: + find_lowest(nested_event) + else: + atomic_events.add(nested_event) + else: + atomic_events.add(e) + + find_lowest(event) + all_atomic_events = all_atomic_events.union(atomic_events) + if event in graph.nestedgroups.keys(): + nesting_top[event] = atomic_events + + for nest, atomic_events in nesting_top.items(): + for r in Relations: + k0 = r.value + if nest in graph.__getattribute__(k0): + for ae in atomic_events: + if ae not in graph.__getattribute__(k0): + graph.__getattribute__(k0)[ae] = set() + graph.__getattribute__(k0)[ae] = graph.__getattribute__(k0)[ae].union(graph.__getattribute__(k0)[nest]) + graph.__getattribute__(k0).pop(nest) + for k, v in graph.__getattribute__(k0).items(): + if nest in v: + graph.__getattribute__(k0)[k] = graph.__getattribute__(k0)[k].union(atomic_events) + graph.__getattribute__(k0)[k].remove(nest) + for k0 in ['timedconditions', 'timedresponses']: + if nest in graph.__getattribute__(k0): + for ae in atomic_events: + graph.__getattribute__(k0)[ae] = {**graph.__getattribute__(k0)[ae], **graph.__getattribute__(k0)[nest]} + graph.__getattribute__(k0).pop(nest) + for k, v in graph.__getattribute__(k0).items(): + for kv0, vv0 in v.items(): + if nest == kv0: + for ae in atomic_events: + graph.__getattribute__(k0)[k][ae] = vv0 + graph.__getattribute__(k0)[k].pop(nest) + + graph.events = all_atomic_events + graph.marking.included = graph.marking.included.intersection(all_atomic_events) + graph.nestedgroups = {} + graph.nestedgroups_map = {} + return graph diff --git a/pm4py/objects/petri_net/exporter/exporter.py b/pm4py/objects/petri_net/exporter/exporter.py index 8dd22a9cd7..6c67d70dab 100644 --- a/pm4py/objects/petri_net/exporter/exporter.py +++ b/pm4py/objects/petri_net/exporter/exporter.py @@ -16,15 +16,17 @@ ''' from enum import Enum -from pm4py.objects.petri_net.exporter.variants import pnml +from pm4py.objects.petri_net.exporter.variants import pnml, tapn from pm4py.util import exec_utils class Variants(Enum): PNML = pnml + TAPN = tapn PNML = Variants.PNML +TAPN = Variants.TAPN def apply(net, initial_marking, output_filename, final_marking=None, variant=PNML, parameters=None): diff --git a/pm4py/objects/petri_net/exporter/variants/pnml.py b/pm4py/objects/petri_net/exporter/variants/pnml.py index 708a0603b6..3caf95f9bc 100644 --- a/pm4py/objects/petri_net/exporter/variants/pnml.py +++ b/pm4py/objects/petri_net/exporter/variants/pnml.py @@ -181,6 +181,7 @@ def export_petri_tree(petrinet, marking, final_marking=None, export_prom5=False, element_text = etree.SubElement(element, "text") element_text.text = petri_properties.RESET_ARC elif isinstance(arc, InhibitorNet.InhibitorArc): + arc_el.set("type", "inhibitor") element = etree.SubElement(arc_el, petri_properties.ARCTYPE) element_text = etree.SubElement(element, "text") element_text.text = petri_properties.INHIBITOR_ARC diff --git a/pm4py/objects/petri_net/exporter/variants/tapn.py b/pm4py/objects/petri_net/exporter/variants/tapn.py new file mode 100644 index 0000000000..8a529c413a --- /dev/null +++ b/pm4py/objects/petri_net/exporter/variants/tapn.py @@ -0,0 +1,464 @@ +''' + This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de). + + PM4Py is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + PM4Py is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with PM4Py. If not, see . +''' +import uuid + +from lxml import etree + +from pm4py.objects.petri_net.obj import Marking +from pm4py.objects.petri_net.obj import PetriNet +from pm4py.objects.petri_net import properties as petri_properties +from pm4py.util import constants + +def export_petri_tree(petrinet, marking, final_marking=None, export_prom5=False, parameters=None): + """ + Export a Petrinet to a XML tree as a TAPN that can be imported to TAPAAL + + Parameters + ---------- + petrinet: :class:`pm4py.entities.petri.petrinet.PetriNet` + Petri net + marking: :class:`pm4py.entities.petri.petrinet.Marking` + Marking + final_marking: :class:`pm4py.entities.petri.petrinet.Marking` + Final marking (optional) + export_prom5 + Enables exporting PNML files in a format that is ProM5-friendly + parameters + Other parameters of the algorithm + + Returns + ---------- + tree + XML tree + """ + if parameters is None: + parameters = {} + + if final_marking is None: + final_marking = Marking() + + root = etree.Element("pnml") + root.set("xmlns", "http://www.informatik.hu-berlin.de/top/pnml/ptNetb") + net = etree.SubElement(root, "net") + net.set("id", "netFromDCR") + net.set("type", "P/T net") + net.set("active", "true") + page = net + places_map = {} + for place in petrinet.places: + places_map[place] = place.name + pl = etree.SubElement(page, "place") + pl.set("id", place.name) + pl.set("displayName","true") + pl.set("name",place.name) + if petri_properties.AGE_INVARIANT in place.properties: + pl.set("invariant", f"<= {place.properties[petri_properties.AGE_INVARIANT]}") + else: + pl.set("invariant","< inf") + if place in marking: + pl.set("initialMarking",str(marking[place])) + else: + pl.set("initialMarking","0") + if constants.LAYOUT_INFORMATION_PETRI in place.properties: + pl.set("positionX", str(place.properties[constants.LAYOUT_INFORMATION_PETRI][0][0])) + pl.set("positionY", str(place.properties[constants.LAYOUT_INFORMATION_PETRI][0][1])) + else: + pl.set("positionX", "0") + pl.set("positionY", "0") + pl.set("nameOffsetX","0") + pl.set("nameOffsetY","0") + + transitions_map = {} + for transition in petrinet.transitions: + transitions_map[transition] = transition.name + trans = etree.SubElement(page, "transition") + trans.set("angle","0") + trans.set("displayName","true") + trans.set("id", transition.name) + trans.set("infiniteServer","false") + trans.set("name",transition.name) + trans.set("nameOffsetX","0") + trans.set("nameOffsetY","0") + trans.set("player","0") + + if constants.LAYOUT_INFORMATION_PETRI in transition.properties: + trans.set("positionX", str(transition.properties[constants.LAYOUT_INFORMATION_PETRI][0][0])) + trans.set("positionY", str(transition.properties[constants.LAYOUT_INFORMATION_PETRI][0][1])) + else: + trans.set("positionX", "0") + trans.set("positionY", "0") + trans.set("priority","0") + trans.set("urgent","false") + if constants.STOCHASTIC_DISTRIBUTION in transition.properties: + random_variable = transition.properties[constants.STOCHASTIC_DISTRIBUTION] + stochastic_information = etree.SubElement(trans, "toolspecific") + stochastic_information.set("tool", "StochasticPetriNet") + stochastic_information.set("version", "0.2") + distribution_type = etree.SubElement(stochastic_information, "property") + distribution_type.set("key", "distributionType") + distribution_type.text = random_variable.get_distribution_type() + if not random_variable.get_distribution_type() == "IMMEDIATE": + distribution_parameters = etree.SubElement(stochastic_information, "property") + distribution_parameters.set("key", "distributionParameters") + distribution_parameters.text = random_variable.get_distribution_parameters() + distribution_priority = etree.SubElement(stochastic_information, "property") + distribution_priority.set("key", "priority") + distribution_priority.text = str(random_variable.get_priority()) + distribution_invisible = etree.SubElement(stochastic_information, "property") + distribution_invisible.set("key", "invisible") + distribution_invisible.text = str(True if transition.label is None else False).lower() + distribution_weight = etree.SubElement(stochastic_information, "property") + distribution_weight.set("key", "weight") + distribution_weight.text = str(random_variable.get_weight()) + # specific for data Petri nets + if petri_properties.TRANS_GUARD in transition.properties: + trans.set(petri_properties.TRANS_GUARD, transition.properties[petri_properties.TRANS_GUARD]) + if petri_properties.READ_VARIABLE in transition.properties: + read_variables = transition.properties[petri_properties.READ_VARIABLE] + for rv in read_variables: + rv_el = etree.SubElement(trans, petri_properties.READ_VARIABLE) + rv_el.text = rv + if petri_properties.WRITE_VARIABLE in transition.properties: + write_variables = transition.properties[petri_properties.WRITE_VARIABLE] + for wv in write_variables: + wv_el = etree.SubElement(trans, petri_properties.WRITE_VARIABLE) + wv_el.text = wv + arc_index = 0 + for arc in petrinet.arcs: + arc_el = etree.SubElement(page, "arc") + if petri_properties.ARCTYPE in arc.properties and arc.properties[petri_properties.ARCTYPE] == petri_properties.INHIBITOR_ARC: + arc_el.set("id", f"I{arc_index}")#str(hash(arc))) + else: + arc_el.set("id", f"A{arc_index}")#str(hash(arc))) + if type(arc.source) is PetriNet.Place: + arc_el.set("inscription","[0,inf)") + arc_el.set("nameOffsetX","0") + arc_el.set("nameOffsetY","0") + arc_el.set("source", str(places_map[arc.source])) + arc_el.set("target", str(transitions_map[arc.target])) + arc_el.set("type","timed") + else: + arc_el.set("inscription","1") + arc_el.set("nameOffsetX","0") + arc_el.set("nameOffsetY","0") + arc_el.set("source", str(transitions_map[arc.source])) + arc_el.set("target", str(places_map[arc.target])) + arc_el.set("type","normal") + + if petri_properties.ARCTYPE in arc.properties: + arc_type = arc.properties[petri_properties.ARCTYPE] + if arc_type == petri_properties.INHIBITOR_ARC: + arc_type = "tapnInhibitor" + arc_el.set("inscription","[0,inf)") + elif arc_type == petri_properties.TRANSPORT_ARC: + arc_type = "transport" + age_min = "0" + age_max = "inf" + t_idx = "1" + if petri_properties.AGE_MIN in arc.properties: + age_min = str(arc.properties[petri_properties.AGE_MIN]) + if petri_properties.AGE_MAX in arc.properties: + age_max = str(arc.properties[petri_properties.AGE_MAX]) + if petri_properties.TRANSPORT_INDEX in arc.properties: + t_idx = str(arc.properties[petri_properties.TRANSPORT_INDEX]) + inscription = f"[{age_min},{age_max}):{t_idx}" + arc_el.set("inscription", inscription) + arc_el.set("type", arc_type) + + if arc.weight > 1: + arc_el.set("weight",str(arc.weight)) + else: + arc_el.set("weight","1") + + for id in range(0,2): + arc_path = etree.SubElement(arc_el, "arcpath") + arc_path.set("arcPointType","false") + arc_path.set("id",str(id)) + arc_path.set("xCoord","0") + arc_path.set("yCoord","0") + arc_index = arc_index + 1 + + if len(final_marking) > 0: + finalmarkings = etree.SubElement(net, "finalmarkings") + marking = etree.SubElement(finalmarkings, "marking") + + for place in final_marking: + placem = etree.SubElement(marking, "place") + placem.set("idref", place.name) + placem_text = etree.SubElement(placem, "text") + placem_text.text = str(final_marking[place]) + + # specific for data Petri nets + if petri_properties.VARIABLES in petrinet.properties: + variables = etree.SubElement(net, "variables") + for prop in petrinet.properties[petri_properties.VARIABLES]: + variable = etree.SubElement(variables, "variable") + variable.set("type", prop["type"]) + variable_name = etree.SubElement(variable, "name") + variable_name.text = prop["name"] + + k_bound = etree.SubElement(root,"k-bound") + k_bound.set("bound","3") + + feature = etree.SubElement(root, "feature") + feature.set("isGame", "false") + if parameters and 'isTimed' in parameters: + if parameters['isTimed']: + feature.set("isTimed", "true") + else: + feature.set("isTimed", "false") + else: + feature.set("isTimed", "false") + + tree = etree.ElementTree(root) + + return tree + +def export_petri_tree_old(petrinet, marking, final_marking=None, export_prom5=False, parameters=None): + """ + Export a Petrinet to a XML tree + + Parameters + ---------- + petrinet: :class:`pm4py.entities.petri.petrinet.PetriNet` + Petri net + marking: :class:`pm4py.entities.petri.petrinet.Marking` + Marking + final_marking: :class:`pm4py.entities.petri.petrinet.Marking` + Final marking (optional) + export_prom5 + Enables exporting PNML files in a format that is ProM5-friendly + parameters + Other parameters of the algorithm + + Returns + ---------- + tree + XML tree + """ + if parameters is None: + parameters = {} + + if final_marking is None: + final_marking = Marking() + + root = etree.Element("pnml") + net = etree.SubElement(root, "net") + net.set("id", "net1") + net.set("type", "http://www.pnml.org/version-2009/grammar/pnmlcoremodel") + if export_prom5 is True: + page = net + else: + page = etree.SubElement(net, "page") + page.set("id", "n0") + places_map = {} + for place in petrinet.places: + places_map[place] = place.name + pl = etree.SubElement(page, "place") + pl.set("id", place.name) + pl_name = etree.SubElement(pl, "name") + pl_name_text = etree.SubElement(pl_name, "text") + pl_name_text.text = place.properties[ + constants.PLACE_NAME_TAG] if constants.PLACE_NAME_TAG in place.properties else place.name + if place in marking: + pl_initial_marking = etree.SubElement(pl, "initialMarking") + pl_initial_marking_text = etree.SubElement(pl_initial_marking, "text") + pl_initial_marking_text.text = str(marking[place]) + if constants.LAYOUT_INFORMATION_PETRI in place.properties: + graphics = etree.SubElement(pl, "graphics") + position = etree.SubElement(graphics, "position") + position.set("x", str(place.properties[constants.LAYOUT_INFORMATION_PETRI][0][0])) + position.set("y", str(place.properties[constants.LAYOUT_INFORMATION_PETRI][0][1])) + dimension = etree.SubElement(graphics, "dimension") + dimension.set("x", str(place.properties[constants.LAYOUT_INFORMATION_PETRI][1][0])) + dimension.set("y", str(place.properties[constants.LAYOUT_INFORMATION_PETRI][1][1])) + transitions_map = {} + for transition in petrinet.transitions: + transitions_map[transition] = transition.name + trans = etree.SubElement(page, "transition") + trans.set("id", transition.name) + trans_name = etree.SubElement(trans, "name") + trans_text = etree.SubElement(trans_name, "text") + if constants.LAYOUT_INFORMATION_PETRI in transition.properties: + graphics = etree.SubElement(trans, "graphics") + position = etree.SubElement(graphics, "position") + position.set("x", str(transition.properties[constants.LAYOUT_INFORMATION_PETRI][0][0])) + position.set("y", str(transition.properties[constants.LAYOUT_INFORMATION_PETRI][0][1])) + dimension = etree.SubElement(graphics, "dimension") + dimension.set("x", str(transition.properties[constants.LAYOUT_INFORMATION_PETRI][1][0])) + dimension.set("y", str(transition.properties[constants.LAYOUT_INFORMATION_PETRI][1][1])) + if constants.STOCHASTIC_DISTRIBUTION in transition.properties: + random_variable = transition.properties[constants.STOCHASTIC_DISTRIBUTION] + stochastic_information = etree.SubElement(trans, "toolspecific") + stochastic_information.set("tool", "StochasticPetriNet") + stochastic_information.set("version", "0.2") + distribution_type = etree.SubElement(stochastic_information, "property") + distribution_type.set("key", "distributionType") + distribution_type.text = random_variable.get_distribution_type() + if not random_variable.get_distribution_type() == "IMMEDIATE": + distribution_parameters = etree.SubElement(stochastic_information, "property") + distribution_parameters.set("key", "distributionParameters") + distribution_parameters.text = random_variable.get_distribution_parameters() + distribution_priority = etree.SubElement(stochastic_information, "property") + distribution_priority.set("key", "priority") + distribution_priority.text = str(random_variable.get_priority()) + distribution_invisible = etree.SubElement(stochastic_information, "property") + distribution_invisible.set("key", "invisible") + distribution_invisible.text = str(True if transition.label is None else False).lower() + distribution_weight = etree.SubElement(stochastic_information, "property") + distribution_weight.set("key", "weight") + distribution_weight.text = str(random_variable.get_weight()) + if transition.label is not None: + trans_text.text = transition.label + else: + trans_text.text = transition.name + tool_specific = etree.SubElement(trans, "toolspecific") + tool_specific.set("tool", "ProM") + tool_specific.set("version", "6.4") + tool_specific.set("activity", "$invisible$") + tool_specific.set("localNodeID", str(uuid.uuid4())) + if export_prom5 is True: + if transition.label is not None: + prom5_specific = etree.SubElement(trans, "toolspecific") + prom5_specific.set("tool", "ProM") + prom5_specific.set("version", "5.2") + log_event_prom5 = etree.SubElement(prom5_specific, "logevent") + event_name = transition.label.split("+")[0] + event_transition = transition.label.split("+")[1] if len( + transition.label.split("+")) > 1 else "complete" + log_event_prom5_name = etree.SubElement(log_event_prom5, "name") + log_event_prom5_name.text = event_name + log_event_prom5_type = etree.SubElement(log_event_prom5, "type") + log_event_prom5_type.text = event_transition + # specific for data Petri nets + if petri_properties.TRANS_GUARD in transition.properties: + trans.set(petri_properties.TRANS_GUARD, transition.properties[petri_properties.TRANS_GUARD]) + if petri_properties.READ_VARIABLE in transition.properties: + read_variables = transition.properties[petri_properties.READ_VARIABLE] + for rv in read_variables: + rv_el = etree.SubElement(trans, petri_properties.READ_VARIABLE) + rv_el.text = rv + if petri_properties.WRITE_VARIABLE in transition.properties: + write_variables = transition.properties[petri_properties.WRITE_VARIABLE] + for wv in write_variables: + wv_el = etree.SubElement(trans, petri_properties.WRITE_VARIABLE) + wv_el.text = wv + for arc in petrinet.arcs: + arc_el = etree.SubElement(page, "arc") + arc_el.set("id", str(hash(arc))) + if type(arc.source) is PetriNet.Place: + arc_el.set("source", str(places_map[arc.source])) + arc_el.set("target", str(transitions_map[arc.target])) + else: + arc_el.set("source", str(transitions_map[arc.source])) + arc_el.set("target", str(places_map[arc.target])) + + if arc.weight > 1: + inscription = etree.SubElement(arc_el, "inscription") + arc_weight = etree.SubElement(inscription, "text") + arc_weight.text = str(arc.weight) + + for prop_key in arc.properties: + if prop_key == petri_properties.ARCTYPE: + arc_type = arc.properties[petri_properties.ARCTYPE] + arc_el.set("type",arc_type) + else: + element = etree.SubElement(arc_el, prop_key) + element_text = etree.SubElement(element, "text") + element_text.text = str(arc.properties[prop_key]) + + if len(final_marking) > 0: + finalmarkings = etree.SubElement(net, "finalmarkings") + marking = etree.SubElement(finalmarkings, "marking") + + for place in final_marking: + placem = etree.SubElement(marking, "place") + placem.set("idref", place.name) + placem_text = etree.SubElement(placem, "text") + placem_text.text = str(final_marking[place]) + + # specific for data Petri nets + if petri_properties.VARIABLES in petrinet.properties: + variables = etree.SubElement(net, "variables") + for prop in petrinet.properties[petri_properties.VARIABLES]: + variable = etree.SubElement(variables, "variable") + variable.set("type", prop["type"]) + variable_name = etree.SubElement(variable, "name") + variable_name.text = prop["name"] + + tree = etree.ElementTree(root) + + return tree + + +def export_petri_as_string(petrinet, marking, final_marking=None, export_prom5=False, + parameters=None): + """ + Parameters + ---------- + petrinet: :class:`pm4py.entities.petri.petrinet.PetriNet` + Petri net + marking: :class:`pm4py.entities.petri.petrinet.Marking` + Marking + final_marking: :class:`pm4py.entities.petri.petrinet.Marking` + Final marking (optional) + export_prom5 + Enables exporting PNML files in a format that is ProM5-friendly + + Returns + ---------- + string + Petri net as string + """ + if parameters is None: + parameters = {} + + # gets the XML tree + tree = export_petri_tree(petrinet, marking, final_marking=final_marking, + export_prom5=export_prom5) + + # removing default decoding (return binary string as in other parts of the application) + return etree.tostring(tree, xml_declaration=True, encoding=constants.DEFAULT_ENCODING) + + +def export_net(petrinet, marking, output_filename, final_marking=None, export_prom5=False, + parameters=None): + """ + Export a Petrinet to a PNML file + + Parameters + ---------- + petrinet: :class:`pm4py.entities.petri.petrinet.PetriNet` + Petri net + marking: :class:`pm4py.entities.petri.petrinet.Marking` + Marking + final_marking: :class:`pm4py.entities.petri.petrinet.Marking` + Final marking (optional) + output_filename: + Absolute output file name for saving the pnml file + export_prom5 + Enables exporting PNML files in a format that is ProM5-friendly + """ + if parameters is None: + parameters = {} + + # gets the XML tree + tree = export_petri_tree(petrinet, marking, final_marking=final_marking, + export_prom5=export_prom5,parameters=parameters) + + # write the tree to a file + tree.write(output_filename, pretty_print=True, xml_declaration=True, encoding='utf-8') \ No newline at end of file diff --git a/pm4py/objects/petri_net/obj.py b/pm4py/objects/petri_net/obj.py index b8076cf774..cf9340cb8c 100644 --- a/pm4py/objects/petri_net/obj.py +++ b/pm4py/objects/petri_net/obj.py @@ -261,6 +261,10 @@ def __init__(self, name: str=None, places: Collection[Place]=None, transitions: self.__transitions = set() if transitions is None else transitions self.__arcs = set() if arcs is None else arcs self.__properties = dict() if properties is None else properties + self.__arc_matrix = {} + + def __get_arc_matrix(self): + return self.__arc_matrix def __get_name(self) -> str: return self.__name @@ -340,6 +344,7 @@ def __str__(self): transitions = property(__get_transitions) arcs = property(__get_arcs) properties = property(__get_properties) + arc_matrix = property(__get_arc_matrix) class InhibitorNet(PetriNet): diff --git a/pm4py/objects/petri_net/properties.py b/pm4py/objects/petri_net/properties.py index aa91163dd7..c1632860aa 100644 --- a/pm4py/objects/petri_net/properties.py +++ b/pm4py/objects/petri_net/properties.py @@ -26,6 +26,13 @@ INHIBITOR_ARC = "inhibitor" RESET_ARC = "reset" STOCHASTIC_ARC = "stochastic_arc" +TRANSPORT_ARC = "transport" + +AGE_GUARD = "ageguard" # or TIME_GUARD we only consider inclusive [ ] intervals +AGE_MIN = "agemin" # we only consider inclusive [ ] intervals +AGE_MAX = "agemax" # we only consider inclusive [ ] intervals +AGE_INVARIANT = "ageinvariant" +TRANSPORT_INDEX = "transportindex" TRANS_GUARD = "guard" WRITE_VARIABLE = "writeVariable" diff --git a/pm4py/objects/petri_net/timed_arc_net/__init__.py b/pm4py/objects/petri_net/timed_arc_net/__init__.py new file mode 100644 index 0000000000..408165a395 --- /dev/null +++ b/pm4py/objects/petri_net/timed_arc_net/__init__.py @@ -0,0 +1,18 @@ +''' + This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de). + + PM4Py is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + PM4Py is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with PM4Py. If not, see . +''' + +from pm4py.objects.petri_net.timed_arc_net import obj, semantics diff --git a/pm4py/objects/petri_net/timed_arc_net/obj.py b/pm4py/objects/petri_net/timed_arc_net/obj.py new file mode 100644 index 0000000000..309b59472b --- /dev/null +++ b/pm4py/objects/petri_net/timed_arc_net/obj.py @@ -0,0 +1,43 @@ +from pm4py.objects.petri_net.obj import InhibitorNet, Marking, PetriNet +from pm4py.objects.petri_net.properties import AGE_INVARIANT + + +class TimedMarking(Marking): + + def __init__(self, marking=None): + Marking.__init__(self, marking) + self.timed_dict = {} # place and age of token (the net is 1-safe or 1-bounded) + + def time_step(self, tics): + for k in self.keys(): + if k not in self.timed_dict: + self.timed_dict[k] = tics + else: + self.timed_dict[k] += tics + + def __repr__(self): + return str([str(p.name) + ":" + str(self.get(p)) for p in sorted(list(self.keys()), key=lambda x: x.name)]) + " " + str(self.timed_dict) + + +class TimedArcNet(InhibitorNet): + + def __init__(self, name=None, places=None, transitions=None, arcs=None, properties=None): + super().__init__(name, places, transitions, arcs, properties) + + class TransportArc(PetriNet.Arc): + def __init__(self, source, target, weight=1, properties=None): + PetriNet.Arc.__init__(self, source, target, weight=weight, properties=properties) + + class InvariantPlace(PetriNet.Place): + + def __init__(self, name, in_arcs=None, out_arcs=None, properties=None): + super().__init__(name, in_arcs, out_arcs, properties) + + def __set_age_invariant(self, age): + self.properties[AGE_INVARIANT] = age + + def __get_age_invariant(self): + return self.properties[AGE_INVARIANT] + + age_invariant = property(__get_age_invariant, __set_age_invariant) + diff --git a/pm4py/objects/petri_net/timed_arc_net/semantics.py b/pm4py/objects/petri_net/timed_arc_net/semantics.py new file mode 100644 index 0000000000..a0487e78f2 --- /dev/null +++ b/pm4py/objects/petri_net/timed_arc_net/semantics.py @@ -0,0 +1,225 @@ +''' + This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de). + + PM4Py is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + PM4Py is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with PM4Py. If not, see . +''' +import copy +from pm4py.objects.petri_net import properties +from pm4py.objects.petri_net.sem_interface import Semantics +from pm4py.objects.petri_net.timed_arc_net.obj import TimedArcNet, TimedMarking +from pm4py.objects.petri_net.properties import AGE_INVARIANT, AGE_MIN, AGE_MAX, TRANSPORT_INDEX + + +class TimedArcSemantics(Semantics): + def is_enabled(self, t, pn, m, **kwargs): + """ + Verifies whether a given transition is enabled in a given Petri net and marking + + Parameters + ---------- + :param t: transition to check + :param pn: Petri net + :param m: marking to check + + Returns + ------- + :return: true if enabled, false otherwise + """ + return is_enabled(t, pn, m) + + def execute(self, t, pn, m, **kwargs): + """ + Executes a given transition in a given Petri net and Marking + + Parameters + ---------- + :param t: transition to execute + :param pn: Petri net + :param m: marking to use + + Returns + ------- + :return: newly reached marking if :param t: is enabled, None otherwise + """ + return execute(t, pn, m) + + def weak_execute(self, t, pn, m, **kwargs): + """ + Execute a transition even if it is not fully enabled + + Parameters + ---------- + :param t: transition to execute + :param pn: Petri net + :param m: marking to use + + Returns + ------- + :return: newly reached marking if :param t: is enabled, None otherwise + """ + return weak_execute(t, m) + + def enabled_transitions(self, pn, m, **kwargs): + """ + Returns a set of enabled transitions in a Petri net and given marking + + Parameters + ---------- + :param pn: Petri net + :param m: marking of the pn + + Returns + ------- + :return: set of enabled transitions + """ + return enabled_transitions(pn, m) + + +# 29/08/2021: the following methods have been encapsulated in the InhibitorResetSemantics class. +# the long term idea is to remove them. However, first we need to adapt the existing code to the new +# structure. Moreover, for performance reason, it is better to leave the code here, without having +# to instantiate a TimedArcSemantics object. +def is_enabled(t, pn, m): + if t not in pn.transitions: + return False + else: + source_transport = {} + for a in t.in_arcs: + if isinstance(a, TimedArcNet.InhibitorArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.INHIBITOR_ARC or + a.properties[properties.ARCTYPE] == "tapnInhibitor" or + a.properties[properties.ARCTYPE] == "inhibitor")): + if m[a.source] > 0: + return False + elif isinstance(a, TimedArcNet.TransportArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.TRANSPORT_ARC or + a.properties[properties.ARCTYPE] == "transport")): # the age of the token in the source place of the transport arc must satisfy the guards + + + min = 0 + max = float("inf") + source_transport[a.properties[TRANSPORT_INDEX]] = a.source # all transport in_arcs have a unique index to link them to transport out_arcs + if AGE_MIN in a.properties: + min = a.properties[AGE_MIN] + if AGE_MAX in a.properties: + max = a.properties[AGE_MAX] + if min > m.timed_dict[a.source] or m.timed_dict[a.source] > max: + return False + elif m[a.source] < a.weight: + return False + + for a in t.out_arcs: + if isinstance(a, TimedArcNet.TransportArc) and isinstance(a.target, TimedArcNet.InvariantPlace): + if a.target[AGE_INVARIANT] >= m.timed_dict[source_transport[a.properties[TRANSPORT_INDEX]]]: + return False + + return True + + +def next_delay(pn): + transport_arcs = [arc for arc in pn.arcs + if properties.ARCTYPE in arc.properties and arc.properties[properties.ARCTYPE] == properties.TRANSPORT_ARC + and isinstance(arc.source, TimedArcNet.Place)] + first_delay = float("inf") + first_enabled_transition = None + for arc in transport_arcs: + min_age = arc.properties[properties.AGE_MIN] + if min_age < first_delay: + first_delay = min_age + first_enabled_transition = arc.target + return first_delay, first_enabled_transition + + +def next_deadline(pn): + invariant_places = [p for p in pn.places if properties.AGE_INVARIANT in p.properties] + first_deadline = float("inf") + for place in invariant_places: + age_invariant = place.properties[properties.AGE_INVARIANT] + if age_invariant < first_deadline: + first_deadline = age_invariant + return first_deadline + + +def time_step(tics, pn, m): + for p in pn.places: + if AGE_INVARIANT in p.properties and p in m.timed_dict and p.properties[AGE_INVARIANT] < m.timed_dict[p] + tics: + return False + m.time_step(tics) + return True + + +def execute(t, pn, m): + if not is_enabled(t, pn, m): + return None + + m_out = copy.copy(m) + if isinstance(pn, TimedArcNet): + m_out.timed_dict = copy.copy(m.timed_dict) + transfer_time_dict = {} + for a in t.in_arcs: + if isinstance(a, TimedArcNet.InhibitorArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.INHIBITOR_ARC or + a.properties[properties.ARCTYPE] == "tapnInhibitor" or + a.properties[properties.ARCTYPE] == "inhibitor")): + pass + else: + m_out[a.source] -= a.weight + if m_out[a.source] == 0: + del m_out[a.source] + if isinstance(a, TimedArcNet.TransportArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.TRANSPORT_ARC or + a.properties[properties.ARCTYPE] == "transport")): + transfer_time_dict[a.properties[TRANSPORT_INDEX]] = m_out.timed_dict[a.source] + if m_out[a.source] == 0: + del m_out.timed_dict[a.source] + + for a in t.out_arcs: + m_out[a.target] += a.weight + if isinstance(a, TimedArcNet.TransportArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.TRANSPORT_ARC or + a.properties[properties.ARCTYPE] == "transport")): + m_out.timed_dict[a.target] = transfer_time_dict[a.properties[TRANSPORT_INDEX]] + + return m_out + + +def weak_execute(t, m): + m_out = copy.copy(m) + m_out.timed_dict = copy.copy(m.timed_dict) + transfer_time_dict = {} + for a in t.in_arcs: + if isinstance(a, TimedArcNet.InhibitorArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.INHIBITOR_ARC or + a.properties[properties.ARCTYPE] == "tapnInhibitor" or + a.properties[properties.ARCTYPE] == "inhibitor")): + pass + else: + m_out[a.source] -= a.weight + if m_out[a.source] <= 0: + del m_out[a.source] + if isinstance(a, TimedArcNet.TransportArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.TRANSPORT_ARC or + a.properties[properties.ARCTYPE] == "transport")): + transfer_time_dict[a.properties[TRANSPORT_INDEX]] = m_out.timed_dict[a.source] + if m_out[a.source] <= 0: + del m_out.timed_dict[a.source] + for a in t.out_arcs: + m_out[a.target] += a.weight + if isinstance(a, TimedArcNet.TransportArc) or (properties.ARCTYPE in a.properties and (a.properties[properties.ARCTYPE] == properties.TRANSPORT_ARC or + a.properties[properties.ARCTYPE] == "transport")): + m_out.timed_dict[a.target] = transfer_time_dict[a.properties[TRANSPORT_INDEX]] + return m_out + + +def enabled_transitions(pn, m): + enabled = set() + print(next_delay(pn)) + print(next_deadline(pn)) + for t in pn.transitions: + if is_enabled(t, pn, m): + enabled.add(t) + return enabled diff --git a/pm4py/read.py b/pm4py/read.py index 41fc6e91c0..1d5a3713db 100644 --- a/pm4py/read.py +++ b/pm4py/read.py @@ -403,3 +403,19 @@ def read_ocel2_xml(file_path: str, variant_str: Optional[str] = None, encoding: variant = xml_importer.Variants.OCEL20_RUSTXES return xml_importer.apply(file_path, variant=variant, parameters={"encoding": encoding}) + + +def read_dcr_xml(file_path, **parameters): + """ + Reads a DCR graph from an XML file + :param file_path: path to the DCR graph + :param parameters: parameters of the importer + :rtype: ``DCR`` + .. code-block:: python3 + import pm4py + dcr = pm4py.read_dcr_xml("", variant) + """ + if not os.path.exists(file_path): + raise Exception("File does not exist") + from pm4py.objects.dcr.importer import importer as dcr_importer + return dcr_importer.apply(file_path, **parameters) diff --git a/pm4py/vis.py b/pm4py/vis.py index c10d4d1d87..18e8866f8a 100644 --- a/pm4py/vis.py +++ b/pm4py/vis.py @@ -38,6 +38,7 @@ from pm4py.objects.ocel.obj import OCEL from pm4py.objects.org.sna.obj import SNA from pm4py.util import constants +from pm4py.objects.dcr.obj import DcrGraph def view_petri_net(petri_net: PetriNet, initial_marking: Optional[Marking] = None, @@ -1294,7 +1295,7 @@ def view_powl(powl: POWL, format: str = constants.DEFAULT_FORMAT_GVIZ_VIEW, bgco variant = POWLVisualizationVariants.NET format = str(format).lower() - parameters = parameters={"format": format, "bgcolor": bgcolor} + parameters = parameters = {"format": format, "bgcolor": bgcolor} from pm4py.visualization.powl import visualizer as powl_visualizer gviz = powl_visualizer.apply(powl, variant=variant, parameters=parameters) @@ -1380,3 +1381,46 @@ def save_vis_object_graph(ocel: OCEL, graph: Set[Tuple[str, str]], file_path: st from pm4py.visualization.ocel.object_graph import visualizer as obj_graph_vis gviz = obj_graph_vis.apply(ocel, graph, parameters={"format": format, "bgcolor": bgcolor, "rankdir": rankdir}) return obj_graph_vis.save(gviz, file_path) + +def view_dcr(dcr: DcrGraph, format: str = constants.DEFAULT_FORMAT_GVIZ_VIEW, bgcolor: str = "white", rankdir: str = constants.DEFAULT_RANKDIR_GVIZ): + """ + Views a DCR graph + + :param dcr_graph: DCR graph + :param format: format of the visualization (default: png) + :param bgcolor: Background color of the visualization (default: white) + :param rankdir: sets the direction of the graph ("LR" for left-to-right; "TB" for top-to-bottom) + + .. code-block:: python3 + + import pm4py + + dcr = pm4py.discover_dcr(dataframe) + pm4py.view_dcr(dcr, format='svg') + """ + format = str(format).lower() + from pm4py.visualization.dcr import visualizer as dcr_visualizer + gviz = dcr_visualizer.apply(dcr, parameters={"format": format, "bgcolor": bgcolor, "set_rankdir": rankdir}) + dcr_visualizer.view(gviz) + +def save_vis_dcr(dcr: DcrGraph, file_path: str, bgcolor: str = "white", rankdir: str = constants.DEFAULT_RANKDIR_GVIZ, **kwargs): + """ + Saves the visualization of a DCR graph + + :param dcr_graph: DCR graph + :param file_path: output path for where DCR graph should be saved + :param bgcolor: Background color of the visualization (default: white) + :param rankdir: sets the direction of the graph ("LR" for left-to-right; "TB" for top-to-bottom) + + .. code-block:: python3 + + import pm4py + + dcr = pm4py.discover_dcr(dataframe) + pm4py.save_vis_dcr(dcr, format='svg') + """ + file_path = str(file_path) + format = os.path.splitext(file_path)[1][1:].lower() + from pm4py.visualization.dcr import visualizer as dcr_visualizer + gviz = dcr_visualizer.apply(dcr, parameters={"format": format, "bgcolor": bgcolor, "set_rankdir": rankdir}) + return dcr_visualizer.save(gviz, file_path) diff --git a/pm4py/visualization/dcr/__init__.py b/pm4py/visualization/dcr/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pm4py/visualization/dcr/variants/__init__.py b/pm4py/visualization/dcr/variants/__init__.py new file mode 100644 index 0000000000..b3dcc46d53 --- /dev/null +++ b/pm4py/visualization/dcr/variants/__init__.py @@ -0,0 +1 @@ +from pm4py.visualization.dcr.variants import classic diff --git a/pm4py/visualization/dcr/variants/classic.py b/pm4py/visualization/dcr/variants/classic.py new file mode 100644 index 0000000000..659b42317b --- /dev/null +++ b/pm4py/visualization/dcr/variants/classic.py @@ -0,0 +1,131 @@ +import tempfile +from enum import Enum + +from click import option +from graphviz import Digraph + +from pm4py.objects.dcr.timed.obj import TimedDcrGraph +from pm4py.objects.dcr.utils.utils import time_to_iso_string +from pm4py.util import exec_utils, constants + +filename = tempfile.NamedTemporaryFile(suffix=".gv") +filename.close() + +class Parameters(Enum): + FORMAT = "format" + RANKDIR = "set_rankdir" + AGGREGATION_MEASURE = "aggregationMeasure" + FONT_SIZE = "font_size" + BGCOLOR = "bgcolor" + DECORATIONS = "decorations" + + +def create_edge(source, target, relation, viz, time = None, font_size = None,time_precision='D'): + viz.edge_attr['labeldistance'] = '0.0' + if font_size: + font_size = int(font_size) + font_size = str(int(font_size - 2/3*font_size)) + if time: + time = time_to_iso_string(time, time_precision) + match time_precision: + case 'D': + time = None if time=='P0D' else time + case 'H': + time = None if time=='P0DT0H' else time + case 'M': + time = None if time=='P0DT0H0M' else time + case 'S': + time = None if time=='P0DT0H0M0S' else time + + match relation: + case 'condition': + if time: + viz.edge(source, target, color='#FFA500', arrowhead='dotnormal', label=time, labelfontsize=font_size) + else: + viz.edge(source, target, color='#FFA500', arrowhead='dotnormal') + case 'exclude': + viz.edge(source, target, color='#FC0C1B', arrowhead='normal', arrowtail='none', headlabel='%', labelfontcolor='#FC0C1B', labelfontsize='8') + case 'include': + viz.edge(source, target, color='#30A627', arrowhead='normal', arrowtail='none', headlabel='+', labelfontcolor='#30A627', labelfontsize='10') + case 'response': + if time: + viz.edge(source, target, color='#2993FC', arrowhead='normal', arrowtail='dot', dir='both', label=time, labelfontsize=font_size) + else: + viz.edge(source, target, color='#2993FC', arrowhead='normal', arrowtail='dot', dir='both') + case 'noresponse': + viz.edge(source, target, color='#7A514D', arrowhead='normal', headlabel='x', labelfontcolor='#7A514D', labelfontsize='8', arrowtail='dot', dir='both') + case 'milestone': + viz.edge(source, target, color='#A932D0', arrowhead='normal', headlabel='◇', labelfontcolor='#A932D0', labelfontsize='8', arrowtail='dot', dir='both') + return + + +def apply(dcr: TimedDcrGraph, parameters): + if parameters is None: + parameters = {} + + image_format = exec_utils.get_param_value(Parameters.FORMAT, parameters, "png") + set_rankdir = exec_utils.get_param_value(Parameters.RANKDIR, parameters, 'LR') + font_size = exec_utils.get_param_value(Parameters.FONT_SIZE, parameters, "12") + bgcolor = exec_utils.get_param_value(Parameters.BGCOLOR, parameters, constants.DEFAULT_BGCOLOR) + + viz = Digraph("", filename=filename.name, engine='dot', graph_attr={'bgcolor': bgcolor, 'rankdir': set_rankdir}, + node_attr={'shape': 'Mrecord'}, edge_attr={'arrowsize': '0.5'}) + + for event in dcr.events: + label = None + try: + roles = [] + key_list = list(dcr.role_assignments.keys()) + value_list = list(dcr.role_assignments.values()) + for count, value in enumerate(value_list): + if event in value: + roles.append(key_list[count]) + roles = ', '.join(roles) + except AttributeError: + roles = '' + pending_record = '' + if event in dcr.marking.pending: + pending_record = '!' + executed_record = '' + if event in dcr.marking.executed: + executed_record = '✓' + label_map = '' + if event in dcr.label_map: + label_map = dcr.label_map[event] + label = '{ ' + roles + ' | ' + executed_record + ' ' + pending_record + ' } | { ' + label_map + ' }' + included_style = 'solid' + if event not in dcr.marking.included: + included_style = 'dashed' + viz.node(event, label, style=included_style,font_size=font_size) + for event in dcr.conditions: + for event_prime in dcr.conditions[event]: + time = None + if hasattr(dcr,'timedconditions') and event in dcr.timedconditions and event_prime in dcr.timedconditions[event]: + time = dcr.timedconditions[event][event_prime] + create_edge(event_prime, event, 'condition', viz, time, font_size) + for event in dcr.responses: + for event_prime in dcr.responses[event]: + time = None + if hasattr(dcr,'timedresponses') and event in dcr.timedresponses and event_prime in dcr.timedresponses[event]: + time = dcr.timedresponses[event][event_prime] + create_edge(event, event_prime, 'response', viz, time, font_size) + for event in dcr.includes: + for event_prime in dcr.includes[event]: + create_edge(event, event_prime, 'include', viz) + for event in dcr.excludes: + for event_prime in dcr.excludes[event]: + create_edge(event, event_prime, 'exclude', viz) + if hasattr(dcr, 'noresponses'): + for event in dcr.noresponses: + for event_prime in dcr.noresponses[event]: + create_edge(event, event_prime, 'noresponse', viz) + if hasattr(dcr, 'milestones'): + for event in dcr.milestones: + for event_prime in dcr.milestones[event]: + create_edge(event, event_prime, 'milestone', viz) + + viz.attr(overlap='false') + + viz.format = image_format.replace("html", "plain-text") + + return viz diff --git a/pm4py/visualization/dcr/visualizer.py b/pm4py/visualization/dcr/visualizer.py new file mode 100644 index 0000000000..7321132afd --- /dev/null +++ b/pm4py/visualization/dcr/visualizer.py @@ -0,0 +1,60 @@ +import graphviz + +from pm4py.visualization.dcr.variants import classic +from enum import Enum +from pm4py.util import exec_utils +from copy import deepcopy +from pm4py.visualization.common import gview +from pm4py.visualization.common import save as gsave + + +class Variants(Enum): + CLASSIC = classic + + +DEFAULT_VARIANT = Variants.CLASSIC + + +def apply(dcr, variant=DEFAULT_VARIANT, parameters=None): + dcr = deepcopy(dcr) + return exec_utils.get_variant(variant).apply(dcr, parameters) + +def save(gviz: graphviz.Digraph, output_file_path: str, parameters=None): + """ + Save the diagram + + Parameters + ----------- + gviz + GraphViz diagram + output_file_path + Path where the GraphViz output should be saved + """ + gsave.save(gviz, output_file_path, parameters=parameters) + return "" + + +def view(gviz: graphviz.Digraph, parameters=None): + """ + View the diagram + + Parameters + ----------- + gviz + GraphViz diagram + """ + return gview.view(gviz, parameters=parameters) + + +def matplotlib_view(gviz: graphviz.Digraph, parameters=None): + """ + Views the diagram using Matplotlib + + Parameters + --------------- + gviz + Graphviz + """ + + return gview.matplotlib_view(gviz, parameters=parameters) + diff --git a/pm4py/write.py b/pm4py/write.py index 918d2ed7c8..0c42fbbc83 100644 --- a/pm4py/write.py +++ b/pm4py/write.py @@ -18,6 +18,8 @@ The ``pm4py.write`` module contains all funcationality related to writing files/objects to disk. """ +from copy import deepcopy + from pm4py.objects.bpmn.obj import BPMN from pm4py.objects.log.obj import EventLog, EventStream from pm4py.objects.ocel.obj import OCEL @@ -379,3 +381,24 @@ def write_ocel2_xml(ocel: OCEL, file_path: str, encoding: str = constants.DEFAUL from pm4py.objects.ocel.exporter.xmlocel import exporter as xml_exporter return xml_exporter.apply(ocel, file_path, variant=xml_exporter.Variants.OCEL20, parameters={"encoding": encoding}) + + +def write_dcr_xml(dcr_graph, path, variant, dcr_title, replace_whitespace=None): + """ + Writes a DCR graph object to disk in the ``.xml`` file format (exported as ``.xml`` file). + :param dcr: DCR graph object + :param path: target file path to the XML file + :param variant: variant of the DCR graph + :param dcr_title: title of the DCR graph + :param replace_whitespace: optional replacement for the white space character + .. code-block:: python3 + + import pm4py + pm4py.write_dcr_xml(dcr, '', variant, '') + """ + file_path = str(path) + if not file_path.lower().endswith("xml"): + file_path = file_path + ".xml" + + from pm4py.objects.dcr.exporter import exporter as dcr_exporter + return dcr_exporter.apply(dcr_graph=deepcopy(dcr_graph), path=file_path, variant=variant, dcr_title=dcr_title, replace_whitespace=replace_whitespace) diff --git a/tests/DCR_test/benchmark_alignments.py b/tests/DCR_test/benchmark_alignments.py new file mode 100644 index 0000000000..a993f2b01d --- /dev/null +++ b/tests/DCR_test/benchmark_alignments.py @@ -0,0 +1,221 @@ +import os + +import pm4py +import pandas as pd +import matplotlib.pyplot as plt +import time +import logging +import cProfile +from collections import Counter + +from pm4py.algo.discovery.dcr_discover.algorithm import apply +from pm4py.algo.discovery.dcr_discover.variants import dcr_discover +from pm4py.algo.conformance.alignments.dcr.variants import optimal +from pm4py.objects.conversion.log import converter as log_converter +from pm4py.algo.conformance.alignments.dfg.variants import classic +from pm4py.algo.discovery.dfg.variants import performance +from pm4py.algo.evaluation.compliance.variants.confusion_matrix import ComplianceChecker + + +def apply_trace_to_log(training_log, G): + print("Inside apply_trace_to_log function.") + #graph_handler = optimal.DCRGraphHandler(G) + #optimal.LogAlignment(training_log,G) + #trace_handler = optimal.TraceHandler(training_log, 'concept:name') + print("About to create Alignment object.") + print("About to call apply_trace on Alignment object.") + return optimal.apply(training_log,G) + + +def benchmark_optimal(): + repeat = 10 + times = [] + no_event = [] + no_of_act = [] + + for i in range(1, 11): + print(f"Starting iteration {i}") + result = [] + print("Reading and converting log...") + training_log = pm4py.read_xes('../input_data/pdc/pdc_2019/Training Logs/pdc_2019_' + str(i) + '.xes') + add = pd.date_range('2018-04-09', periods=len(training_log), freq='20min') + training_log['time:timestamp'] = add + # Convert DataFrame to EventLog + if isinstance(training_log, pd.DataFrame): + training_log = log_converter.apply(training_log) + print(len(training_log)) + print("Generating DCR graph...") + # Generate DCR graph + dcr_result = apply(training_log, dcr_discover) + G = dcr_result[0] + + # Benchmarking + warm_up_runs = 1 + print("Starting warm-up runs...") + for idx in range(warm_up_runs): + print(f"Warm-up run {idx + 1}") + apply_trace_to_log(training_log, G) + print("Completed warm-up runs.") + + test_log = pm4py.read_xes('../input_data/pdc/pdc_2019/Test Logs/pdc_2019_' + str(i) + '.xes') + add = pd.date_range('2018-04-09', periods=len(test_log), freq='20min') + test_log['time:timestamp'] = add + for _ in range(repeat): + starttime = time.perf_counter() + apply_trace_to_log(test_log, G) + endtime = time.perf_counter() - starttime + result.append(endtime) + print(endtime) + print(f"Completed benchmarking for iteration {i}.") + + avg_time = (sum(result) / repeat) * 1000 + print(f"Result from test {i}: {avg_time} ms") + + # Counting number of events and activities + num_events = sum(len(trace) for trace in test_log) + activities = set(event['concept:name'] for trace in test_log for event in trace) + + print(f"Length of event log: {num_events}") + print(f"Number of activities: {len(activities)}") + + times.append(avg_time) + no_event.append(num_events) + no_of_act.append(len(activities)) + + # Plotting + x = [i for i in range(1, 11)] + y = times + plt.plot(x, times, label='Optimal') + plt.ylabel('Run time in ms') + plt.xlabel('PDC logs 1 to 10') + plt.grid(axis='x') + plt.grid(axis='y') + plt.show() + + +def benchmark_dfg_alignment(): + repeat = 10 + + times = [] + + for i in range(1, 11): + result = [] + + training_log = pm4py.read_xes('../input_data/pdc/pdc_2019/Training Logs/pdc_2019_' + str(i) + '.xes') + add = pd.date_range('2018-04-09', periods=len(training_log), freq='20min') + training_log['time:timestamp'] = add + + # Convert DataFrame to EventLog + if isinstance(training_log, pd.DataFrame): + training_log = log_converter.apply(training_log) + print("Generating DFG...") + # Generate DFG + params = {} + dfg_result = performance.apply(training_log, params) + + G = dfg_result + # print(f"type of dfg: {type(G)}, contents of dfg: {G}") + + start_activities = [trace[0]['concept:name'] for trace in training_log] + sa = Counter(start_activities) + end_activities = [trace[-1]['concept:name'] for trace in training_log] + ea = Counter(end_activities) + sa = dict(sa) + ea = dict(ea) + + # Warm up + for _ in range(1): + classic.apply(training_log, G, sa, ea) + + # Benchmark classic + for _ in range(repeat): + starttime = time.perf_counter() + classic.apply(training_log, G, sa, ea) + endtime = time.perf_counter() - starttime + result.append(endtime) + + avg_time_classic = (sum(result) / repeat) * 1000 + + print(f"Result from test {i}: Classic {avg_time_classic} ms") + + times.append(avg_time_classic) + + # Plotting + x = [i for i in range(1, 11)] + plt.plot(x, times, label='Classic') + plt.ylabel('Run time in ms') + plt.xlabel('PDC logs 1 to 10') + plt.legend() + plt.grid(axis='x') + plt.grid(axis='y') + plt.show() + + +def benchmark_optimal2(): + repeat = 10 + times = [] + no_event = [] + no_of_act = [] + + for i in range(1, 11): + logging.info(f"Starting iteration {i}") + result = [] + logging.info("Reading and converting log...") + + training_log = pm4py.read_xes('../input_data/pdc/pdc_2019/Training Logs/pdc_2019_' + str(i) + '.xes') + add = pd.date_range('2018-04-09', periods=len(training_log), freq='20min') + training_log['time:timestamp'] = add + + # Convert DataFrame to EventLog + if isinstance(training_log, pd.DataFrame): + training_log = log_converter.apply(training_log) + + logging.info("Generating DCR graph...") + + dcr_result = apply(training_log, dcr_discover) + G = dcr_result[0] + + # Benchmarking + warm_up_runs = 1 + logging.info("Starting warm-up runs...") + for idx in range(warm_up_runs): + logging.info(f"Warm-up run {idx + 1}") + apply_trace_to_log(training_log, G) + logging.info("Completed warm-up runs.") + + for _ in range(repeat): + start_time = time.perf_counter() + apply_trace_to_log(training_log, G) + end_time = time.perf_counter() - start_time + result.append(end_time) + logging.info(f"Completed benchmarking for iteration {i}.") + + avg_time = (sum(result) / repeat) * 1000 + logging.info(f"Result from test {i}: {avg_time} ms") + + num_events = sum(len(trace) for trace in training_log) + activities = set(event['concept:name'] for trace in training_log for event in trace) + + times.append(avg_time) + no_event.append(num_events) + no_of_act.append(len(activities)) + + # Plotting + x = [i for i in range(1, 11)] + y = times + plt.plot(x, times, label='Optimal') + plt.ylabel('Run time in ms') + plt.xlabel('PDC logs 1 to 10') + plt.grid(axis='x') + plt.grid(axis='y') + plt.show() + + +if __name__ == "__main__": + print("Running benchmark for optimal...") + #benchmark_optimal() + #benchmark_optimal2() + print("Running benchmark for classic") + #benchmark_dfg_alignment() + + diff --git a/tests/DCR_test/benchmark_conformance.py b/tests/DCR_test/benchmark_conformance.py new file mode 100644 index 0000000000..561cf8db6f --- /dev/null +++ b/tests/DCR_test/benchmark_conformance.py @@ -0,0 +1,116 @@ +import time + +import pm4py +import os +import pandas as pd +from pm4py.discovery import discover_dcr, discover_declare +from pm4py.objects.log.obj import EventLog, Event, Trace +from tests.DCR_test.benchmark_util.conformance_sepsis import benchmark_conformance_sepsis, benchmark_conformance_sepsis_declare +from tests.DCR_test.benchmark_util.conformance_ground_truth import conformance_ground_truth +from shutil import rmtree +from zipfile import ZipFile +from collections import Counter + + +import matplotlib.pyplot as plt + +def get_files(path, folder): + extract_path = os.path.join(path,folder) + with ZipFile(extract_path+".zip", 'r') as zipObj: + zipObj.extractall(extract_path) + +def remove_files(path, folder): + extract_path = os.path.join(path, folder) + rmtree(extract_path) + + +def generate_log_using_petri_net(path, log, log_configuration, trace_configuration): + # petri met to produce synthetic log for + from pm4py.algo.simulation.playout.petri_net.variants.basic_playout import apply_playout + print(os.path.join(path,log)) + log = pm4py.read_xes(os.path.join(path,log)) + net, im, fm = pm4py.discover_petri_net_alpha(log) + for i in log_configuration: + for j in trace_configuration: + log = apply_playout(net, im, i, j) + path = os.path.join(path,path+"_"+str(i)+"_"+str(j)+".xes") + pm4py.write_xes(log,path) + +def export_graph(graph, path, name): + from pm4py.objects.dcr.exporter.exporter import DCR_JS_PORTAL + print(os.path.join(path)) + pm4py.write_dcr_xml(dcr_graph=graph,path=os.path.join(path,name+".xml"),variant=DCR_JS_PORTAL,dcr_title=name) + +def import_graph(path,name): + from pm4py.objects.dcr.importer.importer import XML_DCR_PORTAL + graph = pm4py.read_dcr_xml(file_path=os.path.join(path,name+".xml"),variant=XML_DCR_PORTAL) + return graph + + +def sepsis(name): + print("running sepsis with synthetic logs") + # to generate synthetic sepsis logs + configuration_trace_len = [10, 20, 30, 40, 50] + max_trace = [25000, 50000, 75000, 100000] + path = "sepsis" + import_log = "Sepsis Cases - Event Log.xes" + #generate_log_using_petri_net(path, import_log, max_trace, configuration_trace_len) + + # specify test files + res_file = "results/"+name+".csv" + training_log_path = "Sepsis Cases - Event Log.xes" + training_log = pm4py.read_xes(os.path.join("sepsis", training_log_path)) + graph, _ = discover_dcr(training_log) + for test_file in os.listdir("sepsis"): + if test_file == training_log_path: + continue + test_log = pm4py.read_xes(os.path.join("sepsis", test_file), return_legacy_log_object=True) + benchmark_conformance_sepsis(graph, test_log, res_file, 10) + +def sepsis_declare(): + print("running sepsis with synthetic logs for declare") + + # specify test files + res_file = "results/sepsis_run_times_declare.csv" + training_log_path = "Sepsis Cases - Event Log.xes" + training_log = pm4py.read_xes(os.path.join("sepsis", training_log_path)) + model = discover_declare(training_log) + no = 0 + for test_file in os.listdir("sepsis"): + if test_file == training_log_path: + continue + test_log = pm4py.read_xes(os.path.join("sepsis", test_file), return_legacy_log_object=True) + benchmark_conformance_sepsis_declare(model, test_log, res_file, 10) + +def traffic_management(): + path = "Road_Traffic_Fine_Management_Process" + import_log = "Road_Traffic_Fine_Management_Process.xes" + + log = pm4py.read_xes(os.path.join("../input_data", "roadtraffic100traces.xes")) + graph, _ = pm4py.discover_dcr(log) + print(graph) + name_of_xml = "road_traffic" + #export for visualization and analysis of control flow + export_graph(graph, path, name_of_xml) + log = pm4py.read_xes(os.path.join(path, import_log)) + graph, _ = pm4py.discover_dcr(log) + cases = log['case:concept:name'].unique() + print("running") + # create a data frame dictionary to store your data frames + i = 0 + for elem in cases: + trace = log[log['case:concept:name'] == elem] + print(trace['concept:name']) + """ + start = time.perf_counter() + conf_res = pm4py.conformance_dcr(trace, graph) + end = (time.perf_counter() - start) * 1000 + print(end) + print(conf_res) + """ + +if __name__ == "__main__": + sepsis("new test") + #sepsis_declare() + #traffic_management() + diff --git a/tests/DCR_test/benchmark_util/conformance_sepsis.py b/tests/DCR_test/benchmark_util/conformance_sepsis.py new file mode 100644 index 0000000000..ba83655a23 --- /dev/null +++ b/tests/DCR_test/benchmark_util/conformance_sepsis.py @@ -0,0 +1,47 @@ + +import os +import pandas as pd +import time +from pm4py.algo.conformance.dcr.variants.classic import apply +from pm4py.algo.conformance.declare.variants.classic import apply as declare_apply + + +def write_csv(temp, res_file): + data = pd.DataFrame(temp) + if os.path.isfile(res_file): + data.to_csv(res_file, sep=",", mode="a", header=False, + index=False) + else: + data.to_csv(res_file, sep=";", index=False) + +def benchmark_conformance_sepsis(graph, test_log, res_file, repeat): + times = [] + + no_traces = 0 + trace_len = len(test_log[0]) + for i in range(repeat): + start = time.perf_counter() + res = apply(test_log, graph) + end = (time.perf_counter() - start) * 1000 + times.append(end) + print(end) + no_traces = len(res) + + temp = {"avg_run_time": [(sum(times) / len(times))], "no_traces": [no_traces], "trace_len": [trace_len]} + write_csv(temp, res_file) + +def benchmark_conformance_sepsis_declare(model, test_log, res_file, repeat): + times = [] + + no_traces = 0 + trace_len = len(test_log[0]) + for i in range(repeat): + start = time.perf_counter() + res = declare_apply(test_log, model) + end = (time.perf_counter() - start) * 1000 + times.append(end) + print(end) + no_traces = len(res) + + temp = {"avg_run_time": [(sum(times) / len(times))], "no_traces": [no_traces], "trace_len": [trace_len]} + write_csv(temp, res_file) \ No newline at end of file diff --git a/tests/DCR_test/discover_pdc.py b/tests/DCR_test/discover_pdc.py new file mode 100644 index 0000000000..ee6155cac9 --- /dev/null +++ b/tests/DCR_test/discover_pdc.py @@ -0,0 +1,123 @@ +from shutil import rmtree + +import pm4py +import pandas as pd +import time +import os + +from pm4py.algo.discovery.dcr_discover.variants.dcr_discover import apply +from zipfile import ZipFile + +def get_files(path, folder): + extract_path = os.path.join(path,folder) + with ZipFile(extract_path+".zip", 'r') as zipObj: + zipObj.extractall(extract_path) + +def remove_files(path, folder): + extract_path = os.path.join(path, folder) + rmtree(extract_path) + +def benchmark_discover_run_time_2019(test_path: str,training_logs, repeat: int): + log_path = os.path.join(test_path,training_logs) + + final_times = [] + graphs = [] + for file in os.listdir(log_path): + # reset accumalating variables + times = [] + no_event = [] + no_of_act = [] + + log = pm4py.read_xes(os.path.join(log_path,file)) + add = pd.date_range('2018-04-09', periods=len(log), freq='20min') + log['time:timestamp'] = add + for i in range(repeat): + start = time.perf_counter() + graph, _ = apply(log) + + if i == 0: + graphs.append(graph) + + times.append((time.perf_counter() - start)*1000) + #append time values and no_of_act per trace + no_of_act.append(len(set(log['concept:name']))) + + final_time = (sum(times) / repeat) + print("result from test: " + file + ": " + str(final_time) + " ms") + print("length of event log: " + str(len(log))) + # print("number of actitivies: " + str(len(set(training_log['concept:name'])))) + #append number of event, size of log + no_event.append(len(log)) + final_times.append(final_time) + temp = {"process": [file], "avg_time": [final_time], "no events": [len(log)]} + data = pd.DataFrame(temp) + + if os.path.isfile("results/"+str(test_path)+" run time.csv"): + data.to_csv("results/"+str(test_path)+" run time.csv", sep=";", mode="a", header=False, + index=False) + else: + data.to_csv("results/"+str(test_path)+" run time.csv", sep=";", index=False) + + return graphs + + +def test_ground_truth_compliance(graphs, test_path, test_log_path, gt_log_path): + from pm4py.algo.evaluation.compliance.variants.confusion_matrix import ComplianceChecker + ct = ComplianceChecker() + ct_values = None + + log_test_path = os.path.join(test_path,test_log_path) + log_gt_path = os.path.join(test_path, gt_log_path) + for graph, test_file, gt_file in zip(graphs, os.listdir(log_test_path), os.listdir(log_gt_path)): + test_log = pm4py.read_xes(os.path.join(log_test_path,test_file),return_legacy_log_object=True) + gt_log = pm4py.read_xes(os.path.join(log_gt_path, gt_file), return_legacy_log_object=True) + + # call the compliance checker for traces + ct_values = ct.compliant_traces(graph, test_log, gt_log) + com = ComplianceChecker() + # for individual traces + res = com.compliant_traces(graph,test_log,gt_log) + f = res.get_classification_values() + print(test_file+" has "+" tp: "+str(f[0])+" fp: "+str(f[1])+" tn: "+str(f[2])+" fn: "+str(f[3])) + + print(ct_values.get_classification_values()) + print("collective binary classification results:") + print("positive precision: " + str(round(ct_values.compute_positive_precision(), 2))) + print("negative precision: " + str(round(ct_values.compute_negative_precision(), 2))) + print("positive recall: " + str(round(ct_values.compute_positive_recall(), 2))) + print("negative recall: " + str(round(ct_values.compute_negative_recall(), 2))) + print("positive f_1 score: " + str(round(ct_values.get_positive_f_score(), 2))) + print("negative f_1 score: " + str(round(ct_values.get_negative_f_score(), 2))) + print("accuracy: " + str(round(ct_values.compute_accuracy() * 100, 1))) + print("mcc: " + str(round(ct_values.mcc(), 2))) + +def initiate_run_time_test(test_path:str, repeat: int): + training_logs = "Training Logs" + test_logs = "Test Logs" + ground_truth_log = "Ground Truth Logs" + + get_files(test_path, training_logs) + + graphs = benchmark_discover_run_time_2019(test_path,training_logs,repeat) + remove_files(test_path, training_logs) + + get_files(test_path, test_logs) + get_files(test_path, ground_truth_log) + + test_ground_truth_compliance(graphs,test_path,test_logs, ground_truth_log) + + remove_files(test_path, test_logs) + remove_files(test_path, ground_truth_log) + + + +if __name__ == "__main__": + #the folder to test + pdc_test = "pdc_2019" + + + #repeat the discover algo # of times + repeat = 10 + + #instantiate test + initiate_run_time_test(pdc_test, repeat) \ No newline at end of file diff --git a/tests/DCR_test/sepsis/Sepsis Cases - Event Log.xes b/tests/DCR_test/sepsis/Sepsis Cases - Event Log.xes new file mode 100644 index 0000000000..0ccf4dbce0 --- /dev/null +++ b/tests/DCR_test/sepsis/Sepsis Cases - Event Log.xes @@ -0,0 +1,129561 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/dcr_test.py b/tests/dcr_test.py new file mode 100644 index 0000000000..565f1baafc --- /dev/null +++ b/tests/dcr_test.py @@ -0,0 +1,1143 @@ +import os +import unittest +import pm4py +import pandas as pd +from pm4py.objects.dcr.obj import DcrGraph, dcr_template +from pm4py.algo.discovery.dcr_discover.algorithm import apply +from pm4py.algo.conformance.alignments.dcr.variants.optimal import Alignment +from pm4py.objects.conversion.log import converter as log_converter +from pm4py.objects.dcr.importer import importer as dcr_importer +from pm4py.objects.dcr.exporter import exporter as dcr_exporter + + +class TestDiscoveryDCR(unittest.TestCase): + def check_if_dcr_is_equal(self, dcr1, dcr2): + self.assertEqual(len(dcr1.events), len(dcr2.events)) + for i, j in zip(dcr1.conditions, dcr2.conditions): + self.assertEqual(i, j) + for k, l in zip(dcr1.conditions.get(i), dcr2.conditions.get(j)): + self.assertEqual(k, l) + + for i, j in zip(dcr1.responses, dcr2.responses): + self.assertEqual(i, j) + for k, l in zip(dcr1.responses.get(i), dcr2.responses.get(j)): + self.assertEqual(k, l) + + for i, j in zip(dcr1.includes, dcr2.includes): + self.assertEqual(i, j) + for k, l in zip(dcr1.includes.get(i), dcr2.includes.get(j)): + self.assertEqual(k, l) + + for i, j in zip(dcr1.excludes, dcr2.excludes): + self.assertEqual(i, j) + for k, l in zip(dcr1.excludes.get(i), dcr2.excludes.get(j)): + self.assertEqual(k, l) + + def test_basic_discover_new_dcr_structure(self): + # test to perform if the basic structure holdes all values needed and is mined correctly + # given an event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + # when mined + dcr, _ = apply(log, dcr_discover, findAdditionalConditions=False) + # each unique events should be saved in the graph + self.assertEqual(set(log['concept:name'].unique()), dcr.events) + # it should have mined relations for activities, + + # We want to make sure, that the DCR object store relations + self.assertNotEqual(len(dcr.conditions), 0) + self.assertNotEqual(len(dcr.responses), 0) + self.assertNotEqual(len(dcr.includes), 0) + self.assertNotEqual(len(dcr.excludes), 0) + + # every activity included, and pending and executed being empty + self.assertEqual(len(dcr.marking.pending), 0) + self.assertEqual(len(dcr.marking.executed), 0) + self.assertEqual(len(dcr.marking.included), len(dcr.events)) + + del dcr + del log + + def test_basic_discover_with_additionalconditions(self): + # test to see if the DCR graphs has been mine correctly with additional conditions + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + dcr, _ = apply(log) + # each unique events should be saved in the graph + self.assertEqual(set(log['concept:name'].unique()), dcr.events) + # it should have mined relations for activities, + + # We want to make sure, that the DCR object store relations + self.assertNotEqual(len(dcr.conditions), 0) + self.assertNotEqual(len(dcr.responses), 0) + self.assertNotEqual(len(dcr.includes), 0) + self.assertNotEqual(len(dcr.excludes), 0) + + # every activity included, and pending and executed being empty + self.assertEqual(len(dcr.marking.pending), 0) + self.assertEqual(len(dcr.marking.executed), 0) + self.assertEqual(len(dcr.marking.included), len(dcr.events)) + + del dcr + del log + + def test_basic_disCover(self): + log1 = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + dcr1, _ = apply(log1, dcr_discover) + + log2 = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + dcr2, _ = apply(log2, dcr_discover) + self.check_if_dcr_is_equal(dcr1, dcr2) + + del log1 + del dcr1 + del log2 + del dcr2 + + def test_role_mining(self): + # given a DCR graph + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + # when mined, with post_process roles + parameters = get_properties(log, group_key="org:resource") + dcr, _ = apply(log, post_process={'roles'}, parameters=parameters) + # these attributes, will not be empty + self.assertNotEqual(len(dcr.roles), 0) + self.assertNotEqual(len(dcr.principals), 0) + self.assertNotEqual(len(dcr.role_assignments), 0) + # no roles are given, so principals and roles should be equal + self.assertEqual(dcr.principals, dcr.roles) + + del log + del dcr + + def test_pending_mining(self): + # given a DCR graph + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + # when mined, with post_process pending + parameters = get_properties(log, group_key="org:resource") + dcr, _ = apply(log, post_process={'pending'}, parameters=parameters) + # these attributes, will not be empty + self.assertNotEqual(len(dcr.marking.pending), 0) + + del log + del dcr + + def test_nesting_mining(self): + # given a DCR graph + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + # when mined, with post_process nesting + parameters = get_properties(log, group_key="org:resource") + dcr, _ = apply(log, post_process={'nesting'}, parameters=parameters) + # these attributes, will not be empty + self.assertNotEqual(len(dcr.nestedgroups), 0) + + del log + del dcr + + def test_time_mining(self): + # given a DCR graph + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + # when mined, with post_process timed + parameters = get_properties(log, group_key="org:resource") + dcr, _ = apply(log, post_process={'timed'}, parameters=parameters) + # these attributes, will not be empty + self.assertNotEqual(len(dcr.timedconditions), 0) + self.assertNotEqual(len(dcr.timedresponses), 0) + + del log + del dcr + + def test_all_post_process_mining(self): + # given a DCR graph + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + # when mined, with post_process {pending + parameters = get_properties(log, group_key="org:resource") + dcr, _ = apply(log, post_process={'roles','pending','nesting','timed'}, parameters=parameters) + # these attributes, will not be empty + self.assertNotEqual(len(dcr.roles), 0) + self.assertNotEqual(len(dcr.principals), 0) + self.assertNotEqual(len(dcr.role_assignments), 0) + + self.assertNotEqual(len(dcr.marking.pending), 0) + + self.assertNotEqual(len(dcr.nestedgroups), 0) + + self.assertNotEqual(len(dcr.timedconditions), 0) + self.assertNotEqual(len(dcr.timedresponses), 0) + + del log + del dcr + + def test_role_mining_receipt(self): + # Given an event log + log = pm4py.read_xes(os.path.join("input_data", "receipt.xes")) + # when process is discovered + dcr1, _ = pm4py.discover_dcr(log, post_process={'roles'}) + dcr2, _ = pm4py.discover_dcr(log, post_process={'roles'}) + # then the two model should be equal + self.assertEqual(dcr1.roles, dcr2.roles) + self.assertEqual(dcr1.principals, dcr2.principals) + self.assertNotEqual(dcr1.roles, dcr1.principals) + self.assertEqual(dcr1.role_assignments, dcr2.role_assignments) + + del log + del dcr1 + del dcr2 + + def test_role_mining_with_roles(self): + # given an event log with role attribute + log = pm4py.read_xes("input_data/receipt.xes") + # when the dcr is mined + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}) + + # then roles, principals and roleAssignment should have some values + # additionally, a org:role is provided, therefore principals and roles are different + roles = pm4py.get_event_attribute_values(log, attribute="org:group") + principals = pm4py.get_event_attribute_values(log, attribute="org:resource") + self.assertEqual(dcr.roles, set(roles.keys())) + self.assertEqual(dcr.principals, set(principals.keys())) + self.assertNotEqual(len(dcr.role_assignments), 0) + self.assertNotEqual(dcr.roles, dcr.principals) + + del log + del dcr + del roles + del principals + + def test_role_mining_with_no_roles_or_resources(self): + # if a person tries to mine for roles, but no roles or resources exist in the event log + log = pm4py.read_xes(os.path.join('input_data', 'running-example.xes')) + # drop org:resource column + log = log.drop(columns=['org:resource']) + # when the miner is then performed + from pm4py.algo.discovery.dcr_discover.algorithm import apply + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + with self.assertRaises(ValueError) as context: + parameters = get_properties(log, group_key="org:resource") + apply(log, dcr_discover, post_process={'roles'}, parameters=parameters) + self.assertTrue( + 'input log does not contain attribute identifiers for resources or roles' in str(context.exception)) + + del log + + + def test_role_mining_activity_without_role(self): + # Given an event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + # and one event has no role + new_row = (log[log['concept:name'] == "reinitiate request"]) + new_row = new_row.replace("Sara", float("nan")) + for index, _ in new_row.iterrows(): + log.iloc[index] = new_row.loc[index] + + # when process is discovered + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key='org:resource') + # then reinititate request no longer has the orginal assigned role + self.assertNotIn("reinitiate request", dcr.role_assignments['Sara']) + + del log + del new_row + del dcr + + +class TestObjSematics(unittest.TestCase): + def test_getitem(self): + # given an event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + # when a dcr is mine + dcr, _ = apply(log, dcr_discover) + # then dcr graph should be able to be called as a dictionary + self.assertEqual(dcr.obj_to_template()['conditionsFor'], dcr.conditions) + + del log + del dcr + + def test_getitem_inheritance(self): + # given an event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + # when mined + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:resource") + # getitem should be able to call the additional variables associated with the role object + self.assertEqual(dcr.obj_to_template()['roles'], dcr.roles) + self.assertEqual(dcr.obj_to_template()['principals'], dcr.principals) + self.assertEqual(dcr.obj_to_template()['roleAssignments'], dcr.role_assignments) + + del log + del dcr + + def test_dcr_semantics_enabled(self): + # given an eventlog + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + dcr, _ = apply(log, dcr_discover) + # when an event is check for being enabled + from pm4py.objects.dcr.semantics import DcrSemantics + sem = DcrSemantics() + # Then register request should return true, and other event has yet met conditions is false + self.assertTrue(sem.is_enabled(log.iloc[0]["concept:name"], dcr)) + self.assertFalse(sem.is_enabled(log.iloc[1]["concept:name"], dcr)) + + del log + del dcr + del sem + + def test_dcr_execution_semantic(self): + # given a graph from the DisCover miner + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + dcr, _ = apply(log, dcr_discover) + # When event is executed, the event that has the event as a condition can then be executed + from pm4py.objects.dcr.semantics import DcrSemantics + sem = DcrSemantics() + if sem.is_enabled(log.iloc[0]["concept:name"], dcr): + dcr = sem.execute(dcr, log.iloc[0]["concept:name"]) + + self.assertTrue(sem.is_enabled(log.iloc[1]["concept:name"], dcr)) + + del log + del dcr + del sem + + def test_dcr_is_accepting_semantic(self): + # given a DCR graph discovered from Discover, is always initially accepting + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + dcr, _ = apply(log, dcr_discover) + # then the DCR is accepting + from pm4py.objects.dcr.semantics import DcrSemantics + sem = DcrSemantics() + self.assertTrue(sem.is_accepting(dcr)) + + del log + del dcr + del sem + + def test_dcr_is_accepting_response_pending(self): + # given a DCR graph discovered from Discover, is always initially accepting + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + from pm4py.algo.discovery.dcr_discover.variants import dcr_discover + dcr, _ = apply(log, dcr_discover) + # when an event triggers a response relation + from pm4py.objects.dcr.semantics import DcrSemantics + sem = DcrSemantics() + sem.execute(dcr, "register request") + self.assertFalse(sem.is_accepting(dcr)) + + del log + del dcr + del sem + + def test_label_mapping_to_activity(self): + #given a simple dcr + dcr = DcrGraph() + dcr.events.add("event0") + dcr.events.add("event1") + dcr.events.add("event2") + dcr.labels.add("A") + dcr.labels.add("B") + dcr.labels.add("C") + dcr.label_map["event0"] = "A" + dcr.label_map["event1"] = "B" + dcr.label_map["event2"] = "C" + # when labels are retried for the label mapping + # then all the labels retrieve should exist in labels + + for i in dcr.events: + act = dcr.get_activity(i) + self.assertIsInstance(i,str) + self.assertTrue(act in dcr.labels) + + del dcr + + def test_label_Mapping_to_eventID(self): + # given a simple dcr + dcr = DcrGraph() + dcr.events.add("event0") + dcr.events.add("event1") + dcr.events.add("event2") + dcr.labels.add("A") + dcr.labels.add("B") + dcr.labels.add("C") + dcr.label_map["event0"] = "A" + dcr.label_map["event1"] = "B" + dcr.label_map["event2"] = "C" + # when labels are retried for the label mapping + # then all the labels retrieve should exist in labels + for i in dcr.labels: + act = dcr.get_event(i) + self.assertIsInstance(i, str) + self.assertTrue(act in dcr.events) + + del dcr + + def test_pending_event(self): + from pm4py.objects.dcr.importer.variants.xml_dcr_portal import apply as import_apply + # given a dcr graph and event log + # we use this as it provides an dcr graph, with eventIDs and labels and label mapping + dcr = import_apply('input_data/pendingEvent.xml') + self.assertEqual(1, len(dcr.marking.pending)) + + del dcr + + def test_instantiate_object(self): + dcr1 = DcrGraph() + dcr2 = DcrGraph(dcr_template) + # both empty should be equal + self.assertEqual(dcr1, dcr2) + + del dcr1 + del dcr2 + + +from pm4py.utils import get_properties +class TestConformanceDCR(unittest.TestCase): + def test_rule_checking_no_constraints(self): + # given a dcr graph + log = pm4py.read_xes("input_data/running-example.xes") + dcr, _ = pm4py.discover_dcr(log) + # when running getConstraints + no = dcr.get_constraints() + # then object, should contain 28 constraints + self.assertTrue(no == 28) + + del log + del dcr + del no + + def test_rule_checking_conformance(self): + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + + # given a DCR graph and a event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + + # when process is discovered and check conformance + dcr, _ = pm4py.discover_dcr(log) + conf_res = conf_alg(log, dcr, parameters=None) + # then the models should have perfect fitness + for i in conf_res: + self.assertEqual(int(i['dev_fitness']), 1) + self.assertTrue(i['is_fit'], True) + + del log + del dcr + del conf_res + + def test_rule_checking_dataframe(self): + from pm4py.conformance import conformance_dcr + + # given a DCR graph and a event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + + # when process is discovered, check conformance to return dianostics + dcr, _ = pm4py.discover_dcr(log) + conf_res = conformance_dcr(log, dcr, return_diagnostics_dataframe=True) + # then the models should have perfect fitness + self.assertIsInstance(conf_res, pd.DataFrame) + + del log + del dcr + del conf_res + + def test_condition_violation(self): + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + + # given a log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + + # and a DCR graph + dcr, _ = pm4py.discover_dcr(log) + + # and a log with 1 trace with condition violation + log = log.drop(log[log['case:concept:name'] != "1"].index, axis="index") + log = log.drop(log[log['concept:name'] == "register request"].index, axis="index") + # when conformance is checked + conf_res = conf_alg(log, dcr) + # fitness is not 1.0, and contains 2 conditions violations + collect = 0 + for i in conf_res: + collect += i['dev_fitness'] + collect = collect / len(conf_res) + self.assertNotEqual(collect, 1.0) + collect = [] + for i in conf_res[0]['deviations']: + if i[0] == 'conditionViolation': + collect.append(i[0]) + self.assertIn('conditionViolation', collect) + self.assertTrue(len(collect) == 2) + + del log + del dcr + del conf_res + del collect + + def test_response_violation(self): + # given a log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + + # and a DCR graph + dcr, _ = pm4py.discover_dcr(log) + + # and a log with 1 trace with pending violations + log = log.drop(log[log['case:concept:name'] != "1"].index, axis="index") + log = log.drop(log[log['concept:name'] == "decide"].index, axis="index") + log = log.drop(log[log['concept:name'] == "reject request"].index, axis="index") + + # when conformance is checked + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + conf_res = conf_alg(log, dcr) + + # fitness is not 1.0 and contains 2 response Violations + collect = 0 + for i in conf_res: + collect += i['dev_fitness'] + collect = collect / len(conf_res) + self.assertNotEqual(collect, 1.0) + collect = [] + for i in conf_res[0]['deviations']: + if i[0] == 'responseViolation': + collect.append(i[0]) + + self.assertIn('responseViolation', collect) + self.assertEqual(len(collect), 2) + + del log + del dcr + del conf_res + del collect + + + + def test_exclude_violation(self): + # given A log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + + # and a DCR graphs + dcr, _ = pm4py.discover_dcr(log) + + # and a log with 1 trace containing only register request, exclude violations + log = log.drop(log[log['concept:name'] != "register request"].index, axis="index") + new = {'case:concept:name': [1 for i in range(len(log))]} + log['case:concept:name'] = pd.DataFrame(new).values + + # when conformance is checked + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + conf_res = conf_alg(log, dcr) + + # fitness is not 1, and has 1 exclude violations + collect = 0 + for i in conf_res: + collect += i['dev_fitness'] + collect = collect / len(conf_res) + self.assertNotEqual(collect, 1.0) + collect = [] + for i in conf_res[0]['deviations']: + if i[0] == 'excludeViolation': + collect.append(i[0]) + self.assertIn('excludeViolation', collect) + self.assertEqual(1, len(collect)) + + del log + del dcr + del conf_res + del collect + + def test_exclude_violation2(self): + # given A log with check ticket at end after it has been excluded + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + dcr, _ = pm4py.discover_dcr(log) + log = log[log['case:concept:name'] == "1"] + row = log[log['concept:name'] == "check ticket"] + log = pd.concat([log,row]).reset_index(drop=True) + + #when conformance is checked + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + conf_res = conf_alg(log, dcr) + + # fitness is not 1, and has 1 exclude violation + collect = [] + for i in conf_res[0]['deviations']: + if i[0] == 'excludeViolation': + collect.append(i[0]) + self.assertIn('excludeViolation', collect) + self.assertEqual(1, len(collect)) + + def test_include_violation(self): + # given a log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + + # and a DCR graph + from pm4py.algo.discovery.dcr_discover.algorithm import apply + dcr, _ = apply(log) + + # and a log with 1 trace with include violation + log = log[log['case:concept:name'] == "3"] + row = log[log['concept:name'] == "reinitiate request"] + log = pd.concat([log.iloc[:4], row, log.iloc[4:]]).reset_index(drop=True) + + # when conformance is checked + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + conf_res = conf_alg(log, dcr) + + # then it should not have perfect fitness, with an include violations + # note that include violation, are tightly associated with exclude violation + # it triggers, if an event should have occured before this event to include it + collect = 0 + for i in conf_res: + collect += i['dev_fitness'] + collect = collect / len(conf_res) + self.assertNotEqual(collect, 1.0) + collect = [] + for i in conf_res[0]['deviations']: + if i[0] == 'includeViolation': + collect.append(i[0]) + self.assertIn('includeViolation', collect) + self.assertEqual(1, len(collect)) + + del log + del dcr + del conf_res + del collect + + def test_get_constraint_for_roles(self): + # given a dcr graph + log = pm4py.read_xes("input_data/running-example.xes") + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:resource") + # when running getConstraints + no = dcr.get_constraints() + # then object, should contain the roleAssignment + # 28 original constraints, but also, 19 additional role assignments + self.assertTrue(no == 47) + + del log + del dcr + del no + + def test_rule_checking_role_conformance(self): + # given a DCR graph and a event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:resource") + + # when conformance is check with roles on same log used for mining + # should + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + parameters = get_properties(log, group_key="org:resource") + conf_res = conf_alg(log, dcr, parameters=parameters) + for i in conf_res: + self.assertEqual(int(i['dev_fitness']), 1) + self.assertTrue(i['is_fit']) + + del log + del dcr + del conf_res + del parameters + + def test_conformance_with_group_key(self): + # check if conformance work with group_key as standard input + log = pm4py.read_xes("input_data/receipt.xes") + log.replace("Group 1",float("nan")) + + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}) + conf_res = pm4py.conformance_dcr(log, dcr) + + for i in conf_res: + self.assertEqual(int(i['dev_fitness']), 1) + self.assertTrue(i['is_fit']) + + del log + del dcr + del conf_res + + + + def test_rule_checking_event_with_not_included_role(self): + # Given an event log and discovering a dcr + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:resource") + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + # when the roles are changed and conformance is performed + log = log.replace("Mike", "Brenda") + parameters = get_properties(log, group_key="org:resource") + conf_res = conf_alg(log, dcr, parameters=parameters) + # then the fitness should not be perfect + for i in conf_res: + self.assertNotEqual(i["dev_fitness"], 1.0) + + del log + del dcr + del conf_res + + + def test_rule_checking_with_wrong_resource(self): + # Given an event log and discovering a dcr + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:resource") + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + # when the roles are changed and conformance is performed + log = log.replace("Sara", "Mike") + + parameters = get_properties(log, group_key="org:resource") + conf_res = conf_alg(log, dcr, parameters=parameters) + # then the fitness should not be perfect + for i in conf_res: + self.assertNotEqual(i["dev_fitness"], 1.0) + for i in conf_res[0]['deviations']: + self.assertEqual(i[0], 'roleViolation') + + del log + del dcr + del conf_res + + def test_rule_checking_with_log_missing_resource(self): + # Given an event log and discovering a dcr + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:resource") + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + # when the roles are changed and conformance is performed + log = log.replace("Sara", float("nan")) + parameters = get_properties(log, group_key="org:resource") + conf_res = conf_alg(log, dcr, parameters=parameters) + # then the fitness should not be perfect + for i in conf_res: + self.assertNotEqual(i["dev_fitness"], 1.0) + for i in conf_res[0]['deviations']: + self.assertEqual(i[0], 'roleViolation') + + del dcr + del log + del conf_res + del parameters + + + def test_conformance_event_with_no_role(self): + # Given an event log + log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) + + # and one event has no role + new_row = (log[log['concept:name'] == "reinitiate request"]) + new_row = new_row.replace("Sara", float("nan")) + for index, _ in new_row.iterrows(): + log.iloc[index] = new_row.loc[index] + + # given the DCR process is discovered + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:resource") + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + # and a log with 1 trace + log = (log[log['case:concept:name'] == "3"]) + # when conformance is checked + parameters = get_properties(log, group_key="org:resource") + conf_res = conf_alg(log, dcr, parameters=parameters) + # then the fitness should be perfect, as events with no roles, can be executed by anybody + for i in conf_res: + self.assertEqual(int(i['dev_fitness']), 1) + self.assertTrue(i['is_fit']) + + del dcr + del log + del conf_res + del parameters + + def test_rule_checking_with_role_attribute(self): + # given a DCR graph and a event log + # check if conformance work with group_key as standard input + log = pm4py.read_xes("input_data/receipt.xes") + log = log.rename(columns={"org:group": "org:role"}) + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key='org:role') + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + # it returns deviation due to an event in the log, has instance of event with role and without + parameters = pm4py.utils.get_properties(log, group_key='org:role') + conf_res = conf_alg(log, dcr, parameters=parameters) + for i in conf_res: + self.assertEqual(int(i['dev_fitness']), 1) + self.assertTrue(i['is_fit']) + + del dcr + del log + del conf_res + del parameters + + def test_rule_checking_with_replaced_role(self): + # given an event log + log = pm4py.read_xes("input_data/receipt.xes") + log = log.rename(columns={"org:group": "org:role"}) + #with a role missing + dcr, _ = pm4py.discover_dcr(log, post_process={'roles'}, group_key="org:role") + + log = log.replace("Group 14","Group 2") + from pm4py.algo.conformance.dcr.algorithm import apply as conf_alg + + # it returns deviation due to an event in the log, has instance of event with role and without + parameters = get_properties(log, group_key="org:role") + res = conf_alg(log, dcr, parameters=parameters) + collect = 0 + for i in res: + collect += i['dev_fitness'] + collect = collect / len(res) + self.assertNotEqual(collect, 1.0) + collect = [] + for i in res: + for j in i['deviations']: + collect.append(j[0]) + self.assertIn('roleViolation', collect) + self.assertEqual(5, len(collect)) + + del dcr + del log + del res + del collect + +class TestAlignment(unittest.TestCase): + + def setUp(self): + log_path = os.path.join("input_data", "running-example.xes") + self.log = pm4py.read_xes(log_path) + if isinstance(self.log, pd.DataFrame): + self.log = log_converter.apply(self.log) + self.dcr_result = apply(self.log, pm4py.algo.discovery.dcr_discover.variants.dcr_discover) + self.dcr = self.dcr_result[0] + self.assertIsNotNone(self.dcr) + self.first_trace = self.log[0] + + def test_initial_alignment(self): + graph_handler = self.create_graph_handler(self.dcr) + trace_handler = self.create_trace_handler(self.first_trace) + + alignment_obj = Alignment(graph_handler, trace_handler) + aligned_traces = alignment_obj.apply_trace() + self.validate_alignment(aligned_traces) + + del graph_handler + del trace_handler + del alignment_obj + del aligned_traces + + def test_trace_alignments(self): + for trace in self.log: + self.check_trace_alignment(trace) + + def test_alignment_costs(self): + graph_handler = self.create_graph_handler(self.dcr) + trace_handler = self.create_trace_handler(self.first_trace) + alignment_obj = Alignment(graph_handler, trace_handler) + aligned_traces = alignment_obj.apply_trace() + self.check_alignment_cost(aligned_traces) + + del graph_handler + del trace_handler + del alignment_obj + del aligned_traces + + def test_Check_model_moves(self): + # remove event from log + trace = [e["concept:name"] for e in self.first_trace] + trace.remove("check ticket") + graph_handler = self.create_graph_handler(self.dcr) + trace_handler = self.create_trace_handler(trace) + alignment_obj = Alignment(graph_handler, trace_handler) + aligned_traces = alignment_obj.apply_trace() + self.check_alignment_cost(aligned_traces) + self.check_trace_alignment(trace) + + del trace + del graph_handler + del trace_handler + del alignment_obj + del aligned_traces + + def test_Check_log_moves(self): + #remove event from log + trace = [e["concept:name"] for e in self.first_trace] + trace.append("check ticket") + graph_handler = self.create_graph_handler(self.dcr) + trace_handler = self.create_trace_handler(trace) + alignment_obj = Alignment(graph_handler, trace_handler) + aligned_traces = alignment_obj.apply_trace() + self.check_alignment_cost(aligned_traces) + self.check_trace_alignment(trace) + + del trace + del graph_handler + del trace_handler + del alignment_obj + del aligned_traces + + def test_combination(self): + #remove event from log + trace = [e["concept:name"] for e in self.first_trace] + trace[3] = "reject request" + trace.insert(5,"register request") + trace.pop(8) + graph_handler = self.create_graph_handler(self.dcr) + trace_handler = self.create_trace_handler(trace) + alignment_obj = Alignment(graph_handler, trace_handler) + aligned_traces = alignment_obj.apply_trace() + + self.check_alignment_cost(aligned_traces) + self.check_trace_alignment(trace) + + del trace + del graph_handler + del trace_handler + del alignment_obj + del aligned_traces + + def test_log_simple_interface(self): + log_path = os.path.join("input_data", "running-example.xes") + self.log = pm4py.read_xes(log_path) + align_res = pm4py.optimal_alignment_dcr(self.log, self.dcr) + for row in align_res: + self.assertTrue(row['fitness'] == 1.0) + del log_path + del align_res + + def test_fitness(self): + align_res = pm4py.optimal_alignment_dcr(self.first_trace, self.dcr) + for row in align_res: + self.assertTrue(row['fitness'] == 1.0) + del align_res + + def test_return_dataframe(self): + log_path = os.path.join("input_data", "running-example.xes") + self.log = pm4py.read_xes(log_path) + align_res = pm4py.optimal_alignment_dcr(self.log, self.dcr, return_diagnostics_dataframe=True) + self.assertIsInstance(align_res,pd.DataFrame) + + for index,row in align_res.iterrows(): + self.assertTrue(row['fitness'] == 1.0) + del log_path + del align_res + + @staticmethod + def create_graph_handler(dcr_graph): + return pm4py.algo.conformance.alignments.dcr.variants.optimal.DCRGraphHandler(dcr_graph) + + @staticmethod + def create_trace_handler(trace): + return pm4py.algo.conformance.alignments.dcr.variants.optimal.TraceHandler(trace, 'concept:name') + + @staticmethod + def create_log_handler(log): + return pm4py.algo.conformance.alignments.dcr.variants.optimal.LogAlignment(log, 'concept:name') + + def validate_alignment(self, aligned_traces): + self.assertIsNotNone(aligned_traces) + self.assertIsInstance(aligned_traces, dict) + self.assertIn('alignment', aligned_traces) + + def check_trace_alignment(self, trace): + graph_handler = self.create_graph_handler(self.dcr) + trace_handler = self.create_trace_handler(trace) + + alignment_obj = Alignment(graph_handler, trace_handler) + dcr_trace_result = alignment_obj.apply_trace() + self.assertIsNotNone(dcr_trace_result) + self.assertIn('alignment', dcr_trace_result) + self.assertGreaterEqual(len(dcr_trace_result['alignment']),len(trace)) + + if len(trace) > 0: + self.assertNotEqual(len(dcr_trace_result['alignment']), 0) + + def check_alignment_cost(self, aligned_traces): + alignment = aligned_traces['alignment'] + alignment_cost = aligned_traces.get('cost', float('inf')) + self.assertEqual(alignment_cost, aligned_traces.get('global_min', float('inf'))) + model_moves = sum(1 for move in alignment if move[0] == '>>') + log_moves = sum(1 for move in alignment if move[1] == '>>') + expected_cost = model_moves + log_moves + self.assertEqual(expected_cost, alignment_cost) + + def test_return_datafrane_alignment(self): + log_path = os.path.join("input_data", "running-example.xes") + self.log = pm4py.read_xes(log_path) + res = pm4py.optimal_alignment_dcr(self.log, self.dcr, return_diagnostics_dataframe=True) + self.assertIsInstance(res,pd.DataFrame) + for index,row in res.iterrows(): + self.assertTrue(row['fitness'] == 1.0) + +class TestImportExportDCR(unittest.TestCase): + + def setUp(self) -> None: + import urllib.request + url = "https://data.4tu.nl/file/33632f3c-5c48-40cf-8d8f-2db57f5a6ce7/643dccf2-985a-459e-835c-a82bce1c0339" + self.sepsis = "input_data/Sepsis cases - Event Log.xes.gz" + with urllib.request.urlopen(url) as response, open("input_data/Sepsis cases - Event Log.xes.gz", "wb") as out_file: + out_file.write(response.read()) + + self.test_file = '' + self.second_test_file = '' + + def test_exporter_to_xml_simple(self): + event_log_file = os.path.join("input_data", "receipt.xes") + self.test_file = os.path.join("test_output_data", "receipt_xml_simple.xml") + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.test_file,variant=dcr_exporter.XML_SIMPLE, dcr_title='receipt_xml_simple', replace_whitespace=' ') + + del log + del dcr + + def test_import_export_xml_simple(self): + event_log_file = os.path.join("input_data", "receipt.xes") + self.test_file = os.path.join("test_output_data", "receipt_xml_simple.xml") + self.export_file_simple(event_log_file) + dcr = pm4py.read_dcr_xml(self.test_file, variant=dcr_importer.Variants.XML_SIMPLE) + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.test_file,variant=dcr_exporter.Variants.XML_SIMPLE, dcr_title='receipt_xml_simple_exported',replace_whitespace=' ') + dcr_imported_after_export = pm4py.read_dcr_xml(self.test_file, variant=dcr_importer.Variants.XML_SIMPLE) + self.assertEqual(len(dcr.__dict__), len(dcr_imported_after_export.__dict__)) + + del dcr + del dcr_imported_after_export + + # Events are not included (dashed lines) in the portal + def test_xml_simple_to_dcr_js_portal(self): + event_log_file = os.path.join("input_data", "receipt.xes") + self.test_file = os.path.join("test_output_data", "receipt_xml_simple.xml") + self.export_file_simple(event_log_file) + dcr = pm4py.read_dcr_xml(self.test_file, variant=dcr_importer.Variants.XML_SIMPLE) + + os.remove(self.test_file) + + self.test_file = os.path.join("test_output_data", "receipt_xml_simple_to_dcr_js_portal.xml") + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.test_file,variant=dcr_exporter.Variants.DCR_JS_PORTAL, dcr_title='receipt_xml_simple_to_dcr_js_portal',replace_whitespace=' ') + + del dcr + + def test_exporter_to_dcr_portal(self): + event_log_file = os.path.join("input_data","Sepsis cases - Event Log.xes.gz") + self.test_file = os.path.join("test_output_data", "sepsis_dcr_portal.xml") + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.test_file,variant=dcr_exporter.XML_DCR_PORTAL, dcr_title='xml_2_dcr_portal') + + del log + del dcr + + + def test_importer_from_dcr_portal(self): + event_log_file = os.path.join("input_data", "Sepsis cases - Event Log.xes.gz") + self.test_file = os.path.join("test_output_data", "sepsis_dcr_portal.xml") + self.export_file_dcr_portal(event_log_file) + dcr = pm4py.read_dcr_xml(os.path.join("test_output_data", "sepsis_dcr_portal.xml")) + self.assertIsNotNone(dcr) + + del event_log_file + del dcr + + def test_import_export_dcr_portal(self): + + self.test_file = os.path.join("test_output_data", "sepsis_dcr_portal.xml") + self.export_file_dcr_portal(self.sepsis) + dcr = pm4py.read_dcr_xml(self.test_file) + self.second_test_file = os.path.join("test_output_data", "sepsis_dcr_portal_exported.xml") + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.second_test_file,variant=dcr_exporter.XML_DCR_PORTAL, dcr_title='sepsis_dcr_portal_exported_xml') + dcr_imported_after_export = pm4py.read_dcr_xml(self.second_test_file) + self.assertEqual(len(dcr.__dict__), len(dcr_imported_after_export.__dict__)) + + del dcr_imported_after_export + del dcr + + def test_exporter_to_dcr_js_portal(self): + event_log_file = os.path.join("input_data", "receipt.xes") + self.test_file = os.path.join("test_output_data", "receipt_dcr_js_portal.xml") + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + pm4py.write_dcr_xml(dcr_graph=dcr, path=self.test_file, variant=dcr_exporter.Variants.DCR_JS_PORTAL, dcr_title='reviewing_exported_dcr_js_portal') + + del log + del dcr + + def test_importer_from_dcr_js_portal(self): + event_log_file = os.path.join("input_data", "receipt.xes") + self.test_file = os.path.join("test_output_data", "receipt_dcr_js_portal.xml") + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + pm4py.write_dcr_xml(dcr_graph=dcr, path=self.test_file, variant=dcr_exporter.Variants.DCR_JS_PORTAL, + dcr_title='reviewing_exported_dcr_js_portal') + dcr = pm4py.read_dcr_xml(os.path.join("test_output_data", "receipt_dcr_js_portal.xml")) + self.assertIsNotNone(dcr) + + del dcr + del log + + + def test_import_export_dcr_js_portal(self): + event_log_file = os.path.join("input_data","receipt.xes") + self.test_file = os.path.join("test_output_data", "receipt_dcr_js_portal.xml") + self.export_file_dcr_js(event_log_file) + dcr = pm4py.read_dcr_xml(self.test_file) + self.second_test_file = os.path.join("test_output_data", "receipt_dcr_js_portal_exported.xml") + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.second_test_file,variant=dcr_exporter.DCR_JS_PORTAL, dcr_title='receipt_dcr_js_portal_exported') + dcr_imported_after_export = pm4py.read_dcr_xml(self.second_test_file) + self.assertEqual(len(dcr.__dict__), len(dcr_imported_after_export.__dict__)) + + del dcr + del dcr_imported_after_export + + def test_xml_dcr_portal_to_dcr_js_portal(self): + self.test_file = os.path.join("test_output_data", "sepsis_dcr_portal.xml") + self.export_file_dcr_portal(self.sepsis) + dcr = pm4py.read_dcr_xml(self.test_file) + self.second_test_file = os.path.join("test_output_data", "sepsis_dcr_js_portal.xml") + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.second_test_file,variant=dcr_exporter.DCR_JS_PORTAL, dcr_title='sepsis_dcr_js_portal') + + del dcr + + def test_dcr_js_portal_to_xml_dcr_portal(self): + event_log_file = os.path.join("input_data","receipt.xes") + self.test_file = os.path.join("test_output_data", "receipt_dcr_js_portal.xml") + self.export_file_dcr_js(event_log_file) + dcr = pm4py.read_dcr_xml(self.test_file) + + self.second_test_file = os.path.join("test_output_data", "receipt_dcr_xml_portal.xml") + pm4py.write_dcr_xml(dcr_graph=dcr,path=self.second_test_file,variant=dcr_exporter.XML_DCR_PORTAL, dcr_title='receipt_dcr_xml_portal') + + del dcr + + def test_xes_to_xml_dcr_portal_to_dcr_js_portal(self): + event_log_file = os.path.join("input_data", "running-example.xes") + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + + self.test_file = os.path.join("test_output_data", "running-example_dcr_portal.xml") + pm4py.write_dcr_xml(dcr_graph=dcr, path=self.test_file, variant=dcr_exporter.XML_DCR_PORTAL, + dcr_title='running-example_dcr_portal') + dcr_imported_after_export = pm4py.read_dcr_xml(self.test_file) + self.second_test_file = os.path.join("test_output_data", "running-example_dcr_js_portal.xml") + pm4py.write_dcr_xml(dcr_graph=dcr_imported_after_export, path=self.second_test_file, + variant=dcr_exporter.DCR_JS_PORTAL, dcr_title='running-example_dcr_js_portal') + + del dcr + del log + del dcr_imported_after_export + + def export_file_simple(self, event_log_file): + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + pm4py.write_dcr_xml(dcr_graph=dcr, path=self.test_file, variant=dcr_exporter.XML_SIMPLE, + dcr_title='xml_simple',replace_whitespace=' ') + + def export_file_dcr_portal(self, event_log_file): + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + pm4py.write_dcr_xml(dcr_graph=dcr, path=self.test_file, variant=dcr_exporter.XML_DCR_PORTAL, + dcr_title='xml_dcr_portal',replace_whitespace=' ') + + def export_file_dcr_js(self, event_log_file): + log = pm4py.read_xes(event_log_file) + dcr, _ = apply(log) + pm4py.write_dcr_xml(dcr_graph=dcr, path=self.test_file, variant=dcr_exporter.DCR_JS_PORTAL, + dcr_title='xml_dcr_js',replace_whitespace=' ') + + def tearDown(self) -> None: + os.remove("input_data/Sepsis cases - Event Log.xes.gz") + if self.test_file != '': + os.remove(self.test_file) + self.test_file = '' + if self.second_test_file != '': + os.remove(self.second_test_file) + self.second_test_file = '' + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/execute_tests.py b/tests/execute_tests.py index 5e3a56ad75..072509e42c 100644 --- a/tests/execute_tests.py +++ b/tests/execute_tests.py @@ -27,7 +27,8 @@ "DiagnDfConfChecking", "ProcessModelEvaluationTests", "DecisionTreeTest", "GraphsForming", "HeuMinerTest", "MainFactoriesTest", "AlgorithmTest", "LogFilteringTest", "DataframePrefilteringTest", "StatisticsLogTest", "StatisticsDfTest", "TransitionSystemTest", - "ImpExpFromString", "WoflanTest", "OcelFilteringTest", "OcelDiscoveryTest", "LlmTest"] + "ImpExpFromString", "WoflanTest", "OcelFilteringTest", "OcelDiscoveryTest", "LlmTest", "DcrImportExportTest", + "DcrSemanticsTest", "DcrDiscoveryTest", "DcrConformanceTest", "DcrAlignmentTest"] loader = unittest.TestLoader() suite = unittest.TestSuite() @@ -326,7 +327,49 @@ if failed > 0: print("-- PRESS ENTER TO CONTINUE --") input() + try: + from tests.ocel_discovery_test import OcelDiscoveryTest + suite.addTests(loader.loadTestsFromTestCase(OcelDiscoveryTest)) + except: + print("OcelDiscoveryTest import failed!") + failed += 1 + +if "LlmTest" in enabled_tests: + try: + from tests.llm_test import LlmTest + suite.addTests(loader.loadTestsFromTestCase(LlmTest)) + except: + print("LlmTest import failed!") + failed += 1 +if "DcrImportExportTest" in enabled_tests: + from tests.dcr_test import TestImportExportDCR + + suite.addTests(loader.loadTestsFromTestCase(TestImportExportDCR)) + +if "DcrSemanticsTest" in enabled_tests: + from tests.dcr_test import TestObjSematics + + suite.addTests(loader.loadTestsFromTestCase(TestObjSematics)) + +if "DcrDiscoveryTest" in enabled_tests: + from tests.dcr_test import TestDiscoveryDCR + + suite.addTests(loader.loadTestsFromTestCase(TestDiscoveryDCR)) + +if "DcrConformanceTest" in enabled_tests: + from tests.dcr_test import TestConformanceDCR + + suite.addTests(loader.loadTestsFromTestCase(TestConformanceDCR)) + +if "DcrAlignmentTest" in enabled_tests: + from tests.dcr_test import TestAlignment + suite.addTests(loader.loadTestsFromTestCase(TestAlignment)) + + +if failed > 0: + print("-- PRESS ENTER TO CONTINUE --") + input() def main(): if EXECUTE_TESTS: @@ -358,4 +401,13 @@ def main(): if __name__ == "__main__": + import warnings + from pandas.errors import SettingWithCopyWarning, PerformanceWarning + import pandas as pd + pd.set_option('future.no_silent_downcasting', True) + warnings.simplefilter(action="ignore", category=SettingWithCopyWarning) + warnings.simplefilter(action="ignore", category=PerformanceWarning) + warnings.filterwarnings( + action='ignore', category=UserWarning, message=r"Boolean Series.*" + ) main()