Skip to content
Snippets Groups Projects
DirectedGraphTranslator.java 110 KiB
Newer Older
/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
 * ludovic.apvrille AT enst.fr
 * This software is a computer program whose purpose is to allow the
 * edition of TURTLE analysis, design and deployment diagrams, to
 * allow the generation of RT-LOTOS or Java code from this diagram,
 * and at last to allow the analysis of formal validation traces
 * obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
 * from INRIA Rhone-Alpes.
 * This software is governed by the CeCILL  license under French law and
 * abiding by the rules of distribution of free software.  You can  use,
 * modify and/ or redistribute the software under the terms of the CeCILL
 * license as circulated by CEA, CNRS and INRIA at the following URL
 * "http://www.cecill.info".
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL license and that you accept its terms.
 */

maysam zoor's avatar
maysam zoor committed
package ui.simulationtraceanalysis;
import com.mxgraph.layout.hierarchical.mxHierarchicalLayout;
import com.mxgraph.swing.mxGraphComponent;
import org.jgrapht.Graph;
import org.jgrapht.GraphPath;
import org.jgrapht.alg.shortestpath.AllDirectedPaths;
import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
import org.jgrapht.ext.JGraphXAdapter;
import org.jgrapht.graph.DefaultDirectedGraph;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.io.*;
import tmltranslator.*;
import tmltranslator.tomappingsystemc2.DiploSimulatorCodeGenerator;
import ui.TGComponent;
import ui.TGConnectingPoint;
import ui.TGConnector;
import ui.TMLComponentDesignPanel;
import ui.interactivesimulation.SimulationTransaction;
import ui.tmlad.*;
import ui.tmlcompd.TMLCPrimitivePort;

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.*;
import java.util.List;
import java.util.Map.Entry;

/**
 * Class DirectedGraphTranslator: this class generate the directed graph
 * equivalent for the sysml model
 * 23/09/2019
 *
 * @author Maysam Zoor
 */
public class DirectedGraphTranslator extends JApplet {

    // private TMLArchiPanel tmlap; // USed to retrieve the currently opened
    // architecture panel
    // private TMLMapping<TGComponent> tmap;
maysam zoor's avatar
maysam zoor committed
    // private TMLComponentDesignPanel tmlcdp;
    private TMLTask task, task1, task2;
    protected TMLActivity activity;
    int nodeNbProgressBar = 0;
    int nodeNb = 0;
    private TMLActivityElement currentElement;
    private TMLActivityElement backwardElement;
    private ArrayList<String> SummaryCommMapping;
    private Graph<String, DefaultEdge> g;

    public Graph<String, DefaultEdge> getG() {
        return g;
    }

    public void setG(Graph<String, DefaultEdge> g) {
        this.g = g;
    }
    private static final Dimension DEFAULT_SIZE = new Dimension(530, 320);
maysam zoor's avatar
maysam zoor committed
    private List<TMLComponentDesignPanel> cpanels;

    private final List<HwLink> links;
    private final TMLMapping<TGComponent> tmap;
    private final HashMap<String, String> addedEdges = new HashMap<String, String>();
    private final HashMap<String, HashSet<String>> sendEventWaitEventEdges = new HashMap<String, HashSet<String>>();
    private final HashMap<String, HashSet<String>> readWriteChannelEdges = new HashMap<String, HashSet<String>>();
    private final HashMap<String, HashSet<String>> sequenceEdges = new HashMap<String, HashSet<String>>();
    private final HashMap<String, ArrayList<String>> orderedSequenceList = new HashMap<String, ArrayList<String>>();
    private final HashMap<String, HashSet<String>> unOrderedSequenceEdges = new HashMap<String, HashSet<String>>();
    private final HashMap<String, ArrayList<String>> unOrderedSequenceList = new HashMap<String, ArrayList<String>>();
    private final List<String> forEverLoopList = new ArrayList<String>();
    private final HashMap<String, List<TMLTask>> requests = new HashMap<String, List<TMLTask>>();
    private final HashMap<String, HashSet<String>> requestEdges = new HashMap<String, HashSet<String>>();
    private final HashMap<String, List<String>> requestsOriginDestination = new HashMap<String, List<String>>();
    private final HashMap<String, List<String>> requestsPorts = new HashMap<String, List<String>>();
    private final HashMap<String, List<String>> requestsDestination = new HashMap<String, List<String>>();
    private final Vector<String> allLatencyTasks = new Vector<String>();
    private static JScrollPane scrollPane = new JScrollPane();

