diff --git a/src/main/jastadd/distribution/DistributedPN.jadd b/src/main/jastadd/distribution/DistributedPN.jadd
index 68acb5399392d12dabfb478a362ea71b32ca0033..1fe9acc26d876355dcc6215983c41e59741db8c1 100644
--- a/src/main/jastadd/distribution/DistributedPN.jadd
+++ b/src/main/jastadd/distribution/DistributedPN.jadd
@@ -1,5 +1,6 @@
 aspect PnDistribution {
 
+    /*
     syn lazy String Transition.location() {
         return de.tudresden.inf.st.pnml.ToolSpecificsParser.getLocationFromToolSpecifics(this.getToolspecificList());
     }
@@ -35,4 +36,20 @@ aspect PnDistribution {
     syn lazy Integer Transition.outputLimit(){
         return de.tudresden.inf.st.pnml.ToolSpecificsParser.getTransitionInputLimit(this.getToolspecificList());
     }
+
+     */
+
+    syn lazy TransitionInformation InputSignalTransition.getTransitionInformation() {
+
+        TransitionInformation tInfo = de.tudresden.inf.st.pnml.ToolSpecificsParser.getTransitionInformation(this.getToolspecificList());
+
+        return tInfo;
+    }
+
+    syn lazy PlaceInformation OutputSignalPlace.getPlaceInformation() {
+
+        PlaceInformation pInfo = de.tudresden.inf.st.pnml.ToolSpecificsParser.getPlaceInformation(this.getToolspecificList());
+
+        return pInfo;
+    }
 }
\ No newline at end of file
diff --git a/src/main/jastadd/io/IoPN.relast b/src/main/jastadd/io/IoPN.relast
index b659cb7a2cd2edc98e3a60b37e7059bd9b81f5ff..38fd19c687f1ff230ccd2e844bdb8af0208faef5 100644
--- a/src/main/jastadd/io/IoPN.relast
+++ b/src/main/jastadd/io/IoPN.relast
@@ -1,7 +1,9 @@
 InputSignalBinding : PnObject ::= <TransitionID:String> <InputSignalID:String> <InputSignalValue:int>;
 OutputSignalBinding : PnObject ::= <PlaceID:String> <OutputSignalID:String> /<OutputSignalValue:String>/ EqualityOM:EqualityOutputMapping* ThresholdOM:ThresholdOutputMapping* RangeOM:RangeOutputMapping*;
+TransitionInformation ::= <Location:String> <Type:String> <InputLimit:java.lang.Integer> <OutputLimit:java.lang.Integer> <Topic:String> <SubNet:String>;
+PlaceInformation ::= <Location:String> <Type:String> <SubNet:String>;
 
-InputSignalTransition : Transition ::= /InputSignalBinding*/;
+InputSignalTransition : Transition ::= /InputSignalBinding*/ /TransitionInformation/;
 OutputSignalPlace : Place ::= /OutputSignalBinding*/;
 
 OutputMapping;
