VissimNetworkLaneParser.java

package org.opentrafficsim.road.network.factory.vissim;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.net.URL;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

import javax.naming.NamingException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.locationtech.jts.geom.LineString;
import org.opentrafficsim.core.dsol.OTSSimulatorInterface;
import org.opentrafficsim.core.geometry.OTSGeometryException;
import org.opentrafficsim.core.geometry.OTSLine3D;
import org.opentrafficsim.core.gtu.GTUException;
import org.opentrafficsim.core.gtu.GTUType;
import org.opentrafficsim.core.network.NetworkException;
import org.opentrafficsim.road.network.OTSRoadNetwork;
import org.opentrafficsim.road.network.lane.LaneType;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import nl.tudelft.simulation.dsol.SimRuntimeException;
import nl.tudelft.simulation.dsol.simulators.DEVSSimulatorInterface;

/**
 * <p>
 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
 * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
 * <p>
 * $LastChangedDate: 2015-07-24 02:58:59 +0200 (Fri, 24 Jul 2015) $, @version $Revision: 1147 $, by $Author: averbraeck $,
 * initial version Jul 23, 2015 <br>
 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
 */
public class VissimNetworkLaneParser implements Serializable
{
    /** */
    private static final long serialVersionUID = 20150723L;

    /** Global values from the GLOBAL tag. */
    private GlobalTag globalTag;

    /** The UNprocessed links for further reference. */
    private Map<String, NodeTag> nodeTags = new LinkedHashMap<>();

    /** The UNprocessed links for further reference. */
    private Map<String, LinkTag> linkTags = new LinkedHashMap<>();

    /** The UNprocessed links for further reference. */
    private Map<String, LinkTag> connectorTags = new LinkedHashMap<>();

    /** The UNprocessed links for further reference. */
    private Map<String, LinkTag> realLinkTags = new LinkedHashMap<>();

    /** The UNprocessed links for further reference. */
    private Map<String, SignalHeadTag> signalHeadTags = new LinkedHashMap<>();

    /** The UNprocessed links for further reference. */
    private Map<String, SensorTag> sensorTags = new LinkedHashMap<>();

    /** The gtu tags for further reference. */
    private Map<String, GTUTag> gtuTags = new LinkedHashMap<>();

    /** The gtumix tags for further reference. */
    private Map<String, GTUMixTag> gtuMixTags = new LinkedHashMap<>();

    /** The road type tags for further reference. */
    private Map<String, RoadTypeTag> roadTypeTags = new LinkedHashMap<>();

    /** The GTUTypes that have been created. public to make it accessible from LaneAttributes. */
    private Map<String, GTUType> gtuTypes = new LinkedHashMap<>();

    /** The LaneType tags that have been created. */
    private Map<String, LaneTypeTag> laneTypeTags = new LinkedHashMap<>();

    /** The LaneType tags that have been created. */
    private Map<String, RoadLayoutTag> roadLayoutTags = new LinkedHashMap<>();

    /** The RouteMix tags that have been created. */
    private Map<String, RouteMixTag> routeMixTags = new LinkedHashMap<>();

    /** The RouteMix tags that have been created. */
    private Map<String, ShortestRouteMixTag> shortestRouteMixTags = new LinkedHashMap<>();

    /** The RouteMix tags that have been created. */
    private Map<String, ShortestRouteTag> shortestRouteTags = new LinkedHashMap<>();

    /** The RouteMix tags that have been created. */
    private Map<String, RouteTag> routeTags = new LinkedHashMap<>();

    /** The LaneTypes that have been created. */
    private Map<String, LaneType> laneTypes = new LinkedHashMap<>();

    /** The simulator for creating the animation. Null if no animation needed. */
    private OTSSimulatorInterface simulator;

    /** The network to register the GTUs in. */
    @SuppressWarnings("visibilitymodifier")
    protected OTSRoadNetwork network;

    /*****
     * Variables, typically for Vissim network import
     */

    /** the node number is automatically generated and increases with every additional node. */
    private int upperNodeNr = 1;