    // List<String,String> = new ArrayList<String,String>();

    private final HashMap<String, String> nameIDTaskList = new HashMap<String, String>();

    private final HashMap<String, ArrayList<String>> channelPaths = new HashMap<String, ArrayList<String>>();
    public HashMap<String, String> getNameIDTaskList() {
        return nameIDTaskList;
    }

    public JScrollPane getScrollPane() {
        return scrollPane;
    }

    public static void setScrollPane(JScrollPane scrollPane) {
        DirectedGraphTranslator.scrollPane = scrollPane;
    }

    private Object[][] dataByTask = null;
    private Object[][] dataByTaskMinMax = null;
    private Object[][] dataByTaskBYRow;
    private Object[][] dataByTaskHWBYRow;

    HashMap<Integer, List<SimulationTransaction>> dataByTaskR = new HashMap<Integer, List<SimulationTransaction>>();
    HashMap<Integer, List<SimulationTransaction>> dataBydelayedTasks = new HashMap<Integer, List<SimulationTransaction>>();
    HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>> timeDelayedPerRow = new HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>>();
    HashMap<Integer, List<String>> detailsOfMinMaxRow = new HashMap<Integer, List<String>>();
    HashMap<Integer, List<SimulationTransaction>> dataBydelayedTasksOfMinMAx = new HashMap<Integer, List<SimulationTransaction>>();
    private final JFrame frame = new JFrame("The Sys-ML Model As Directed Graph");
    List<Integer> times1 = new ArrayList<Integer>();
    List<Integer> times2 = new ArrayList<Integer>();
    Vector<SimulationTransaction> transFile;
    String idTask1;
    String idTask2;
    String task2DeviceName = "";
    String task1DeviceName = "";
    ArrayList<String> devicesToBeConsidered = new ArrayList<String>();
    Vector<SimulationTransaction> relatedsimTraces = new Vector<SimulationTransaction>();
    Vector<SimulationTransaction> delayDueTosimTraces = new Vector<SimulationTransaction>();
    JFrameLatencyDetailedAnalysis frameLatencyDetailedAnalysis;
    JFrameCompareLatencyDetail frameCompareLatencyDetail;
    int callingFrame;
    int nbOfNodes = 0;
    HashMap<String, ArrayList<ArrayList<Integer>>> runnableTimePerDevice = new HashMap<String, ArrayList<ArrayList<Integer>>>();
    @SuppressWarnings("deprecation")
maysam zoor's avatar
maysam zoor committed
    public DirectedGraphTranslator(JFrameLatencyDetailedAnalysis jFrameLatencyDetailedAnalysis, JFrameCompareLatencyDetail jframeCompareLatencyDetail,
                                   TMLMapping<TGComponent> tmap1, List<TMLComponentDesignPanel> cpanels1, int i) {
maysam zoor's avatar
maysam zoor committed
        setCpanels(cpanels1);

        links = tmap.getTMLArchitecture().getHwLinks();

maysam zoor's avatar
maysam zoor committed
        // tmlcdp = getCpanels().get(0);

        callingFrame = i;

        if (callingFrame == 0)

        {
            frameLatencyDetailedAnalysis = jFrameLatencyDetailedAnalysis;
        } else if (callingFrame == 1) {
            frameCompareLatencyDetail = jframeCompareLatencyDetail;
            // frameCompareLatencyDetail.pack();
            // frameCompareLatencyDetail.revalidate();
            // frameCompareLatencyDetail.repaint();
maysam zoor's avatar
maysam zoor committed
        }
        /*
         * JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String,
         * DefaultEdge>(g);
         *
         * mxHierarchicalLayout layout = new mxHierarchicalLayout(graphAdapter);
         *
         * layout.setInterHierarchySpacing(100); layout.setInterRankCellSpacing(100);
         * layout.setIntraCellSpacing(100);
         *
         * layout.execute(graphAdapter.getDefaultParent());
         *
         * scrollPane.setViewportView(new mxGraphComponent(graphAdapter));
         *
         * scrollPane.setVisible(true);
         *
         * scrollPane.revalidate(); scrollPane.repaint(); frame = new
         * JFrame("The Sys-ML Model As Directed Graph"); frame.add(scrollPane);
         * frame.pack();
         */
        // frame.setVisible(false);

    }

