ODParser.java

  1. package org.opentrafficsim.road.network.factory.xml.parser;

  3. import java.math.BigInteger;
  4. import java.util.ArrayList;
  5. import java.util.Collections;
  6. import java.util.Comparator;
  7. import java.util.LinkedHashMap;
  8. import java.util.LinkedHashSet;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;

  13. import org.djunits.unit.FrequencyUnit;
  14. import org.djunits.unit.TimeUnit;
  15. import org.djunits.value.storage.StorageType;
  16. import org.djunits.value.vdouble.scalar.Acceleration;
  17. import org.djunits.value.vdouble.scalar.Frequency;
  18. import org.djunits.value.vdouble.scalar.Length;
  19. import org.djunits.value.vdouble.scalar.Speed;
  20. import org.djunits.value.vdouble.scalar.Time;
  21. import org.djunits.value.vdouble.vector.FrequencyVector;
  22. import org.djunits.value.vdouble.vector.TimeVector;
  23. import org.djunits.value.vdouble.vector.base.DoubleVector;
  24. import org.djutils.exceptions.Throw;
  25. import org.djutils.exceptions.Try;
  26. import org.djutils.logger.CategoryLogger;
  27. import org.opentrafficsim.base.logger.Cat;
  28. import org.opentrafficsim.core.distributions.Generator;
  29. import org.opentrafficsim.core.dsol.OTSSimulatorInterface;
  30. import org.opentrafficsim.core.gtu.GTUException;
  31. import org.opentrafficsim.core.gtu.GTUType;
  32. import org.opentrafficsim.core.gtu.NestedCache;
  33. import org.opentrafficsim.core.gtu.TemplateGTUType;
  34. import org.opentrafficsim.core.idgenerator.IdGenerator;
  35. import org.opentrafficsim.core.network.Node;
  36. import org.opentrafficsim.core.network.route.Route;
  37. import org.opentrafficsim.road.gtu.generator.GeneratorPositions.LaneBias;
  38. import org.opentrafficsim.road.gtu.generator.GeneratorPositions.LaneBiases;
  39. import org.opentrafficsim.road.gtu.generator.GeneratorPositions.RoadPosition;
  40. import org.opentrafficsim.road.gtu.generator.LaneBasedGTUGenerator;
  41. import org.opentrafficsim.road.gtu.generator.MarkovCorrelation;
  42. import org.opentrafficsim.road.gtu.generator.od.DefaultGTUCharacteristicsGeneratorOD.Factory;
  43. import org.opentrafficsim.road.gtu.generator.od.ODApplier;
  44. import org.opentrafficsim.road.gtu.generator.od.ODApplier.GeneratorObjects;
  45. import org.opentrafficsim.road.gtu.generator.od.ODOptions;
  46. import org.opentrafficsim.road.gtu.generator.od.ODOptions.Option;
  47. import org.opentrafficsim.road.gtu.generator.od.StrategicalPlannerFactorySupplierOD;
  48. import org.opentrafficsim.road.gtu.lane.tactical.following.IDMPlusFactory;
  49. import org.opentrafficsim.road.gtu.lane.tactical.lmrs.DefaultLMRSPerceptionFactory;
  50. import org.opentrafficsim.road.gtu.lane.tactical.lmrs.LMRSFactory;
  51. import org.opentrafficsim.road.gtu.strategical.LaneBasedStrategicalPlannerFactory;
  52. import org.opentrafficsim.road.gtu.strategical.od.Categorization;
  53. import org.opentrafficsim.road.gtu.strategical.od.Category;
  54. import org.opentrafficsim.road.gtu.strategical.od.Interpolation;
  55. import org.opentrafficsim.road.gtu.strategical.od.ODMatrix;
  56. import org.opentrafficsim.road.gtu.strategical.route.LaneBasedStrategicalRoutePlannerFactory;
  57. import org.opentrafficsim.road.gtu.strategical.route.RouteGeneratorOD;
  58. import org.opentrafficsim.road.network.OTSRoadNetwork;
  59. import org.opentrafficsim.road.network.factory.xml.XmlParserException;
  60. import org.opentrafficsim.road.network.factory.xml.utils.ParseDistribution;
  61. import org.opentrafficsim.road.network.factory.xml.utils.StreamInformation;
  62. import org.opentrafficsim.road.network.factory.xml.utils.Transformer;
  63. import org.opentrafficsim.road.network.lane.CrossSectionLink;
  64. import org.opentrafficsim.road.network.lane.Lane;
  65. import org.opentrafficsim.xml.generated.CATEGORYTYPE;
  66. import org.opentrafficsim.xml.generated.GLOBALTIMETYPE.TIME;
  67. import org.opentrafficsim.xml.generated.GTUTEMPLATE;
  68. import org.opentrafficsim.xml.generated.LEVELTIMETYPE;
  69. import org.opentrafficsim.xml.generated.NETWORKDEMAND;
  70. import org.opentrafficsim.xml.generated.OD;
  71. import org.opentrafficsim.xml.generated.OD.DEMAND;
  72. import org.opentrafficsim.xml.generated.ODOPTIONS;
  73. import org.opentrafficsim.xml.generated.ODOPTIONS.ODOPTIONSITEM;
  74. import org.opentrafficsim.xml.generated.ODOPTIONS.ODOPTIONSITEM.DEFAULTMODEL;
  75. import org.opentrafficsim.xml.generated.ODOPTIONS.ODOPTIONSITEM.LANEBIASES.LANEBIAS;
  76. import org.opentrafficsim.xml.generated.ODOPTIONS.ODOPTIONSITEM.MARKOV.STATE;
  77. import org.opentrafficsim.xml.generated.ODOPTIONS.ODOPTIONSITEM.MODEL;

  79. import nl.tudelft.simulation.jstats.streams.StreamInterface;

  81. /**
  82.  * <p>
  83.  * Copyright (c) 2013-2020 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
  84.  * BSD-style license. See <a href="http://opentrafficsim.org/node/13">OpenTrafficSim License</a>.
  85.  * <p>
  86.  * @version $Revision$, $LastChangedDate$, by $Author$, initial version Mar 29, 2019 <br>
  87.  * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
  88.  * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
  89.  * @author <a href="http://www.transport.citg.tudelft.nl">Wouter Schakel</a>
  90.  */
  91. public final class ODParser
  92. {
  93.     /** */
  94.     private ODParser()
  95.     {
  96.         // static class
  97.     }

  99.     /**
  100.      * Creates generators and returns OD matrices.
  101.      * @param otsNetwork OTSRoadNetwork; network
  102.      * @param simulator OTSSimulatorInterface; simulator
  103.      * @param demands List&lt;NETWORKDEMAND&gt;; demand
  104.      * @param gtuTemplates Map&lt;String, GTUTEMPLATE&gt;; GTU templates
  105.      * @param factories Map&lt;String, LaneBasedStrategicalPlannerFactory&lt;?&gt;&gt;; factories from model parser
  106.      * @param modelIdReferrals Map&lt;String, String&gt;; model id referrals
  107.      * @param streamMap Map&lt;String, StreamInformation&gt;; stream map
  108.      * @return List&lt;LaneBasedGTUGenerator&gt;; generators
  109.      * @throws XmlParserException if the OD contains an inconsistency or error
  110.      */
  111.     @SuppressWarnings("checkstyle:methodlength")
  112.     public static List<LaneBasedGTUGenerator> parseDemand(final OTSRoadNetwork otsNetwork,
  113.             final OTSSimulatorInterface simulator, final List<NETWORKDEMAND> demands,
  114.             final Map<String, GTUTEMPLATE> gtuTemplates, final Map<String, LaneBasedStrategicalPlannerFactory<?>> factories,
  115.             final Map<String, String> modelIdReferrals, final Map<String, StreamInformation> streamMap)
  116.             throws XmlParserException
  117.     {
  118.         List<LaneBasedGTUGenerator> generators = new ArrayList<>();

  120.         IdGenerator idGenerator = new IdGenerator("");

  122.         for (NETWORKDEMAND subDemand : demands)
  123.         {
  124.             // Collect options
  125.             Map<String, ODOPTIONS> odOptionsMap = new LinkedHashMap<>();
  126.             for (ODOPTIONS odOptions : subDemand.getODOPTIONS())
  127.             {
  128.                 odOptionsMap.put(odOptions.getID(), odOptions);
  129.             }
  130.             List<OD> ods = subDemand.getOD();
  131.             for (OD od : ods)
  132.             {

  134.                 // ID
  135.                 String id = od.getID();

  137.                 // Origins and destinations, retrieve them from demand items
  138.                 List<Node> origins = new ArrayList<>();
  139.                 List<Node> destinations = new ArrayList<>();
  140.                 for (DEMAND demand : od.getDEMAND())
  141.                 {
  142.                     if (!origins.contains(otsNetwork.getNode(demand.getORIGIN())))
  143.                     {
  144.                         Node originNode = otsNetwork.getNode(demand.getORIGIN());
  145.                         if (null == originNode)
  146.                         {
  147.                             CategoryLogger.filter(Cat.PARSER).trace("Parse demand: cannot find origin {}", demand.getORIGIN());
  148.                         }
  149.                         else
  150.                         {
  151.                             // TODO: will skipping origins that are not in the network cause problems later on?
  152.                             origins.add(originNode);
  153.                         }
  154.                     }
  155.                     if (!destinations.contains(otsNetwork.getNode(demand.getDESTINATION())))
  156.                     {
  157.                         Node destinationNode = otsNetwork.getNode(demand.getDESTINATION());
  158.                         if (null == destinationNode)
  159.                         {
  160.                             CategoryLogger.filter(Cat.PARSER).trace("Parse demand: cannot find destination {}",
  161.                                     demand.getDESTINATION());
  162.                         }
  163.                         else
  164.                         {
  165.                             // TODO: will skipping origins that are not in the network cause problems later on?
  166.                             destinations.add(destinationNode);
  167.                         }
  168.                     }
  169.                 }

  171.                 // Create categorization
  172.                 Categorization categorization;
  173.                 Map<String, Category> categories = new LinkedHashMap<>();
  174.                 Map<String, Double> categoryFactors = new LinkedHashMap<>();
  175.                 if (od.getCATEGORY() == null || od.getCATEGORY().isEmpty())
  176.                 {
  177.                     categorization = Categorization.UNCATEGORIZED;
  178.                 }
  179.                 else
  180.                 {
  181.                     List<Class<?>> categoryClasses = new ArrayList<>();
  182.                     if (od.getCATEGORY().get(0).getGTUTYPE() != null)
  183.                     {
  184.                         categoryClasses.add(GTUType.class);
  185.                     }
  186.                     if (od.getCATEGORY().get(0).getROUTE() != null)
  187.                     {
  188.                         categoryClasses.add(Route.class);
  189.                     }
  190.                     if (od.getCATEGORY().get(0).getLANE() != null)
  191.                     {
  192.                         categoryClasses.add(Lane.class);
  193.                     }
  194.                     if (categoryClasses.isEmpty())
  195.                     {
  196.                         // XML uses categories, but these define nothing
  197.                         categorization = Categorization.UNCATEGORIZED;
  198.                     }
  199.                     else
  200.                     {
  201.                         Class<?> clazz = categoryClasses.get(0);
  202.                         categoryClasses.remove(0);
  203.                         categorization = new Categorization("", clazz, categoryClasses.toArray(new Class[0]));
  204.                     }
  205.                     // create categories and check that all categories comply with the categorization
  206.                     for (CATEGORYTYPE category : od.getCATEGORY())
  207.                     {
  208.                         Throw.when(
  209.                                 (categorization.entails(GTUType.class) && category.getGTUTYPE() == null)
  210.                                         || (!categorization.entails(GTUType.class) && category.getGTUTYPE() != null),
  211.                                 XmlParserException.class, "Categories are inconsistent concerning GTUType.");
  212.                         Throw.when(
  213.                                 (categorization.entails(Route.class) && category.getROUTE() == null)
  214.                                         || (!categorization.entails(Route.class) && category.getROUTE() != null),
  215.                                 XmlParserException.class, "Categories are inconsistent concerning Route.");
  216.                         Throw.when(
  217.                                 (categorization.entails(Lane.class) && category.getLANE() == null)
  218.                                         || (!categorization.entails(Lane.class) && category.getLANE() != null),
  219.                                 XmlParserException.class, "Categories are inconsistent concerning Lane.");
  220.                         List<Object> objects = new ArrayList<>();
  221.                         if (categorization.entails(GTUType.class))
  222.                         {
  223.                             objects.add(otsNetwork.getGtuType(category.getGTUTYPE()));
  224.                         }
  225.                         if (categorization.entails(Route.class))
  226.                         {
  227.                             objects.add(otsNetwork.getRoute(category.getROUTE()));
  228.                         }
  229.                         if (categorization.entails(Lane.class))
  230.                         {
  231.                             CrossSectionLink link = (CrossSectionLink) otsNetwork.getLink(category.getLANE().getLINK());
  232.                             Lane lane = (Lane) link.getCrossSectionElement(category.getLANE().getID());
  233.                             objects.add(lane);
  234.                         }
  235.                         categories.put(category.getID(), new Category(categorization, objects.get(0),
  236.                                 objects.subList(1, objects.size()).toArray(new Object[objects.size() - 1])));
  237.                         categoryFactors.put(category.getID(), parsePositiveFactor(category.getFACTOR()));
  238.                     }
  239.                 }

  241.                 // Global time vector
  242.                 TimeVector globalTimeVector = null;
  243.                 if (od.getGLOBALTIME() != null)
  244.                 {
  245.                     List<Time> timeList = new ArrayList<>();
  246.                     for (TIME time : od.getGLOBALTIME().getTIME())
  247.                     {
  248.                         timeList.add(time.getVALUE());
  249.                     }
  250.                     Collections.sort(timeList);
  251.                     globalTimeVector =
  252.                             Try.assign(() -> DoubleVector.instantiateList(timeList, TimeUnit.DEFAULT, StorageType.DENSE),
  253.                                     XmlParserException.class, "Global time has no values.");
  254.                 }

  256.                 // Global interpolation
  257.                 Interpolation globalInterpolation =
  258.                         od.getGLOBALINTERPOLATION().equals("LINEAR") ? Interpolation.LINEAR : Interpolation.STEPWISE;

  260.                 // Global factor
  261.                 double globalFactor = parsePositiveFactor(od.getGLOBALFACTOR());

  263.                 // Create the OD matrix
  264.                 ODMatrix odMatrix =
  265.                         new ODMatrix(id, origins, destinations, categorization, globalTimeVector, globalInterpolation);

  267.                 // Add demand
  268.                 NestedCache<Set<DEMAND>> demandPerOD = new NestedCache<>(Node.class, Node.class);
  269.                 for (DEMAND demand : od.getDEMAND())
  270.                 {
  271.                     Node origin = otsNetwork.getNode(demand.getORIGIN());
  272.                     Node destination = otsNetwork.getNode(demand.getDESTINATION());
  273.                     demandPerOD.getValue(() -> new LinkedHashSet<>(), origin, destination).add(demand);
  274.                 }
  275.                 for (Object o : demandPerOD.getKeys())
  276.                 {
  277.                     NestedCache<Set<DEMAND>> demandPerD = demandPerOD.getChild(o);
  278.                     for (Object d : demandPerD.getKeys())
  279.                     {
  280.                         Set<DEMAND> set = demandPerD.getValue(d);
  281.                         Node origin = (Node) o;
  282.                         Node destination = (Node) d;
  283.                         Throw.when(categorization.equals(Categorization.UNCATEGORIZED) && set.size() > 1,
  284.                                 XmlParserException.class,
  285.                                 "Multiple DEMAND tags define demand from %s to %s in uncategorized demand.", origin.getId(),
  286.                                 destination.getId());

  288.                         // Find main demand, that may be split among other DEMAND tags between the same origin and destination
  289.                         DEMAND main = null;
  290.                         if (!categorization.equals(Categorization.UNCATEGORIZED))
  291.                         {
  292.                             for (DEMAND demand : set)
  293.                             {
  294.                                 if (demand.getCATEGORY() == null)
  295.                                 {
  296.                                     Throw.when(main != null, XmlParserException.class,
  297.                                             "Multiple DEMAND tags define main demand from %s to %s.", origin.getId(),
  298.                                             destination.getId());
  299.                                     Throw.when(set.size() == 1, XmlParserException.class,
  300.                                             "Categorized demand from %s to %s has single DEMAND, and without category.",
  301.                                             origin.getId(), destination.getId());
  302.                                     main = demand;
  303.                                 }
  304.                             }
  305.                         }

  307.                         // Add demand per tag
  308.                         for (DEMAND demand : set)
  309.                         {
  310.                             // Skip main demand, it is split among other tags
  311.                             if (demand.equals(main))
  312.                             {
  313.                                 continue;
  314.                             }

  316.                             // TimeVector: demand > main demand > global
  317.                             List<LEVELTIMETYPE> timeTags =
  318.                                     demand.getLEVEL() == null || demand.getLEVEL().get(0).getTIME() == null
  319.                                             ? (main == null || main.getLEVEL() == null
  320.                                                     || main.getLEVEL().get(0).getTIME() == null ? null : main.getLEVEL())
  321.                                             : demand.getLEVEL();
  322.                             TimeVector timeVector = timeTags == null ? globalTimeVector : parseTimeVector(timeTags);

  324.                             // Interpolation: demand > main demand > global
  325.                             // TODO: LINEAR follows when only global STEPWISE is defined
  326.                             String interpolationString = demand.getINTERPOLATION() == null
  327.                                     ? (main == null || main.getINTERPOLATION() == null ? null : main.getINTERPOLATION())
  328.                                     : demand.getINTERPOLATION();
  329.                             Interpolation interpolation = interpolationString == null ? globalInterpolation
  330.                                     : interpolationString.equals("LINEAR") ? Interpolation.LINEAR : Interpolation.STEPWISE;

  332.                             // Category
  333.                             Category category = categorization.equals(Categorization.UNCATEGORIZED) ? Category.UNCATEGORIZED
  334.                                     : categories.get(demand.getCATEGORY());

  336.                             // Factor
  337.                             double factor = globalFactor;
  338.                             factor = main == null ? factor : factor * parsePositiveFactor(main.getFACTOR());
  339.                             factor *= parsePositiveFactor(demand.getFACTOR());

  341.                             // Figure out where the base demand, and optional factors are
  342.                             Frequency[] demandRaw = new Frequency[timeVector.size()];
  343.                             List<LEVELTIMETYPE> baseDemand;
  344.                             List<LEVELTIMETYPE> factors = null;
  345.                             if (demand.getLEVEL() == null)
  346.                             {
  347.                                 // this demand specified no levels, use main demand
  348.                                 baseDemand = main.getLEVEL();
  349.                             }
  350.                             else if (demand.getLEVEL().get(0).getValue().contains("veh"))
  351.                             {
  352.                                 // this demand specifies levels
  353.                                 baseDemand = demand.getLEVEL();
  354.                             }
  355.                             else
  356.                             {
  357.                                 // this demand specifies factors on the main demand
  358.                                 baseDemand = main.getLEVEL();
  359.                                 factors = demand.getLEVEL();
  360.                             }
  361.                             // sort
  362.                             sortLevelTime(baseDemand);
  363.                             if (factors != null)
  364.                             {
  365.                                 sortLevelTime(factors);
  366.                             }
  367.                             // fill array, include factors
  368.                             for (int i = 0; i < baseDemand.size(); i++)
  369.                             {
  370.                                 Throw.when(
  371.                                         baseDemand.get(i).getTIME() != null && factors != null
  372.                                                 && factors.get(i).getTIME() != null
  373.                                                 && !baseDemand.get(i).getTIME().eq(factors.get(i).getTIME()),
  374.                                         XmlParserException.class,
  375.                                         "Demand from %s to %s is specified with factors that have different time from the base demand.",
  376.                                         origin, destination);
  377.                                 demandRaw[i] = parseLevel(baseDemand.get(i).getValue(),
  378.                                         factor * (factors == null ? 1.0 : parsePositiveFactor(factors.get(i).getValue())));
  379.                             }
  380.                             FrequencyVector demandVector =
  381.                                     Try.assign(() -> DoubleVector.instantiate(demandRaw, FrequencyUnit.SI, StorageType.DENSE),
  382.                                             XmlParserException.class, "Unexpected empty demand.");

  384.                             // Finally, add the demand
  385.                             odMatrix.putDemandVector(origin, destination, category, demandVector, timeVector, interpolation);
  386.                         }

  388.                     }
  389.                 }

  391.                 // OD Options
  392.                 ODOptions odOptions =
  393.                         new ODOptions().set(ODOptions.GTU_ID, idGenerator).set(ODOptions.NO_LC_DIST, Length.instantiateSI(1.0));
  394.                 // templates
  395.                 Set<TemplateGTUType> templates = new LinkedHashSet<>();
  396.                 for (GTUTEMPLATE template : gtuTemplates.values())
  397.                 {
  398.                     GTUType gtuType = otsNetwork.getGtuType(template.getGTUTYPE());
  399.                     Generator<Length> lengthGenerator = ParseDistribution.parseLengthDist(streamMap, template.getLENGTHDIST());
  400.                     Generator<Length> widthGenerator = ParseDistribution.parseLengthDist(streamMap, template.getWIDTHDIST());
  401.                     Generator<Speed> maximumSpeedGenerator =
  402.                             ParseDistribution.parseSpeedDist(streamMap, template.getMAXSPEEDDIST());
  403.                     if (template.getMAXACCELERATIONDIST() == null || template.getMAXDECELERATIONDIST() == null)
  404.                     {
  405.                         templates.add(new TemplateGTUType(gtuType, lengthGenerator, widthGenerator, maximumSpeedGenerator));
  406.                     }
  407.                     else
  408.                     {
  409.                         Generator<Acceleration> maxAccelerationGenerator =
  410.                                 ParseDistribution.parseAccelerationDist(streamMap, template.getMAXACCELERATIONDIST());
  411.                         Generator<Acceleration> maxDecelerationGenerator =
  412.                                 ParseDistribution.parseAccelerationDist(streamMap, template.getMAXDECELERATIONDIST());
  413.                         templates.add(new TemplateGTUType(gtuType, lengthGenerator, widthGenerator, maximumSpeedGenerator,
  414.                                 maxAccelerationGenerator, maxDecelerationGenerator));
  415.                     }
  416.                 }
  417.                 // default global option to integrate defined templates
  418.                 Factory factory = new Factory(); // DefaultGTUCharacteristicsGeneratorOD factory
  419.                 factory.setTemplates(templates);
  420.                 odOptions.set(ODOptions.GTU_TYPE, factory.create());
  421.                 // other options
  422.                 if (od.getOPTIONS() != null)
  423.                 {
  424.                     Throw.when(!odOptionsMap.containsKey(od.getOPTIONS()), XmlParserException.class,
  425.                             "OD options of id od.getOPTIONS() not defined.");
  426.                     for (ODOPTIONSITEM options : odOptionsMap.get(od.getOPTIONS()).getODOPTIONSITEM())
  427.                     {
  428.                         /*
  429.                          * The current 'options' is valid within a single context, i.e. global, link type, origin or lane. All
  430.                          * option values are set in odOptions for that context, in the current loop. For the model factories an
  431.                          * implementation of StrategicalPlannerFactorySupplierOD is created that responds to the GTU type, and
  432.                          * selects a factory assigned to that GTU type within the context. Or, the default factory in the
  433.                          * context is used. Or finally, a default LMRS. If no model factory is specified in the context (nor a
  434.                          * higher context), no option value is set and ODOptions itself returns a default LMRS factory.
  435.                          */

  437.                         // GTU type (model)
  438.                         if (options.getDEFAULTMODEL() != null || (options.getMODEL() != null && !options.getMODEL().isEmpty()))
  439.                         {
  440.                             LaneBasedStrategicalPlannerFactory<?> defaultFactory;
  441.                             if (options.getDEFAULTMODEL() != null)
  442.                             {
  443.                                 // TODO: model id referral
  444.                                 String modelId = ODParser.getModelId(options.getDEFAULTMODEL(), modelIdReferrals);
  445.                                 Throw.when(!factories.containsKey(modelId), XmlParserException.class,
  446.                                         "OD option DEFAULTMODEL refers to a non-existent model with ID %s.", modelId);
  447.                                 defaultFactory = factories.get(modelId);
  448.                             }
  449.                             else
  450.                             {
  451.                                 defaultFactory = null;
  452.                             }
  453.                             // compose map that couples GTU types to factories through MODEL ID's
  454.                             final Map<GTUType, LaneBasedStrategicalPlannerFactory<?>> gtuTypeFactoryMap = new LinkedHashMap<>();
  455.                             if (options.getMODEL() != null)
  456.                             {
  457.                                 for (MODEL model : options.getMODEL())
  458.                                 {
  459.                                     GTUType gtuType = otsNetwork.getGtuType(model.getGTUTYPE());
  460.                                     Throw.when(!factories.containsKey(model.getID()), XmlParserException.class,
  461.                                             "OD option MODEL refers to a non existent-model with ID %s.", model.getID());
  462.                                     gtuTypeFactoryMap.put(gtuType, factories.get(getModelId(model, modelIdReferrals)));
  463.                                 }
  464.                             }
  465.                             factory = new Factory(); // DefaultGTUCharacteristicsGeneratorOD factory
  466.                             factory.setTemplates(templates);
  467.                             factory.setFactorySupplier(new StrategicalPlannerFactorySupplierOD()
  468.                             {
  469.                                 /** {@inheritDoc} */
  470.                                 @Override
  471.                                 public LaneBasedStrategicalPlannerFactory<?> getFactory(final Node origin,
  472.                                         final Node destination, final Category category, final StreamInterface randomStream)
  473.                                         throws GTUException
  474.                                 {
  475.                                     if (category.getCategorization().entails(GTUType.class))
  476.                                     {
  477.                                         LaneBasedStrategicalPlannerFactory<?> strategicalPlannerFactory =
  478.                                                 gtuTypeFactoryMap.get(category.get(GTUType.class));
  479.                                         if (strategicalPlannerFactory != null)
  480.                                         {
  481.                                             // a model factory for this GTU type is specified
  482.                                             return strategicalPlannerFactory;
  483.                                         }
  484.                                     }
  485.                                     if (defaultFactory != null)
  486.                                     {
  487.                                         // a default model factory is specified
  488.                                         return defaultFactory;
  489.                                     }
  490.                                     // no model factory specified, return a default LMRS factory
  491.                                     // TODO: LMRSFactory can receive a parameter factory, but how to define those parameters in
  492.                                     // XML?
  493.                                     return new LaneBasedStrategicalRoutePlannerFactory(
  494.                                             new LMRSFactory(new IDMPlusFactory(randomStream),
  495.                                                     new DefaultLMRSPerceptionFactory()),
  496.                                             RouteGeneratorOD.getDefaultRouteSupplier(randomStream));
  497.                                 }
  498.                             });
  499.                             setOption(odOptions, ODOptions.GTU_TYPE, factory.create(), options, otsNetwork);
  500.                         }
  501.                         // no lc
  502.                         setOption(odOptions, ODOptions.NO_LC_DIST, options.getNOLANECHANGE(), options, otsNetwork);
  503.                         // room checker
  504.                         setOption(odOptions, ODOptions.ROOM_CHECKER, Transformer.parseRoomChecker(options.getROOMCHECKER()),
  505.                                 options, otsNetwork);
  506.                         // headway distribution
  507.                         try
  508.                         {
  509.                             setOption(odOptions, ODOptions.HEADWAY_DIST,
  510.                                     Transformer.parseHeadwayDistribution(options.getHEADWAYDIST()), options, otsNetwork);
  511.                         }
  512.                         catch (NoSuchFieldException | IllegalAccessException exception)
  513.                         {
  514.                             throw new XmlParserException(exception);
  515.                         }
  516.                         // markov
  517.                         if (options.getMARKOV() != null)
  518.                         {
  519.                             Throw.when(!categorization.entails(GTUType.class), XmlParserException.class,
  520.                                     "The OD option MARKOV can only be used if GTUType is in the CATEGORY's.");
  521.                             Throw.when(!categorization.entails(Lane.class) && options.getLANE() != null,
  522.                                     XmlParserException.class,
  523.                                     "Markov chains at lane level are not used if Lane's are not in the CATEGORY's.");
  524.                             MarkovCorrelation<GTUType, Frequency> markov = new MarkovCorrelation<>();
  525.                             for (STATE state : options.getMARKOV().getSTATE())
  526.                             {
  527.                                 GTUType gtuType = otsNetwork.getGtuType(state.getGTUTYPE());
  528.                                 double correlation = state.getCORRELATION();
  529.                                 if (state.getPARENT() == null)
  530.                                 {
  531.                                     markov.addState(gtuType, correlation);
  532.                                 }
  533.                                 else
  534.                                 {
  535.                                     GTUType parentType = otsNetwork.getGtuType(state.getPARENT());
  536.                                     markov.addState(parentType, gtuType, correlation);
  537.                                 }
  538.                             }
  539.                             setOption(odOptions, ODOptions.MARKOV, markov, options, otsNetwork);
  540.                         }
  541.                         // lane biases
  542.                         if (options.getLANEBIASES() != null)
  543.                         {
  544.                             LaneBiases laneBiases = new LaneBiases();
  545.                             for (LANEBIAS laneBias : options.getLANEBIASES().getLANEBIAS())
  546.                             {
  547.                                 GTUType gtuType = otsNetwork.getGtuType(laneBias.getGTUTYPE());
  548.                                 double bias = laneBias.getBIAS();
  549.                                 int stickyLanes;
  550.                                 if (laneBias.getSTICKYLANES() == null)
  551.                                 {
  552.                                     stickyLanes = Integer.MAX_VALUE;
  553.                                 }
  554.                                 else
  555.                                 {
  556.                                     if (laneBias.getSTICKYLANES().compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0)
  557.                                     {
  558.                                         stickyLanes = Integer.MAX_VALUE;
  559.                                     }
  560.                                     else
  561.                                     {
  562.                                         stickyLanes = laneBias.getSTICKYLANES().intValue();
  563.                                     }
  564.                                 }
  565.                                 RoadPosition roadPosition;
  566.                                 if (laneBias.getFROMRIGHT() != null)
  567.                                 {
  568.                                     roadPosition = new RoadPosition.ByValue(laneBias.getFROMRIGHT());
  569.                                 }
  570.                                 else if (laneBias.getFROMLEFT() != null)
  571.                                 {
  572.                                     roadPosition = new RoadPosition.ByValue(1.0 - laneBias.getFROMLEFT());
  573.                                 }
  574.                                 else
  575.                                 {
  576.                                     roadPosition = new RoadPosition.BySpeed(laneBias.getLEFTSPEED(), laneBias.getRIGHTSPEED());
  577.                                 }
  578.                                 laneBiases.addBias(gtuType, new LaneBias(roadPosition, bias, stickyLanes));
  579.                             }
  580.                             setOption(odOptions, ODOptions.getLaneBiasOption(otsNetwork), laneBiases, options, otsNetwork);
  581.                         }
  582.                     }
  583.                 }

  585.                 // Invoke ODApplier
  586.                 Map<String, GeneratorObjects> output =
  587.                         Try.assign(() -> ODApplier.applyOD(otsNetwork, odMatrix, simulator, odOptions),
  588.                                 XmlParserException.class, "Simulator time should be zero when parsing an OD.");

  590.                 // Collect generators in output
  591.                 for (GeneratorObjects generatorObject : output.values())
  592.                 {
  593.                     generators.add(generatorObject.getGenerator());
  594.                 }
  595.             }
  596.         }

  598.         return generators;
  599.     }

  601.     /**
  602.      * Parse the value of a LEVELTIMETYPE that specifies flow (i.e. with 'veh' per time unit).
  603.      * @param string String; value of LEVELTIMETYPE
  604.      * @param factor double; total applicable factor on this level
  605.      * @return Frequency; resulting frequency
  606.      */
  607.     private static Frequency parseLevel(final String string, final double factor)
  608.     {
  609.         return Frequency.valueOf(string.replace("veh", "")).times(factor);
  610.     }

  612.     /**
  613.      * Sorts LEVELTIMETYPE in a list by the time value, if any.
  614.      * @param levelTime List&lt;LEVELTIMETYPE&gt;; sorted list
  615.      */
  616.     private static void sortLevelTime(final List<LEVELTIMETYPE> levelTime)
  617.     {
  618.         Collections.sort(levelTime, new Comparator<LEVELTIMETYPE>()
  619.         {
  620.             /** {@inheritDoc} */
  621.             @Override
  622.             public int compare(final LEVELTIMETYPE o1, final LEVELTIMETYPE o2)
  623.             {
  624.                 if (o1.getTIME() == null && o2.getTIME() == null)
  625.                 {
  626.                     return 0;
  627.                 }
  628.                 if (o1.getTIME() == null)
  629.                 {
  630.                     return -1;
  631.                 }
  632.                 if (o2.getTIME() == null)
  633.                 {
  634.                     return 1;
  635.                 }
  636.                 return o1.getTIME().compareTo(o2.getTIME());
  637.             }
  638.         });
  639.     }

  641.     /**
  642.      * Parse a list of {@code LEVELTIMETYPE} to a {@code TimeVector}.
  643.      * @param list List&lt;LEVELTIMETYPE&gt;; list of time information
  644.      * @return TimeVector; time vector
  645.      * @throws XmlParserException if global time has no values
  646.      */
  647.     private static TimeVector parseTimeVector(final List<LEVELTIMETYPE> list) throws XmlParserException
  648.     {
  649.         List<Time> timeList = new ArrayList<>();
  650.         for (LEVELTIMETYPE time : list)
  651.         {
  652.             timeList.add(time.getTIME());
  653.         }
  654.         Collections.sort(timeList);
  655.         return Try.assign(() -> DoubleVector.instantiateList(timeList, TimeUnit.DEFAULT, StorageType.DENSE),
  656.                 XmlParserException.class, "Global time has no values.");
  657.     }

  659.     /**
  660.      * Parses a positive factor.
  661.      * @param factor String; factor in {@code String} format
  662.      * @return double; factor in {@code double} format
  663.      * @throws XmlParserException if the factor is not positive
  664.      */
  665.     private static double parsePositiveFactor(final String factor) throws XmlParserException
  666.     {
  667.         double factorValue;
  668.         if (factor.endsWith("%"))
  669.         {
  670.             factorValue = Double.parseDouble(factor.substring(0, factor.length() - 1)) / 100.0;
  671.         }
  672.         factorValue = Double.parseDouble(factor);
  673.         Throw.when(factorValue < 0.0, XmlParserException.class, "Factor %d is not positive.", factorValue);
  674.         return factorValue;
  675.     }

  677.     /**
  678.      * Set option.
  679.      * @param odOptions ODOptions; OD options to set the option in
  680.      * @param option Option&lt;T&gt;; option to set
  681.      * @param value T; value to set the option to
  682.      * @param options ODOPTIONSITEM; used to set the option on the right level (Link type, origin node, lane
  683.      * @param otsNetwork OTSRoadNetwork; to get the link type, origin node or lane from
  684.      * @param <T> option value type
  685.      */
  686.     private static <T> void setOption(final ODOptions odOptions, final Option<T> option, final T value,
  687.             final ODOPTIONSITEM options, final OTSRoadNetwork otsNetwork)
  688.     {
  689.         if (value != null)
  690.         {
  691.             if (options.getLINKTYPE() != null)
  692.             {
  693.                 odOptions.set(otsNetwork.getLinkType(options.getLINKTYPE().getVALUE()), option, value);
  694.             }
  695.             else if (options.getORIGIN() != null)
  696.             {
  697.                 odOptions.set(otsNetwork.getNode(options.getORIGIN().getVALUE()), option, value);
  698.             }
  699.             else if (options.getLANE() != null)
  700.             {
  701.                 CrossSectionLink link = (CrossSectionLink) otsNetwork.getLink(options.getLANE().getLINK());
  702.                 odOptions.set((Lane) link.getCrossSectionElement(options.getLANE().getID()), option, value);
  703.             }
  704.             else
  705.             {
  706.                 odOptions.set(option, value);
  707.             }
  708.         }
  709.     }

  711.     /**
  712.      * Returns the ID of a default model, referred if there is a referral specified.
  713.      * @param model String; model
  714.      * @param modelIdReferrals String; model ID
  715.      * @return ID of a model, referred if there is a referral specified
  716.      */
  717.     private static String getModelId(final DEFAULTMODEL model, final Map<String, String> modelIdReferrals)
  718.     {
  719.         if (model.getMODELIDREFERRAL() != null)
  720.         {
  721.             return modelIdReferrals.get(model.getMODELIDREFERRAL());
  722.         }
  723.         return model.getID();
  724.     }

  726.     /**
  727.      * Returns the ID of a model, referred if there is a referral specified.
  728.      * @param model String; model
  729.      * @param modelIdReferrals String; model ID
  730.      * @return ID of a model, referred if there is a referral specified
  731.      */
  732.     private static String getModelId(final MODEL model, final Map<String, String> modelIdReferrals)
  733.     {
  734.         if (model.getMODELIDREFERRAL() != null)
  735.         {
  736.             return modelIdReferrals.get(model.getMODELIDREFERRAL());
  737.         }
  738.         return model.getID();
  739.     }

  741. }
Created with JaCoCo 0.8.5.201910111838