    /** the node number is automatically generated and increases with every additional node. */
    private int upperLinkNr = 1;

    /**
     * @param simulator OTSSimulatorInterface; the simulator for creating the animation. Null if no animation needed.
     */
    public VissimNetworkLaneParser(final OTSSimulatorInterface simulator)
    {
        this.simulator = simulator;
    }

    /**
     * @param inputUrl URL; input
     * @param outputFile File; output file
     * @param network OTSRoadNetwork; network
     * @param sinkKillClassName String; name of the sink-sensor class
     * @param sensorClassName String; name of the sensor class
     * @param trafficLightName String; name of the trafficLight class
     * @return the network with Nodes, Links, and Lanes.
     * @throws NetworkException in case of parsing problems.
     * @throws SAXException in case of parsing problems.
     * @throws ParserConfigurationException in case of parsing problems.
     * @throws IOException in case of file reading problems.
     * @throws NamingException in case the animation context cannot be found
     * @throws GTUException in case of a problem with creating the LaneBlock (which is a GTU right now)
     * @throws OTSGeometryException when construction of a lane contour or offset design line fails
     * @throws SimRuntimeException when simulator cannot be used to schedule GTU generation
     */
    @SuppressWarnings("checkstyle:needbraces")
    public OTSRoadNetwork build(final URL inputUrl, final File outputFile, final OTSRoadNetwork network,
            final String sinkKillClassName, final String sensorClassName, final String trafficLightName)
            throws NetworkException, ParserConfigurationException, SAXException, IOException, NamingException, GTUException,
            OTSGeometryException, SimRuntimeException
    {
        if (inputUrl.getFile().length() > 0 && !(new File(inputUrl.getFile()).exists()))
        {
            throw new SAXException("XmlNetworkLaneParser.build: File url.getFile() does not exist");
        }

        // starts with the creation of an empty network
        this.network = network;

        // prepare for reading the XML document
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setXIncludeAware(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse(inputUrl.openStream());
        NodeList networkXMLNodeList = document.getDocumentElement().getChildNodes();

        // Is it a Vissim network?
        if (!document.getDocumentElement().getNodeName().equals("network"))
        {
            throw new SAXException("XmlNetworkLaneParser.build: XML document does not start with an NETWORK tag, found "
                    + document.getDocumentElement().getNodeName() + " instead");
        }

        // make the GTUTypes ALL and NONE to get started
        this.gtuTypes.put("ALL", network.getGtuType(GTUType.DEFAULTS.VEHICLE));
        // this.gtuTypes.put("NONE", GTUType.NONE);

        // Read the link (and connector) tags and ...
        // Construct the nodes as Vissim does not use Nodes!!
        LinkTag.parseLinks(networkXMLNodeList, this);

        // the signal heads are stored separately. Read them first, connect to links later on
        SignalHeadTag.parseSignalHead(networkXMLNodeList, this);

        // the sensor are defined separate also. Read them first, connect to links later on
        SensorTag.parseSensor(networkXMLNodeList, this);

        // add the signalHeads to the links
        LinkTag.addSignalHeads(this);

        // add the detectors to the links
        LinkTag.addDetectors(this);

        // create a subset of connector links
        for (LinkTag linkTag : this.linkTags.values())
        {
            if (linkTag.connector)
            {
                this.connectorTags.put(linkTag.name, linkTag);
            }
            else
            {
                this.realLinkTags.put(linkTag.name, linkTag);
            }
        }

        // removes all duplicate nodes, both in Link and Node lists
        NodeTag.removeDuplicateNodes(this);
        // Split links where appropriate
        // Step 1: split links, where a connector intersects a link
        // loops through all connectors
        // a link gets split if the connector is more than a "margin" number of meters from the start or end of a link
        Double margin = 5.0;
        splitLinksIntersectedByConnector(margin);

        // create space between connectors and links, in order to make bezier curved links between connectors and links
        // action: the connectors become shorter than they were
        // LinkTag.shortenConnectors(this);

        // Create links to connect the shortened connectors and links by means of bezier curved links
        createLinkBetweenConnectorAndLink(this);

        // Step 2: split links directly behind a signal head, assuming such a link enters a signalized junction
        //
        Double splitMetersAfterSignalHead = 1.5;
        margin = 4.0;
        splitLinkAtSignalAndDetector(this.linkTags, margin, splitMetersAfterSignalHead);

        // remove double links with the same start and end node
        LinkedHashMap<String, LinkTag> removeConnectorTags = new LinkedHashMap<>();
        removeDoubleConnectors(removeConnectorTags);

        // build links
        for (LinkTag linkTag : this.linkTags.values())
        {
            Links.buildLink(linkTag, this, this.simulator);
        }

        // Generate the real links
        for (LinkTag realLinkTag : this.linkTags.values())
        {
            Links.applyRoadTypeToLink(realLinkTag, this, this.simulator);
        }

        // Generate sink/kill sensors at the links that have no further connections (dead-walking)
        for (LinkTag realLinkTag : this.linkTags.values())
        {
            Links.createSinkSensor(realLinkTag, this, this.simulator);
        }

        // generate the connector links
        for (LinkTag connectorTag : this.linkTags.values())
        {
            Links.applyRoadTypeToConnector(connectorTag, this, this.simulator);
        }

        NodeTag.removeRedundantNodeTags(this);

        // process the routes
        // for (RouteTag routeTag : this.routeTags.values())
        // routeTag.makeRoute();
        // TODO shortestRoute, routeMix, ShortestRouteMix

        // store the structure information in the network
        XMLNetworkWriter.writeToXML(outputFile, linkTags, nodeTags, sinkKillClassName, sensorClassName, trafficLightName);

        return makeNetwork();
    }

    private void removeDoubleConnectors(HashMap<String, LinkTag> removeConnectorTags)
    {
        for (LinkTag linkTag : this.connectorTags.values())
        {
            for (LinkTag linkTag2 : this.connectorTags.values())
            {
                if (linkTag.nodeStartTag.name.equals(linkTag2.nodeStartTag.name)
                        && linkTag.nodeEndTag.name.equals(linkTag2.nodeEndTag.name) && !linkTag.equals(linkTag2))
                {
                    removeConnectorTags.put(linkTag.nodeStartTag.name + linkTag.nodeEndTag.name, linkTag);
                }
            }
        }
        for (Entry<String, LinkTag> entry : removeConnectorTags.entrySet())
        {
            connectorTags.remove(entry.getValue().name);
            linkTags.remove(entry.getValue().name);
        }
    }

    /**
     * @param parser VissimNetworkLaneParser;
     * @throws OTSGeometryException
     */
    private void createLinkBetweenConnectorAndLink(final VissimNetworkLaneParser parser) throws OTSGeometryException
    {
        // loop through all connector links
        for (LinkTag connectorLinkTag : this.connectorTags.values())
        {

            OTSLine3D designLineOTS = LinkTag.createLineString(connectorLinkTag);
            LineString designLine = designLineOTS.getLineString();
            Double length = designLine.getLength();
            // default: we replace the connector link by a bezier curved link
            if (length < 999995)
            {
                connectorLinkTag.nodeStartTag = parser.nodeTags.get(connectorLinkTag.connectorTag.fromNodeName);
                connectorLinkTag.nodeEndTag = parser.nodeTags.get(connectorLinkTag.connectorTag.toNodeName);
                connectorLinkTag.bezierTag = new BezierTag();
                if (connectorLinkTag.nodeStartTag.name.equals(connectorLinkTag.nodeEndTag.name))
                {
                    this.linkTags.remove(connectorLinkTag.name);
                    // this.connectorTags.remove(connectorLinkTag.name);
                }
                if (connectorLinkTag.polyLineTag != null)
                {
                    connectorLinkTag.polyLineTag = null;
                }
                if (connectorLinkTag.straightTag != null)
                {
                    connectorLinkTag.straightTag = null;
                }
            }
            // if the link is quite long....we could split it but we don't do this now
            // so the next block is inactive!!!
            else
            {
                // get the from link
                LinkTag pasteLinkFromTag = new LinkTag(connectorLinkTag);
                // add a unique name
                String linkName = "" + parser.upperLinkNr;
                parser.upperLinkNr++;
                pasteLinkFromTag.name = linkName;
                pasteLinkFromTag.nodeStartTag = parser.nodeTags.get(connectorLinkTag.connectorTag.fromNodeName);
                pasteLinkFromTag.nodeEndTag = connectorLinkTag.nodeStartTag;
                pasteLinkFromTag.bezierTag = new BezierTag();
                if (pasteLinkFromTag.polyLineTag != null)
                {
                    pasteLinkFromTag.polyLineTag = null;
                }
                if (pasteLinkFromTag.straightTag != null)
                {
                    pasteLinkFromTag.straightTag = null;
                }
                // this.linkTags.put(pasteLinkFromTag.name, pasteLinkFromTag);

                // get the To link
                LinkTag pasteLinkToTag = new LinkTag(connectorLinkTag);
                linkName = "" + parser.upperLinkNr;
                parser.upperLinkNr++;
                pasteLinkToTag.name = linkName;
                pasteLinkToTag.nodeStartTag = connectorLinkTag.nodeEndTag;
                pasteLinkToTag.nodeEndTag = parser.nodeTags.get(connectorLinkTag.connectorTag.toNodeName);

                pasteLinkToTag.bezierTag = new BezierTag();
                if (pasteLinkToTag.polyLineTag != null)
                {
                    pasteLinkToTag.polyLineTag = null;
                }
                if (pasteLinkToTag.straightTag != null)
                {
                    pasteLinkToTag.straightTag = null;
                }
                // this.linkTags.put(pasteLinkToTag.name, pasteLinkToTag);

            }
            // }
        }
    }

    private void splitLinkAtSignalAndDetector(Map<String, LinkTag> inputLinkTags, Double margin,
            Double splitMetersAfterSignalHead) throws OTSGeometryException, NetworkException
    {

        Map<String, LinkTag> newLinkTags = new LinkedHashMap<>();
        // Loops through all links
        splitLinksAtSignal(margin, splitMetersAfterSignalHead, inputLinkTags, newLinkTags);

    }

    private void splitLinksAtSignal(Double margin, Double splitMetersAfterSignalHead, Map<String, LinkTag> inputLinkTags,
            Map<String, LinkTag> newLinkTags) throws OTSGeometryException, NetworkException
    {
        for (LinkTag linkTag : inputLinkTags.values())
        {
            for (SignalHeadTag signalHeadTag : linkTag.signalHeads)
            {
                Double position = Double.parseDouble(signalHeadTag.positionStr);
                Double splitPosition = position + splitMetersAfterSignalHead;
                // A new node has to be created
                NodeTag newNodeTag = NodeTag.createNewNodeAtLinkPosition(linkTag, this, splitPosition);
                // split the link and connect the new node after the position of the signalhead\
                Map<String, LinkTag> newLinks = LinkTag.splitLink(newNodeTag, linkTag, this, splitPosition, margin, false);
                if (newLinks != null)
                {
                    newLinkTags.putAll(newLinks);
                }
            }
            linkTag.signalHeads.removeAll(linkTag.signalHeadsToRemove);
            linkTag.sensors.removeAll(linkTag.sensorTagsToRemove);
            // relocate the signalHeads and detectors afterwards!
        }
        if (!newLinkTags.isEmpty())
        {
            this.linkTags.putAll(newLinkTags);
        }

        // run again for the newly created linkTags
        Map<String, LinkTag> new2LinkTags = new LinkedHashMap<>();
        if (newLinkTags.size() > 0)
        {
            splitLinksAtSignal(margin, splitMetersAfterSignalHead, newLinkTags, new2LinkTags);
        }
    }

    private void splitLinksIntersectedByConnector(Double margin) throws OTSGeometryException, NetworkException
    {
        // loop through all connector links
        for (LinkTag connectorLinkTag : this.connectorTags.values())
        {
            // ***********************
            // 1: connector meets link:
            // get the position where this connector intersects the Link. Here the link will be split
            Double position = Double.parseDouble(connectorLinkTag.connectorTag.toPositionStr);

            // get the meeting link
            LinkTag linkToTag = this.realLinkTags.get(connectorLinkTag.connectorTag.toLinkNo);
            boolean isConnectorToLink = true;

            // create a new node at the split position of the "meeting" Link
            NodeTag newSplitNodeTag = NodeTag.createNewNodeAtLinkPosition(linkToTag, this, position);

            // split the link
            Map<String, LinkTag> newLinkToTags =
                    LinkTag.splitLink(newSplitNodeTag, linkToTag, this, position, margin, isConnectorToLink);
            linkToTag.signalHeads.removeAll(linkToTag.signalHeadsToRemove);
            linkToTag.sensors.removeAll(linkToTag.sensorTagsToRemove);

            if (newLinkToTags != null)
            {
                // only add if a link is split
                connectorLinkTag.connectorTag.toNodeName = newSplitNodeTag.name;
                this.nodeTags.put(newSplitNodeTag.name, newSplitNodeTag);
                // adjust the connection of other Connector links
                for (LinkTag connectorLinkTag2 : this.connectorTags.values())
                {

                    if (connectorLinkTag2 != connectorLinkTag
                            && connectorLinkTag2.connectorTag.toLinkNo.equals(connectorLinkTag.connectorTag.toLinkNo))
                    {

                        Double position2 = Double.parseDouble(connectorLinkTag2.connectorTag.toPositionStr);
                        if (position2 > position)
                        {
                            connectorLinkTag2.connectorTag.toLinkNo = newLinkToTags.values().iterator().next().name;
                            Double newPosition = position2 - position;
                            connectorLinkTag2.connectorTag.toPositionStr = newPosition.toString();
                        }
                    }
                    if (connectorLinkTag2 != connectorLinkTag
                            && connectorLinkTag2.connectorTag.fromLinkNo.equals(connectorLinkTag.connectorTag.toLinkNo))
                    {

                        Double position2 = Double.parseDouble(connectorLinkTag2.connectorTag.fromPositionStr);
                        if (position2 > position)
                        {
                            connectorLinkTag2.connectorTag.fromLinkNo = newLinkToTags.values().iterator().next().name;
                            Double newPosition = position2 - position;
                            connectorLinkTag2.connectorTag.fromPositionStr = newPosition.toString();
                        }
                    }
                }
                // connectorTag.connectorTag.toLinkNo = newLinkToTags.values().iterator().next().name;
                this.linkTags.putAll(newLinkToTags);
                this.realLinkTags.putAll(newLinkToTags);
            }
            else
            {

                // from connector to next link
                if (position < margin)
                {
                    this.nodeTags.remove(connectorLinkTag.connectorTag.toNodeName);
                    connectorLinkTag.connectorTag.toNodeName = linkToTag.nodeStartTag.name;
                }
                // from link to connector
                else
                {
                    this.nodeTags.remove(connectorLinkTag.connectorTag.toNodeName);
                    connectorLinkTag.connectorTag.toNodeName = linkToTag.nodeEndTag.name;
                }
            }

            // ******************************
            // 2: connector exits from a link:
            position = Double.parseDouble(connectorLinkTag.connectorTag.fromPositionStr);
            LinkTag linkFromTag = this.realLinkTags.get(connectorLinkTag.connectorTag.fromLinkNo);
            isConnectorToLink = false;
            NodeTag newSplitNodeTag2 = NodeTag.createNewNodeAtLinkPosition(linkFromTag, this, position);

            Map<String, LinkTag> newLinkFromTags =
                    LinkTag.splitLink(newSplitNodeTag2, linkFromTag, this, position, margin, isConnectorToLink);
            linkFromTag.signalHeads.removeAll(linkFromTag.signalHeadsToRemove);
            linkFromTag.sensors.removeAll(linkFromTag.sensorTagsToRemove);

            if (newLinkFromTags != null)
            {
                // only add if a link is split
                connectorLinkTag.connectorTag.fromNodeName = newSplitNodeTag2.name;
                this.nodeTags.put(newSplitNodeTag2.name, newSplitNodeTag2);
                // adjust the connection of other Connector links
                for (LinkTag connectorLinkTag2 : this.connectorTags.values())
                {
                    if (connectorLinkTag2 != connectorLinkTag
                            && connectorLinkTag2.connectorTag.fromLinkNo.equals(connectorLinkTag.connectorTag.fromLinkNo))
                    {

                        Double position2 = Double.parseDouble(connectorLinkTag2.connectorTag.fromPositionStr);
                        if (position2 > position)
                        {
                            connectorLinkTag2.connectorTag.fromLinkNo = newLinkFromTags.values().iterator().next().name;
                            Double newPosition = position2 - position;
                            connectorLinkTag2.connectorTag.fromPositionStr = newPosition.toString();
                        }
                    }
                    if (connectorLinkTag2 != connectorLinkTag
                            && connectorLinkTag2.connectorTag.toLinkNo.equals(connectorLinkTag.connectorTag.fromLinkNo))
                    {

                        Double position2 = Double.parseDouble(connectorLinkTag2.connectorTag.toPositionStr);
                        if (position2 > position)
                        {
                            connectorLinkTag2.connectorTag.toLinkNo = newLinkFromTags.values().iterator().next().name;
                            Double newPosition = position2 - position;
                            connectorLinkTag2.connectorTag.toPositionStr = newPosition.toString();
                        }
                    }
                }
                // connectorTag.connectorTag.fromLinkNo = newLinkFromTags.values().iterator().next().name;
                this.linkTags.putAll(newLinkFromTags);
                this.realLinkTags.putAll(newLinkFromTags);
            }
            else
            {
                // from connector to next link
                if (position < margin)
                {
                    this.nodeTags.remove(connectorLinkTag.connectorTag.fromNodeName);
                    connectorLinkTag.connectorTag.fromNodeName = linkFromTag.nodeStartTag.name;
                }
                // from link to connector
                else
                {
                    this.nodeTags.remove(connectorLinkTag.connectorTag.fromNodeName);
                    connectorLinkTag.connectorTag.fromNodeName = linkFromTag.nodeEndTag.name;
                }
            }
        }
    }

    /**
     * @return the OTSRoadNetwork with the static information about the network
     * @throws NetworkException if items cannot be added to the Network
     */
    private OTSRoadNetwork makeNetwork() throws NetworkException
    {
        // for (RouteTag routeTag : this.routeTags.values()) {
        // // TODO Make routes GTU specific. See what to do with GTUType.ALL for routes
        // // TODO Automate addition of Routes to network
        // this.network.addRoute(GTUType.ALL, routeTag.route);
        // }
        return this.network;
    }

    /** {@inheritDoc} */
    @Override
    public final String toString()
    {
        return "VissimANMNetworkLaneParser [gtuTypes=" + this.gtuTypes + ", laneTypes=" + this.laneTypes + "]";
    }

    public GlobalTag getGlobalTag()
    {
        return globalTag;
    }

    public void setGlobalTag(GlobalTag globalTag)
    {
        this.globalTag = globalTag;
    }

    public Map<String, NodeTag> getNodeTags()
    {
        return nodeTags;
    }

    public void setNodeTags(Map<String, NodeTag> nodeTags)
    {
        this.nodeTags = nodeTags;
    }

    public Map<String, LinkTag> getLinkTags()
    {
        return linkTags;
    }

    public void setLinkTags(Map<String, LinkTag> linkTags)
    {
        this.linkTags = linkTags;
    }

    public Map<String, LinkTag> getConnectorTags()
    {
        return connectorTags;
    }

    public void setConnectorTags(Map<String, LinkTag> connectorTags)
    {
        this.connectorTags = connectorTags;
    }

    public Map<String, LinkTag> getRealLinkTags()
    {
        return realLinkTags;
    }

    public void setRealLinkTags(Map<String, LinkTag> realLinkTags)
    {
        this.realLinkTags = realLinkTags;
    }

    public Map<String, SignalHeadTag> getSignalHeadTags()
    {
        return signalHeadTags;
    }

    public void setSignalHeadTags(Map<String, SignalHeadTag> signalHeadTags)
    {
        this.signalHeadTags = signalHeadTags;
    }

    public Map<String, SensorTag> getSensorTags()
    {
        return sensorTags;
    }

    public void setSensorTags(Map<String, SensorTag> sensorTags)
    {
        this.sensorTags = sensorTags;
    }

    public Map<String, GTUTag> getGtuTags()
    {
        return gtuTags;
    }

    public void setGtuTags(Map<String, GTUTag> gtuTags)
    {
        this.gtuTags = gtuTags;
    }

    public Map<String, GTUMixTag> getGtuMixTags()
    {
        return gtuMixTags;
    }

    public void setGtuMixTags(Map<String, GTUMixTag> gtuMixTags)
    {
        this.gtuMixTags = gtuMixTags;
    }

    public Map<String, RoadTypeTag> getRoadTypeTags()
    {
        return roadTypeTags;
    }

    public void setRoadTypeTags(Map<String, RoadTypeTag> roadTypeTags)
    {
        this.roadTypeTags = roadTypeTags;
    }

    public Map<String, GTUType> getGtuTypes()
    {
        return gtuTypes;
    }

    public void setGtuTypes(Map<String, GTUType> gtuTypes)
    {
        this.gtuTypes = gtuTypes;
    }

    public Map<String, LaneTypeTag> getLaneTypeTags()
    {
        return laneTypeTags;
    }

    public void setLaneTypeTags(Map<String, LaneTypeTag> laneTypeTags)
    {
        this.laneTypeTags = laneTypeTags;
    }

    public Map<String, RoadLayoutTag> getRoadLayoutTags()
    {
        return roadLayoutTags;
    }

    public void setRoadLayoutTags(Map<String, RoadLayoutTag> roadLayoutTags)
    {
        this.roadLayoutTags = roadLayoutTags;
    }

    public Map<String, RouteMixTag> getRouteMixTags()
    {
        return routeMixTags;
    }

    public void setRouteMixTags(Map<String, RouteMixTag> routeMixTags)
    {
        this.routeMixTags = routeMixTags;
    }

    public Map<String, ShortestRouteMixTag> getShortestRouteMixTags()
    {
        return shortestRouteMixTags;
    }

    public void setShortestRouteMixTags(Map<String, ShortestRouteMixTag> shortestRouteMixTags)
    {
        this.shortestRouteMixTags = shortestRouteMixTags;
    }

    public Map<String, ShortestRouteTag> getShortestRouteTags()
    {
        return shortestRouteTags;
    }

    public void setShortestRouteTags(Map<String, ShortestRouteTag> shortestRouteTags)
    {
        this.shortestRouteTags = shortestRouteTags;
    }

    public Map<String, RouteTag> getRouteTags()
    {
        return routeTags;
    }

    public void setRouteTags(Map<String, RouteTag> routeTags)
    {
        this.routeTags = routeTags;
    }

    public Map<String, LaneType> getLaneTypes()
    {
        return laneTypes;
    }

    public void setLaneTypes(Map<String, LaneType> laneTypes)
    {
        this.laneTypes = laneTypes;
    }

    public DEVSSimulatorInterface.TimeDoubleUnit getSimulator()
    {
        return simulator;
    }

    public void setSimulator(OTSSimulatorInterface simulator)
    {
        this.simulator = simulator;
    }

    public OTSRoadNetwork getNetwork()
    {
        return network;
    }

    public void setNetwork(OTSRoadNetwork network)
    {
        this.network = network;
    }

    public int getUpperNodeNr()
    {
        return upperNodeNr;
    }

    public void setUpperNodeNr(int upperNodeNr)
    {
        this.upperNodeNr = upperNodeNr;
    }

    public int getUpperLinkNr()
    {
        return upperLinkNr;
    }

    public void setUpperLinkNr(int upperLinkNr)
    {
        this.upperLinkNr = upperLinkNr;
    }
}