    // The main function to add the vertices and edges according to the model

    private void DrawDirectedGraph() {
maysam zoor's avatar
maysam zoor committed
        nodeNbProgressBar = 0;

        nodeNbProgressBar = tmap.getArch().getBUSs().size() + tmap.getArch().getHwBridge().size() + tmap.getArch().getHwA().size()
                + tmap.getArch().getMemories().size() + tmap.getArch().getCPUs().size();

        for (HwA node : tmap.getArch().getHwA()) {
maysam zoor's avatar
maysam zoor committed

            if (tmap.getLisMappedTasks(node).size() > 0) {
maysam zoor's avatar
maysam zoor committed

                nodeNbProgressBar = tmap.getLisMappedTasks(node).size() + nodeNbProgressBar;
maysam zoor's avatar
maysam zoor committed

                for (TMLTask task : tmap.getLisMappedTasks(node)) {
maysam zoor's avatar
maysam zoor committed

                    nodeNbProgressBar = task.getActivityDiagram().nElements() + nodeNbProgressBar;
        for (HwNode node : tmap.getArch().getCPUs()) {
            if (tmap.getLisMappedTasks(node).size() > 0) {
                nodeNbProgressBar = tmap.getLisMappedTasks(node).size() + nodeNbProgressBar;
maysam zoor's avatar
maysam zoor committed

                for (TMLTask task : tmap.getLisMappedTasks(node)) {
maysam zoor's avatar
maysam zoor committed

                    nodeNbProgressBar = task.getActivityDiagram().nElements() + nodeNbProgressBar;
        HashSet<String> mappedcomm = new HashSet<String>();
        for (HwNode node : tmap.getArch().getBUSs()) {

            if (tmap.getLisMappedChannels(node).size() > 0) {
                for (TMLElement entry : tmap.getLisMappedChannels(node)) {
maysam zoor's avatar
maysam zoor committed

                    if (!mappedcomm.contains(entry.getName())) {
                        mappedcomm.add(entry.getName());
                        nodeNbProgressBar++;
maysam zoor's avatar
maysam zoor committed

        for (HwNode node : tmap.getArch().getHwBridge()) {
            if (tmap.getLisMappedChannels(node).size() > 0) {
maysam zoor's avatar
maysam zoor committed

                for (TMLElement entry : tmap.getLisMappedChannels(node)) {
                    if (!mappedcomm.contains(entry.getName())) {
                        mappedcomm.add(entry.getName());
                        nodeNbProgressBar++;
maysam zoor's avatar
maysam zoor committed

        for (HwNode node : tmap.getArch().getMemories()) {
            if (tmap.getLisMappedChannels(node).size() > 0) {
                for (TMLElement entry : tmap.getLisMappedChannels(node)) {
                    if (!mappedcomm.contains(entry.getName())) {
                        mappedcomm.add(entry.getName());
                        nodeNbProgressBar++;
maysam zoor's avatar
maysam zoor committed

        for (TMLChannel ch : tmap.getTMLModeling().getChannels()) {
            if (!mappedcomm.contains(ch.getName())) {
                mappedcomm.add(ch.getName());
maysam zoor's avatar
maysam zoor committed

maysam zoor's avatar
maysam zoor committed

        if (callingFrame == 0)
maysam zoor's avatar
maysam zoor committed

        {
            frameLatencyDetailedAnalysis.pbar.setMaximum(nodeNbProgressBar);
            frameLatencyDetailedAnalysis.pbar.setMinimum(0);
        if (callingFrame == 1)
        {
            frameCompareLatencyDetail.pbar.setMaximum(nodeNbProgressBar);
            frameCompareLatencyDetail.pbar.setMinimum(0);
        }
        HashMap<String, HashSet<String>> cpuTasks;
        HashMap<String, HashSet<TMLElement>> buschannel = new HashMap<String, HashSet<TMLElement>>();
        HashMap<String, HashSet<TMLElement>> memorychannel = new HashMap<String, HashSet<TMLElement>>();
        HashMap<String, HashSet<TMLElement>> bridgechannel = new HashMap<String, HashSet<TMLElement>>();
        HashMap<String, HashSet<TMLTask>> cpuTask = new HashMap<String, HashSet<TMLTask>>();
        g = new DefaultDirectedGraph<>(DefaultEdge.class);
        for (HwNode node : tmap.getArch().getBUSs()) {
maysam zoor's avatar
maysam zoor committed

            if (!g.containsVertex(node.getName())) {
                g.addVertex(node.getName());
maysam zoor's avatar
maysam zoor committed

                updatemainBar("getBUSs");
            if (tmap.getLisMappedChannels(node).size() > 0) {
                buschannel.put(node.getName(), tmap.getLisMappedChannels(node));
        for (HwNode node : tmap.getArch().getHwBridge()) {
            if (!g.containsVertex(node.getName())) {
                g.addVertex(node.getName());
                updatemainBar("getHwBridge");
            }

            if (tmap.getLisMappedChannels(node).size() > 0) {
                bridgechannel.put(node.getName(), tmap.getLisMappedChannels(node));
        for (HwA node : tmap.getArch().getHwA()) {
maysam zoor's avatar
maysam zoor committed
            cpuTask = new HashMap<String, HashSet<TMLTask>>();
            if (tmap.getLisMappedTasks(node).size() > 0) {
maysam zoor's avatar
maysam zoor committed

                cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));

            }

            cpuTasks = getCPUTaskMap(cpuTask);

            // if (tmap.getLisMappedChannels(node).size() > 0) {
            // bridgechannel.put(node.getName(), tmap.getLisMappedChannels(node));
        for (HwNode node : tmap.getArch().getMemories()) {
            if (!g.containsVertex(node.getName())) {
                g.addVertex(node.getName());
                updatemainBar("getMemories");

            }

            if (tmap.getLisMappedChannels(node).size() > 0) {
                memorychannel.put(node.getName(), tmap.getLisMappedChannels(node));
        for (Entry<String, HashSet<TMLElement>> entry : buschannel.entrySet()) {
            String busName = entry.getKey();
            HashSet<TMLElement> busChList = entry.getValue();
            for (TMLElement busCh : busChList) {
                String ChannelName = busCh.getName();
                if (!g.containsVertex(ChannelName)) {
                    g.addVertex(ChannelName);
                    updatemainBar("ChannelName");
                g.addEdge(busName, ChannelName);

                TMLChannel tmlch = (TMLChannel) busCh;

                String writeChannel = tmlch.getDestinationTask().getName() + "__" + "writechannel:" + tmlch.getDestinationPort();
                String readChannel;
        for (Entry<String, HashSet<TMLElement>> entry : bridgechannel.entrySet()) {
            String busName = entry.getKey();
            HashSet<TMLElement> busChList = entry.getValue();
            for (TMLElement busCh : busChList) {
                String ChannelName = busCh.getName();
                if (!g.containsVertex(ChannelName)) {
                    g.addVertex(ChannelName);
                    updatemainBar("ChannelName");
                g.addEdge(busName, ChannelName);
        for (Entry<String, HashSet<TMLElement>> entry : memorychannel.entrySet()) {
            String busName = entry.getKey();
            HashSet<TMLElement> busChList = entry.getValue();
            for (TMLElement busCh : busChList) {
                String ChannelName = busCh.getName();
                if (!g.containsVertex(ChannelName)) {
                    g.addVertex(ChannelName);
                    updatemainBar("ChannelName");
                g.addEdge(busName, ChannelName);
        DiploSimulatorCodeGenerator gen = new DiploSimulatorCodeGenerator(tmap);
        for (TMLChannel ch : tmap.getTMLModeling().getChannels()) {
            List<HwCommunicationNode> pathNodes = gen.determineRoutingPath(tmap.getHwNodeOf(ch.getOriginTask()),
                    tmap.getHwNodeOf(ch.getDestinationTask()), ch);
            if (!g.vertexSet().contains(ch.getName())) {
                g.addVertex(ch.getName());
                updatemainBar(ch.getName());
            }
            if (!pathNodes.isEmpty()) {
                for (HwCommunicationNode node : pathNodes) {
                    if (channelPaths.containsKey(ch.getName())) {
                        if (!channelPaths.get(ch.getName()).contains(node.getName())) {
                            channelPaths.get(ch.getName()).add(node.getName());
                        }
                    } else {
                        ArrayList<String> pathNodeNames = new ArrayList<String>();
                        pathNodeNames.add(node.getName());
                        channelPaths.put(ch.getName(), pathNodeNames);
                    }
                    if (!g.containsEdge(node.getName(), ch.getName())) {
                        g.addEdge(node.getName(), ch.getName());
                    }
        SummaryCommMapping = tmap.getSummaryCommMapping();
        for (HwNode node : tmap.getArch().getCPUs()) {
            cpuTask = new HashMap<String, HashSet<TMLTask>>();
            if (tmap.getLisMappedTasks(node).size() > 0) {
                cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
            cpuTasks = getCPUTaskMap(cpuTask);
        for (HwLink link : links) {
            if (g.containsVertex(link.hwnode.getName()) && g.containsVertex(link.bus.getName())) {
                g.addEdge(link.hwnode.getName(), link.bus.getName());
                g.addEdge(link.bus.getName(), link.hwnode.getName());
            }
        if (addedEdges.size() > 0) {
            for (Entry<String, String> edge : addedEdges.entrySet()) {
                g.addEdge(edge.getKey(), edge.getValue());
        if (sendEventWaitEventEdges.size() > 0) {
            for (Entry<String, HashSet<String>> edge : sendEventWaitEventEdges.entrySet()) {
                for (String waitEventEdge : edge.getValue())
                    g.addEdge(edge.getKey(), waitEventEdge);
        if (readWriteChannelEdges.size() > 0) {
            for (Entry<String, HashSet<String>> edge : readWriteChannelEdges.entrySet()) {
                for (String readChannelEdge : edge.getValue())
                    g.addEdge(edge.getKey(), readChannelEdge);
        if (sequenceEdges.size() > 0) {
            for (Entry<String, HashSet<String>> edge : sequenceEdges.entrySet()) {
                for (String sequenceEdge : edge.getValue())
                    g.addEdge(edge.getKey(), sequenceEdge);
        if (unOrderedSequenceEdges.size() > 0) {
            for (Entry<String, HashSet<String>> edge : unOrderedSequenceEdges.entrySet()) {
                for (String sequenceEdge : edge.getValue())
maysam zoor's avatar
maysam zoor committed

                    g.addEdge(edge.getKey(), sequenceEdge);
maysam zoor's avatar
maysam zoor committed

maysam zoor's avatar
maysam zoor committed

        if (requestEdges.size() > 0) {
maysam zoor's avatar
maysam zoor committed

            for (Entry<String, HashSet<String>> edge : requestEdges.entrySet()) {
                for (String requestsingleEdges : edge.getValue()) {

                    g.addEdge(edge.getKey(), requestsingleEdges);
maysam zoor's avatar
maysam zoor committed

    // draw the vertices and edges for the tasks mapped to the CPUs
    private void updatemainBar(String string) {
        if (callingFrame == 0)
        {
            frameLatencyDetailedAnalysis.updateBar(nbOfNodes);
        } else if (callingFrame == 1) {
            frameCompareLatencyDetail.updateBar(nbOfNodes);
    public HashMap<String, HashSet<String>> getCPUTaskMap(HashMap<String, HashSet<TMLTask>> cpuTask) {
        HashMap<String, HashSet<String>> cpuTaskMap = new HashMap<String, HashSet<String>>();
        if (tmap == null) {
            return cpuTaskMap;
        for (Entry<String, HashSet<TMLTask>> entry : cpuTask.entrySet()) {
            String key = entry.getKey();
            HashSet<TMLTask> value = entry.getValue();
            Vector<TMLActivityElement> multiNexts = new Vector<TMLActivityElement>();
            TMLActivityElement elt;
            // Map <String, String> sendEvt;
            HashMap<String, List<String>> sendEvt = new HashMap<String, List<String>>();
            HashMap<String, List<String>> waitEvt = new HashMap<String, List<String>>();
            HashMap<String, String> sendData = new HashMap<String, String>();
            HashMap<String, String> receiveData = new HashMap<String, String>();
            // GEt List of all requests
            for (TMLTask task : value) {
                if (task.isRequested()) {
                    TMLRequest requestToTask = task.getRequest();
                    requestToTask.getReferenceObject();
                    requestToTask.getDestinationTask();
                    requestToTask.getOriginTasks().get(0);
                    requestToTask.ports.get(0).getName();
                    requestToTask.getExtendedName();
                    String destinationRequest = requestToTask.getDestinationTask().getName() + "__"
                            + requestToTask.getDestinationTask().getActivityDiagram().get(0).getName() + "__"
                            + requestToTask.getDestinationTask().getActivityDiagram().get(0).getID();
                    String destinationRequestName = requestToTask.getDestinationTask().getName();
                    for (TMLTask originTask : requestToTask.getOriginTasks()) {
                        String requestOriginTaskName = originTask.getName();
                        if (requestsOriginDestination.containsKey(requestOriginTaskName)) {
                            if (!requestsOriginDestination.get(requestOriginTaskName).contains(destinationRequestName)) {
                                requestsOriginDestination.get(requestOriginTaskName).add(destinationRequestName);
                            }
                        } else {
                            ArrayList<String> destinationRequestNames = new ArrayList<String>();
                            destinationRequestNames.add(destinationRequestName);
                            requestsOriginDestination.put(requestOriginTaskName, destinationRequestNames);
                        }
                    for (TMLCPrimitivePort requestsPort : requestToTask.ports) {
                        String requestsPortName = requestsPort.getPortName();
                        if (requestsPorts.containsKey(task.getName())) {
                            if (!requestsPorts.get(task.getName()).contains(requestsPortName)) {
                                requestsPorts.get(task.getName()).add(requestsPortName);
                            }
                        } else {
                            ArrayList<String> requestsPortNames = new ArrayList<String>();
                            requestsPortNames.add(requestsPortName);
                            requestsPorts.put(task.getName(), requestsPortNames);
                        }
                    if (requestsDestination.containsKey(destinationRequestName)) {
                        if (!requestsDestination.get(destinationRequestName).contains(destinationRequest)) {
                            requestsDestination.get(destinationRequestName).add(destinationRequest);
                        }
                    } else {
                        ArrayList<String> destinationRequestNames = new ArrayList<String>();
                        destinationRequestNames.add(destinationRequest);
                        requestsDestination.put(destinationRequestName, destinationRequestNames);
            for (TMLTask task : value) {
                /*
                 * for (TMLComponentDesignPanel dpPanel : getCpanels()) { String[] taskpanel =
                 * task.getName().split("__");
                 *
                 * if (dpPanel.getNameOfTab().equals(taskpanel[0])) { tmlcdp = dpPanel; }
                 *
                 * }
                 */
                // get the names and params of send events per task and their corresponding wait
                // events
                for (TMLSendEvent sendEvent : task.getSendEvents()) {
                    TMLCPrimitivePort sendingPortdetails = sendEvent.getEvent().port;
                    TMLCPrimitivePort receivePortdetails = sendEvent.getEvent().port2;
                    String sendingPortparams = sendEvent.getAllParams();
                    TMLTask destinationTasks = sendEvent.getEvent().getDestinationTask();
                    sendEvt.put("sendevent:" + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")", new ArrayList<String>());
                    for (TMLWaitEvent wait_sendEvent : destinationTasks.getWaitEvents()) {
                        String receivePortparams = wait_sendEvent.getAllParams();
                        sendEvt.get("sendevent:" + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")")
                                .add("waitevent:" + receivePortdetails.getPortName() + "(" + receivePortparams + ")");
                }
                // get the names of read channels per task and their corresponding write
                // channels
                for (TMLReadChannel readChannel : task.getReadChannels()) {
                    int i = readChannel.getNbOfChannels();
                    for (int j = 0; j < i; j++) {
                        String sendingDataPortdetails = readChannel.getChannel(j).getOriginPort().getName();
                        String receiveDataPortdetails = readChannel.getChannel(j).getDestinationPort().getName();
                        if (!sendingDataPortdetails.equals(receiveDataPortdetails)) {
                            receiveData.put(receiveDataPortdetails, sendingDataPortdetails);
                }
                // get the names of write channels per task and their corresponding read
                // channels
                for (TMLWriteChannel writeChannel : task.getWriteChannels()) {
                    int i = writeChannel.getNbOfChannels();
                    for (int j = 0; j < i; j++) {
                        // writeChannel.getChannel(j);
                        String sendingDataPortdetails = writeChannel.getChannel(j).getOriginPort().getName();
                        String receiveDataPortdetails = writeChannel.getChannel(j).getDestinationPort().getName();
                        if (!sendingDataPortdetails.equals(receiveDataPortdetails)) {
                            sendData.put(sendingDataPortdetails, receiveDataPortdetails);
                        }
                }
                // get the names and params of wait events per task and their corresponding send
                // events
                for (TMLWaitEvent waitEvent : task.getWaitEvents()) {
                    // TMLCPrimitivePort portdetails = waitEvent.getEvent().port;
                    TMLCPrimitivePort sendingPortdetails = waitEvent.getEvent().port;
                    TMLCPrimitivePort receivePortdetails = waitEvent.getEvent().port2;
                    String receivePortparams = waitEvent.getAllParams();
                    // tmlcdp.tmlctdp.getAllPortsConnectedTo(portdetails);
                    waitEvt.put("waitevent:" + receivePortdetails.getPortName() + "(" + receivePortparams + ")", new ArrayList<String>());
                    TMLTask originTasks = waitEvent.getEvent().getOriginTask();
                    for (TMLSendEvent wait_sendEvent : originTasks.getSendEvents()) {
                        String sendingPortparams = wait_sendEvent.getAllParams();
                        waitEvt.get("waitevent:" + receivePortdetails.getPortName() + "(" + receivePortparams + ")")
                                .add("sendevent:" + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")");
                // add the name of the task as a vertex
                if (!g.vertexSet().contains(key)) {
                    g.addVertex(key);
                    updatemainBar(key);
                }
                if (!g.vertexSet().contains(task.getName())) {
                    g.addVertex(task.getName());
                    updatemainBar(task.getName());
                g.addEdge(key, task.getName());
                activity = task.getActivityDiagram();
                currentElement = activity.getFirst();
                String taskStartName = "";
                String taskEndName = "";
                int countTillStart = 0;
                boolean hasSequence = false;
                boolean hasForLoop = false;
                HashMap<String, List<String>> forLoopNextValues = new HashMap<String, List<String>>();
                // loop over all the activites corresponding to a task
                while (count <= activity.nElements()) {
                    String eventName;
                    String preEventName;
                    if (currentElement.getName().equals("Stop after infinite loop")) {
                        if (count <= activity.nElements()) {
                            if (currentElement.getNexts().size() == 1) {

                                currentElement = currentElement.getNexts().firstElement();

                            } else if (!multiNexts.isEmpty()) {
                                currentElement = multiNexts.get(0);
                                multiNexts.remove(0);
                            continue;
                        } else {
                            break;
                        }
                    } else if (currentElement.getReferenceObject() instanceof TMLADRandom) {
                        eventName = task.getName() + "__" + currentElement.getName() + "__" + currentElement.getID();
                    } else {
                        eventName = task.getName() + "__" + currentElement.getReferenceObject().toString() + "__" + currentElement.getID();

                    }
                    updatemainBar(eventName);
                    if (currentElement.getNexts().size() > 1) {
                        for (TMLActivityElement ae : currentElement.getNexts()) {
                            multiNexts.add(ae);
                    }

                    // in case an end was encountered , the previous activities should be checked:
                    // in
                    // case it is an end for a loop or sequence speavial edges should be added
                    if (currentElement.getReferenceObject() instanceof TMLADStopState) {
                        taskEndName = task.getName() + "__" + currentElement.getName() + "__" + currentElement.getID();
                        preEventName = task.getName() + "__" + activity.getPrevious(currentElement).getReferenceObject().toString() + "__"
                                + activity.getPrevious(currentElement).getID();
                        g.addVertex(taskEndName);
                        // allTasks.add(taskEndName);
                        if (!(activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADSequence)) {
                            g.addEdge(preEventName, taskEndName);
                        @SuppressWarnings({"unchecked", "rawtypes"})
                        AllDirectedPaths<String, DefaultEdge> allPaths = new AllDirectedPaths<String, DefaultEdge>(g);
                        if (orderedSequenceList.size() > 0) {
                            int noForLoop = 0;
                            // get path from sequence to end
                            for (Entry<String, ArrayList<String>> sequenceListEntry : orderedSequenceList.entrySet()) {
                                int directlyConnectedSeq = 0;
                                if (g.containsVertex(sequenceListEntry.getKey())) {
                                    List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(sequenceListEntry.getKey(), taskEndName, false,
                                            g.vertexSet().size());
                                    for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList.entrySet()) {
                                        for (int i = 0; i < path.size(); i++) {
                                            if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
                                                if (path.get(i).getVertexList().contains(othersequenceListEntryValue.getKey())) {
                                                    directlyConnectedSeq++;
                                    if (path.size() > 0 && sequenceListEntry.getValue().size() > 0 && directlyConnectedSeq == 0) {
                                        for (int i = 0; i < path.size(); i++) {
                                            for (String sequenceListEntryValue : sequenceListEntry.getValue()) {
                                                if (g.containsVertex(sequenceListEntryValue)) {
                                                    if (path.get(i).getVertexList().contains(sequenceListEntryValue)) {
                                                        if (forLoopNextValues.size() > 0) {
                                                            for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
                                                                if (path.get(i).getVertexList().contains(forloopListEntry.getValue().get(0))) {
                                                        if (forEverLoopList.size() > 0) {
                                                            for (String forloopListEntry : forEverLoopList) {
                                                                if (path.get(i).getVertexList().contains(forloopListEntry)) {
                                                            int nextIndex = sequenceListEntry.getValue().indexOf(sequenceListEntryValue) + 1;
                                                            if (nextIndex < sequenceListEntry.getValue().size()) {
maysam zoor's avatar
maysam zoor committed

                                                                HashSet<String> endSequenceVertex = new HashSet<String>();
                                                                endSequenceVertex.add(sequenceListEntry.getValue().get(nextIndex));
                                                                if (sequenceEdges.containsKey(taskEndName)) {
                                                                    if (!sequenceEdges.get(taskEndName)
                                                                            .contains(sequenceListEntry.getValue().get(nextIndex))) {
                                                                        sequenceEdges.get(taskEndName)
                                                                                .add(sequenceListEntry.getValue().get(nextIndex));
                                                                    }
                                                                    sequenceEdges.put(eventName, endSequenceVertex);
                                                            } else if (nextIndex == sequenceListEntry.getValue().size()
                                                                    && orderedSequenceList.size() > 1) {
                                                                for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList
                                                                        .entrySet()) {
                                                                    if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
                                                                        List<GraphPath<String, DefaultEdge>> pathBetweenSeq = allPaths.getAllPaths(
                                                                                othersequenceListEntryValue.getKey(), taskEndName, false,
                                                                                g.vertexSet().size());
                                                                        for (int j = 0; j < pathBetweenSeq.size(); j++) {
                                                                            for (Entry<String, ArrayList<String>> adjacentsequenceListEntryValue : orderedSequenceList