diff --git a/src/main/java/de/tudresden/inf/st/pnml/Main.java b/src/main/java/de/tudresden/inf/st/pnml/Main.java
index c154407e768963168d99d44e30e643813d0aed07..a7b268e2faf177fa4ebf6ec93675dfb752c24a6f 100644
--- a/src/main/java/de/tudresden/inf/st/pnml/Main.java
+++ b/src/main/java/de/tudresden/inf/st/pnml/Main.java
@@ -24,6 +24,7 @@ public class Main {
     public static void main(String[] args) {
 
         List<PetriNet> petriNets = parsePnml("src/main/resources/minimal_global.pnml");
+        GlobalToLocalNetsPostProcessor.disconnectNets(petriNets.get(0));
 
     }
 
diff --git a/src/main/java/de/tudresden/inf/st/pnml/PnmlConstants.java b/src/main/java/de/tudresden/inf/st/pnml/PnmlConstants.java
index 6bb2a0ad465528a445b430e577dabec8f2f70c46..32978dcbf90a15ef6e96834988b7efd3c6a42548 100644
--- a/src/main/java/de/tudresden/inf/st/pnml/PnmlConstants.java
+++ b/src/main/java/de/tudresden/inf/st/pnml/PnmlConstants.java
@@ -7,6 +7,12 @@ public final class PnmlConstants {
 
     public static final String TRANSITION_TYPE_TOPIC = "topicTransitionType";
 
+    public static final String TRANSITION_TOPIC_TYPE_LIMITED_IN = "limitedChannelInType";
+    public static final String TRANSITION_TOPIC_TYPE_UNLIMITED_IN = "unlimitedChannelInType";
+
+    public static final String TRANSITION_TOPIC_TYPE_LIMITED_OUT = "limitedChannelOutType";
+    public static final String TRANSITION_TOPIC_TYPE_UNLIMITED_OUT = "unlimitedChannelOutType";
+
     public static final String PLACE_TYPE_DISCRETE = "discretePlaceType";
     public static final String PLACE_TYPE_CONTINUOUS = "continuousPlaceType";
 
diff --git a/src/main/java/de/tudresden/inf/st/pnml/ToolSpecificsParser.java b/src/main/java/de/tudresden/inf/st/pnml/ToolSpecificsParser.java
index 7c98d659b1fa7f452a84a5f7f8d55f0085a40872..eca05eee01ee1160659b3bd7090d3ab8db062c8d 100644
--- a/src/main/java/de/tudresden/inf/st/pnml/ToolSpecificsParser.java
+++ b/src/main/java/de/tudresden/inf/st/pnml/ToolSpecificsParser.java
@@ -1,12 +1,14 @@
 package de.tudresden.inf.st.pnml;
 
 import de.tudresden.inf.st.pnml.jastadd.model.JastAddList;
+import de.tudresden.inf.st.pnml.jastadd.model.PlaceInformation;
 import de.tudresden.inf.st.pnml.jastadd.model.ToolInfo;
 
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.ParserConfigurationException;
 
+import de.tudresden.inf.st.pnml.jastadd.model.TransitionInformation;
 import fr.lip6.move.pnml.framework.utils.PNMLUtils;
 import fr.lip6.move.pnml.ptnet.hlapi.PetriNetDocHLAPI;
 import org.slf4j.Logger;
@@ -23,7 +25,7 @@ public class ToolSpecificsParser {
 
     private static final Logger logger = LoggerFactory.getLogger(ToolSpecificsParser.class);
 
-    public static String getLocationFromToolSpecifics(JastAddList<ToolInfo> toolInfos) {
+    private static String getLocationFromToolSpecifics(JastAddList<ToolInfo> toolInfos) {
 
         if (toolInfos.getNumChild() > 0) {
             try {
@@ -55,7 +57,7 @@ public class ToolSpecificsParser {
                             || type.equals(PnmlConstants.TRANSITION_TYPE_TOPIC)) {
                         return type;
                     } else {
-                        logger.error("Error: Invalid transition type configured.");
+                        logger.error("Error: Invalid transition type configured: " + type + ".");
                     }
                 }
 
@@ -67,7 +69,7 @@ public class ToolSpecificsParser {
         return null;
     }
 
-    public static String getPlaceTypeFromToolSpecifics(JastAddList<ToolInfo> toolInfos) {
+    private static String getPlaceTypeFromToolSpecifics(JastAddList<ToolInfo> toolInfos) {
 
         if (toolInfos.getNumChild() > 0) {
             try {
@@ -78,8 +80,6 @@ public class ToolSpecificsParser {
                     String type = typeList.item(0).getTextContent();
                     if (type.equals(PnmlConstants.PLACE_TYPE_DISCRETE) || type.equals(PnmlConstants.PLACE_TYPE_CONTINUOUS)) {
                         return type;
-                    } else {
-                        logger.error("Error: Invalid transition type configured.");
                     }
                 }
 
@@ -90,7 +90,7 @@ public class ToolSpecificsParser {
         return null;
     }
 
-    public static String getTopic(JastAddList<ToolInfo> toolInfos) {
+    private static String getTopic(JastAddList<ToolInfo> toolInfos) {
 
         if (toolInfos.getNumChild() > 0) {
             try {
@@ -105,6 +105,7 @@ public class ToolSpecificsParser {
 
                     if (type.equals(PnmlConstants.TRANSITION_TYPE_TOPIC)) {
                         return topicList.item(0).getTextContent();
+
                     }
                 }
             } catch (ParserConfigurationException | SAXException | IOException e) {
@@ -115,19 +116,19 @@ public class ToolSpecificsParser {
         return null;
     }
 
-    private static String getSubnetInfoInternal(JastAddList<ToolInfo> toolInfos){
+    private static String getSubnetInfoInternal(JastAddList<ToolInfo> toolInfos) {
 
         if (toolInfos.getNumChild() > 0) {
-            try{
+            try {
                 Document doc = parseToolSpecifics(toolInfos);
                 String typeTrans = getTransitionTypeFromToolSpecifics(toolInfos);
                 String typePlace = getPlaceTypeFromToolSpecifics(toolInfos);
 
                 String type = typePlace == null ? typeTrans : typePlace;
 
-                if(type != null && (type.equals(PnmlConstants.TRANSITION_TYPE_DISCRETE)
+                if (type != null && (type.equals(PnmlConstants.TRANSITION_TYPE_DISCRETE)
                         || type.equals(PnmlConstants.PLACE_TYPE_CONTINUOUS) || type.equals(PnmlConstants.PLACE_TYPE_CONTINUOUS)
-                || type.equals(PnmlConstants.PLACE_TYPE_DISCRETE))){
+                        || type.equals(PnmlConstants.PLACE_TYPE_DISCRETE) || type.equals(PnmlConstants.TRANSITION_TYPE_TOPIC))) {
 
                     NodeList snList = doc.getElementsByTagName(PnmlConstants.SUBNET_KEY);
 
@@ -135,28 +136,28 @@ public class ToolSpecificsParser {
                         return snList.item(0).getTextContent();
                     }
                 }
-            }catch (ParserConfigurationException | SAXException | IOException e) {
+            } catch (ParserConfigurationException | SAXException | IOException e) {
                 logger.error(e.getMessage());
             }
         }
         return null;
     }
 
-    public static String getTransitionSubnetInfo(JastAddList<ToolInfo> toolInfos){
+    private static String getTransitionSubnetInfo(JastAddList<ToolInfo> toolInfos) {
         return getSubnetInfoInternal(toolInfos);
     }
 
-    public static String getPlaceSubnetInfo(JastAddList<ToolInfo> toolInfos){
+    private static String getPlaceSubnetInfo(JastAddList<ToolInfo> toolInfos) {
         return getSubnetInfoInternal(toolInfos);
     }
 
-    private static int getTransitionLimitsInternal(JastAddList<ToolInfo> toolInfos, String limitType){
+    private static int getTransitionLimitsInternal(JastAddList<ToolInfo> toolInfos, String limitType) {
         if (toolInfos.getNumChild() > 0) {
-            try{
+            try {
                 Document doc = parseToolSpecifics(toolInfos);
                 String transitionType = getTransitionTypeFromToolSpecifics(toolInfos);
 
-                if(transitionType != null && (transitionType.equals(PnmlConstants.TRANSITION_TYPE_TOPIC))){
+                if (transitionType != null && (transitionType.equals(PnmlConstants.TRANSITION_TYPE_TOPIC))) {
 
                     NodeList limList = doc.getElementsByTagName(limitType);
 
@@ -164,21 +165,48 @@ public class ToolSpecificsParser {
                         return Integer.valueOf(limList.item(0).getTextContent());
                     }
                 }
-            }catch (ParserConfigurationException | SAXException | IOException e) {
+            } catch (ParserConfigurationException | SAXException | IOException e) {
                 logger.error(e.getMessage());
             }
         }
         return -1;
     }
 
-    public static int getTransitionOutputLimit(JastAddList<ToolInfo> toolInfos) {
+    private static int getTransitionOutputLimit(JastAddList<ToolInfo> toolInfos) {
         return getTransitionLimitsInternal(toolInfos, PnmlConstants.OUTPUT_LIMIT_KEY);
     }
 
-    public static int getTransitionInputLimit(JastAddList<ToolInfo> toolInfos) {
+    private static int getTransitionInputLimit(JastAddList<ToolInfo> toolInfos) {
         return getTransitionLimitsInternal(toolInfos, PnmlConstants.INPUT_LIMIT_KEY);
     }
 
+    public static TransitionInformation getTransitionInformation(JastAddList<ToolInfo> toolInfos) {
+
+        TransitionInformation ti = new TransitionInformation();
+        ti.setInputLimit(getTransitionInputLimit(toolInfos));
+        ti.setOutputLimit(getTransitionOutputLimit(toolInfos));
+        ti.setLocation(getLocationFromToolSpecifics(toolInfos));
+        ti.setType(getTransitionTypeFromToolSpecifics(toolInfos));
+
+        if(!ti.getType().equals(PnmlConstants.TRANSITION_TYPE_TOPIC)){
+            ti.setTopic(getTopic(toolInfos));
+        }
+
+        ti.setSubNet(getTransitionSubnetInfo(toolInfos));
+
+        return ti;
+    }
+
+    public static PlaceInformation getPlaceInformation(JastAddList<ToolInfo> toolInfos) {
+
+        PlaceInformation pi = new PlaceInformation();
+        pi.setLocation(getLocationFromToolSpecifics(toolInfos));
+        pi.setSubNet(getPlaceSubnetInfo(toolInfos));
+        pi.setType(getPlaceTypeFromToolSpecifics(toolInfos));
+
+        return pi;
+    }
+
     private static Document parseToolSpecifics(JastAddList<ToolInfo> toolInfos) throws ParserConfigurationException, SAXException, IOException {
 
         StringBuffer toolInfoStringBuffer = toolInfos.getChild(0).getFormattedXMLBuffer();
diff --git a/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java b/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java
index a6953645fefde1906da6825b2ccf93d610f810ef..c89dd32ffc3e4184d9a72028987dc72f4309be08 100644
--- a/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java
+++ b/src/main/java/de/tudresden/inf/st/postprocessing/GlobalToLocalNetsPostProcessor.java
@@ -1,23 +1,121 @@
 package de.tudresden.inf.st.postprocessing;
 
 import de.tudresden.inf.st.pnml.PnmlConstants;
-import de.tudresden.inf.st.pnml.jastadd.model.PetriNet;
-import de.tudresden.inf.st.pnml.jastadd.model.Transition;
+import de.tudresden.inf.st.pnml.jastadd.model.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import java.util.HashSet;
 import java.util.Set;
 
 public class GlobalToLocalNetsPostProcessor implements PostProcessor<PetriNet> {
 
+    private static final Logger logger = LoggerFactory.getLogger(GlobalToLocalNetsPostProcessor.class);
+
     public static PetriNet disconnectNets(PetriNet petriNet){
 
-        Set<Transition> transitionSet = petriNet.allTransitions();
+        Set<Transition> transitionsToAdd = new HashSet<>();
+        Set<Transition> transitionsToRemove = new HashSet<>();
+
+        for(Transition transition : petriNet.allTransitions()){
+
+            InputSignalTransition channelIst = transition.asInputSignalTransition();
+           // logger.error("infos: " + channelIst.getTransitionInformation());
+
+            if(channelIst.getTransitionInformation().getType().equals(PnmlConstants.TRANSITION_TYPE_TOPIC)){
+
+                logger.info("Found topic transition: " + transition.getId());
+
+                // handle refs?
+
+                transitionsToRemove.add(transition);
+
+
+                // STEP 1: Get location/subnet of source/target - places
+                String inLocation = null;
+                String outLocation = null;
+                String inSubNet = null;
+                String outSubNet = null;
+
+                for(Place p : channelIst.incomingPlaces()){
+                    inLocation = p.asOutputSignalPlace().getPlaceInformation().getLocation();
+                    inSubNet = p.asOutputSignalPlace().getPlaceInformation().getSubNet();
+                    break;
+                }
+
+                for(Place p : channelIst.outgoingPlaces()){
+                    outLocation = p.asOutputSignalPlace().getPlaceInformation().getLocation();
+                    outSubNet = p.asOutputSignalPlace().getPlaceInformation().getSubNet();
+                    break;
+                }
+
+                // STEP 1: Create new source and target Transition
+                InputSignalTransition sourceIst = channelIst.treeCopyNoTransform();
+                sourceIst.getName().setText(sourceIst.getName().getText() + "-source");
+                sourceIst.setId(sourceIst.getId() + "-source");
+                sourceIst.getTransitionInformation().setSubNet(inSubNet);
+                sourceIst.getTransitionInformation().setLocation(inLocation);
+
+                // TODO: the attributized infos need to be written back to XML
+                sourceIst.setToolspecificList(new JastAddList<>());
 
-        for(Transition transition : transitionSet){
-            if(transition.type().equals(PnmlConstants.TRANSITION_TYPE_TOPIC)){
-                // transition.incomingPlaces());
+                if(sourceIst.getTransitionInformation().getInputLimit() >= 0 ){
+                    sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_OUT);
+                }else{
+                    sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_OUT);
+                }
+
+                InputSignalTransition targetIst = channelIst.treeCopyNoTransform();
+                targetIst.getName().setText(targetIst.getName().getText() + "-target");
+                targetIst.setId(sourceIst.getId() + "-target");
+                targetIst.getTransitionInformation().setSubNet(outSubNet);
+                targetIst.getTransitionInformation().setLocation(outLocation);
+
+                // TODO: the attributized infos need to be written back to XML
+                targetIst.setToolspecificList(new JastAddList<>());
+
+                if(targetIst.getTransitionInformation().getOutputLimit() >= 0 ){
+                    sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_LIMITED_IN);
+                }else{
+                    sourceIst.getTransitionInformation().setType(PnmlConstants.TRANSITION_TOPIC_TYPE_UNLIMITED_IN);
+                }
+
+
+                // STEP 2: Reconnect Input Signals
+                //for(InputSignalBinding isb : channelIst.getInputSignalBindingList()){
+                //    inputIst.addInputSignalBinding(isb);
+                //}
+
+                // STEP 3: Get all incoming arcs and connect them to new output transition
+                for(Arc arc : channelIst.getInArcList()){
+                    arc.setTarget(sourceIst);
+                    //logger.error("###");
+                    //break;
+                }
+
+                // STEP 4: Gel all outgoing arcs and connect them to new input transition
+                for(Arc arc : channelIst.getOutArcList()){
+                    arc.setSource(targetIst);
+                    //logger.error("+++");
+                    //break;
+                }
+
+                // STEP 5: Add new transitions to net
+                transitionsToAdd.add(sourceIst);
+                transitionsToAdd.add(targetIst);
             }
         }
 
+        // STEP 6: Remove "old transition"
+        petriNet.allTransitions().removeAll(transitionsToRemove);
+        petriNet.allTransitions().addAll(transitionsToAdd);
+
+        return petriNet;
+    }
+
+    private static StringBuffer buildToolSpecifics(String type, String location, String subnet, String inputLimit, String outputLimit){
+
+        // TODO TBD
         return null;
     }
 }
diff --git a/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java b/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java
index 310c538baa909c17cbb0c442eaf19bd868e8d2fe..a13b6652bcfc288b0cea48104387619c04376e6b 100644
--- a/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java
+++ b/src/main/java/de/tudresden/inf/st/postprocessing/IoPetriNetPostProcessor.java
@@ -168,6 +168,7 @@ public class IoPetriNetPostProcessor implements PostProcessor<PetriNet> {
         Document doc = dBuilder.parse(fromStringBuffer(toolInfoStringBuffer));
         doc.getDocumentElement().normalize();
 
+        logger.error("############################# tttttttttttttttttttttttt");
         return doc;
     }
 
diff --git a/src/main/resources/minimal_global.pnml b/src/main/resources/minimal_global.pnml
index c6f66792af382d3d536886ef3bfa5462e7106ffe..4f3abf34df5f9d2ea0fe8f9f1ec6e86561640cae 100644
--- a/src/main/resources/minimal_global.pnml
+++ b/src/main/resources/minimal_global.pnml
@@ -53,8 +53,8 @@
             </place>
             <place id="p2">
                 <toolspecific tool="de.tudresden.inf.st.pnml.distributedPN" version="0.0.1">
-                    <location>node-1</location>
-                    <subnet>subnet-1</subnet>
+                    <location>node-2</location>
+                    <subnet>subnet-2</subnet>
                     <type>discretePlaceType</type>
                     <outputsignalbindings>
                         <outputsignalbinding>
@@ -79,6 +79,8 @@
                         </outputsignalbinding>
                     </outputsignalbindings>
                 </toolspecific>
+                <toolspecific tool="de.tudresden.inf.st.pnml.NEWTOOL" version="0.0.1">
+                </toolspecific>
                 <name>
                     <text>p2</text>
                     <graphics>