ScenarioParser.java

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

  3. import java.io.Serializable;
  4. import java.util.ArrayList;
  5. import java.util.LinkedHashMap;
  6. import java.util.LinkedHashSet;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Set;
  10. import java.util.function.Supplier;

  12. import org.djunits.value.vdouble.scalar.Dimensionless;
  13. import org.djutils.base.Identifiable;
  14. import org.djutils.eval.Eval;
  15. import org.djutils.eval.RetrieveValue;
  16. import org.opentrafficsim.road.network.factory.xml.CircularDependencyException;
  17. import org.opentrafficsim.xml.bindings.types.ExpressionType;
  18. import org.opentrafficsim.xml.generated.Demand;
  19. import org.opentrafficsim.xml.generated.InputParameters;
  20. import org.opentrafficsim.xml.generated.ModelIdReferralType;
  21. import org.opentrafficsim.xml.generated.ScenarioType;
  22. import org.opentrafficsim.xml.generated.Scenarios;

  24. /**
  25.  * Parser of scenario tags.
  26.  * <p>
  27.  * Copyright (c) 2013-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
  28.  * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  29.  * </p>
  30.  * @author <a href="https://github.com/averbraeck">Alexander Verbraeck</a>
  31.  * @author <a href="https://tudelft.nl/staff/p.knoppers-1">Peter Knoppers</a>
  32.  * @author <a href="https://github.com/wjschakel">Wouter Schakel</a>
  33.  */
  34. public class ScenarioParser
  35. {

  37.     /**
  38.      * Parse input parameters for scenario.
  39.      * @param scenarios Scenarios; scenarios tag.
  40.      * @param scenario String; name of scenario tp parse.
  41.      * @return Eval; expression evaluator for all expression in XML.
  42.      */
  43.     public static Eval parseInputParameters(final Scenarios scenarios, final String scenario)
  44.     {
  45.         if (scenarios == null)
  46.         {
  47.             return new Eval();
  48.         }
  49.         ScenariosWrapper scenariosWrapper = new ScenariosWrapper()
  50.         {
  51.             /** {@inheritDoc} */
  52.             @Override
  53.             public Iterable<ParameterWrapper> getDefaultInputParameters()
  54.             {
  55.                 return getInputParameterIterator(scenarios.getDefaultInputParameters());
  56.             }

  58.             /** {@inheritDoc} */
  59.             @Override
  60.             public Iterable<ParameterWrapper> getScenarioInputParameters()
  61.             {
  62.                 for (ScenarioType scenarioTag : scenarios.getScenario())
  63.                 {
  64.                     if (scenarioTag.getId().equals(scenario))
  65.                     {
  66.                         return getInputParameterIterator(scenarioTag.getInputParameters());
  67.                     }
  68.                 }
  69.                 return null;
  70.             }
  71.         };
  72.         return parseInputParameters(scenariosWrapper);
  73.     }

  75.     /**
  76.      * Parse input parameters for scenario.
  77.      * @param scenariosWrapper ScenariosWrapper; scenarios wrapper, from XML or Xsd Tree nodes in editor.
  78.      * @return Eval; expression evaluator for all expression in XML.
  79.      */
  80.     public static Eval parseInputParameters(final ScenariosWrapper scenariosWrapper)
  81.     {
  82.         Map<String, Supplier<?>> defaultsMap = new LinkedHashMap<>();
  83.         ParameterMap defaults = new ParameterMap(defaultsMap);
  84.         Eval eval = new Eval().setRetrieveValue(defaults);
  85.         parseInputParameters(scenariosWrapper.getDefaultInputParameters(), defaultsMap, defaults);
  86.         if (scenariosWrapper.getScenarioInputParameters() != null)
  87.         {
  88.             Map<String, Supplier<?>> inputParametersMap = new LinkedHashMap<>();
  89.             ParameterMap inputParameters = new ParameterMap(inputParametersMap);
  90.             defaults.setScenarioMap(inputParameters);
  91.             parseInputParameters(scenariosWrapper.getScenarioInputParameters(), inputParametersMap, defaults);
  92.         }
  93.         // test whether values can be obtained successfully (might throw CircularDependencyException)
  94.         for (ParameterWrapper parameter : scenariosWrapper.getDefaultInputParameters())
  95.         {
  96.             String id = parameter.getId();
  97.             eval.evaluate(id.substring(1, id.length() - 1));
  98.         }
  99.         if (scenariosWrapper.getScenarioInputParameters() != null)
  100.         {
  101.             for (ParameterWrapper parameter : scenariosWrapper.getScenarioInputParameters())
  102.             {
  103.                 String id = parameter.getId();
  104.                 eval.evaluate(id.substring(1, id.length() - 1));
  105.             }
  106.         }
  107.         return eval;
  108.     }

  110.     /**
  111.      * Creates parsable parameters from an InputParameters XML tag (default or of a scenario).
  112.      * @param inputParameters InputParameters; parameters XML tag.
  113.      * @return ITerable&lt;ParameterWrapper&gt;; parameters in generic form for parsing.
  114.      */
  115.     private static Iterable<ParameterWrapper> getInputParameterIterator(final InputParameters inputParameters)
  116.     {
  117.         List<ParameterWrapper> parameters = new ArrayList<>();
  118.         if (inputParameters == null)
  119.         {
  120.             return parameters;
  121.         }
  122.         for (Serializable parameter : inputParameters.getDurationOrLengthOrSpeed())
  123.         {
  124.             if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Duration)
  125.             {
  126.                 org.opentrafficsim.xml.generated.InputParameters.Duration p =
  127.                         (org.opentrafficsim.xml.generated.InputParameters.Duration) parameter;
  128.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  129.             }
  130.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Length)
  131.             {
  132.                 org.opentrafficsim.xml.generated.InputParameters.Length p =
  133.                         (org.opentrafficsim.xml.generated.InputParameters.Length) parameter;
  134.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  135.             }
  136.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Speed)
  137.             {
  138.                 org.opentrafficsim.xml.generated.InputParameters.Speed p =
  139.                         (org.opentrafficsim.xml.generated.InputParameters.Speed) parameter;
  140.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  141.             }
  142.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Acceleration)
  143.             {
  144.                 org.opentrafficsim.xml.generated.InputParameters.Acceleration p =
  145.                         (org.opentrafficsim.xml.generated.InputParameters.Acceleration) parameter;
  146.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  147.             }
  148.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.LinearDensity)
  149.             {
  150.                 org.opentrafficsim.xml.generated.InputParameters.LinearDensity p =
  151.                         (org.opentrafficsim.xml.generated.InputParameters.LinearDensity) parameter;
  152.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  153.             }
  154.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Frequency)
  155.             {
  156.                 org.opentrafficsim.xml.generated.InputParameters.Frequency p =
  157.                         (org.opentrafficsim.xml.generated.InputParameters.Frequency) parameter;
  158.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  159.             }
  160.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Double)
  161.             {
  162.                 org.opentrafficsim.xml.generated.InputParameters.Double p =
  163.                         (org.opentrafficsim.xml.generated.InputParameters.Double) parameter;
  164.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  165.             }
  166.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Fraction)
  167.             {
  168.                 org.opentrafficsim.xml.generated.InputParameters.Fraction p =
  169.                         (org.opentrafficsim.xml.generated.InputParameters.Fraction) parameter;
  170.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  171.             }
  172.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Integer)
  173.             {
  174.                 org.opentrafficsim.xml.generated.InputParameters.Integer p =
  175.                         (org.opentrafficsim.xml.generated.InputParameters.Integer) parameter;
  176.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  177.             }
  178.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Boolean)
  179.             {
  180.                 org.opentrafficsim.xml.generated.InputParameters.Boolean p =
  181.                         (org.opentrafficsim.xml.generated.InputParameters.Boolean) parameter;
  182.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  183.             }
  184.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.String)
  185.             {
  186.                 org.opentrafficsim.xml.generated.InputParameters.String p =
  187.                         (org.opentrafficsim.xml.generated.InputParameters.String) parameter;
  188.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  189.             }
  190.             else if (parameter instanceof org.opentrafficsim.xml.generated.InputParameters.Class)
  191.             {
  192.                 org.opentrafficsim.xml.generated.InputParameters.Class p =
  193.                         (org.opentrafficsim.xml.generated.InputParameters.Class) parameter;
  194.                 parameters.add(new ParameterWrapper(p.getId(), p.getValue()));
  195.             }
  196.         }
  197.         return parameters;
  198.     }

  200.     /**
  201.      * Parse input parameters.
  202.      * @param inputParameters Iterable&lt;ParameterWrapper&gt;; xml tag.
  203.      * @param map Map&lt;String, Supplier&lt;?&gt;&gt;; map that underlines inputParameters.
  204.      * @param retrieve ParameterMap; value retrieval.
  205.      */
  206.     private static void parseInputParameters(final Iterable<ParameterWrapper> inputParameters,
  207.             final Map<String, Supplier<?>> map, final ParameterMap retrieve)
  208.     {
  209.         Eval eval = new Eval().setRetrieveValue(retrieve);
  210.         for (ParameterWrapper parameter : inputParameters)
  211.         {
  212.             // need to create a new Eval each time, as input parameters may depend on others
  213.             // NOTE: if Eval has additional user defined functions or unit parsers, that's not included here
  214.             String id = parameter.getId();
  215.             map.put(id.substring(1, id.length() - 1), () -> parameter.get().get(eval));
  216.         }
  217.     }

  219.     /**
  220.      * Parse model ID referrals.
  221.      * @param scenario List&lt;ScenarioType&gt;; scenario
  222.      * @param demand Demand; demand
  223.      * @param eval Eval; expression evaluator.
  224.      * @return map from ID to ID
  225.      */
  226.     public static final Map<String, String> parseModelIdReferral(final List<ScenarioType> scenario, final Demand demand,
  227.             final Eval eval)
  228.     {
  229.         // TODO: use run to select scenario (probably outside this class, and accept a single Scenario
  230.         Map<String, String> map = new LinkedHashMap<>();
  231.         for (ModelIdReferralType modelIdReferral : demand.getModelIdReferral())
  232.         {
  233.             map.put(modelIdReferral.getId(), modelIdReferral.getModelId().get(eval));
  234.         }
  235.         // overwrite with scenario level ID referrals
  236.         if (!scenario.isEmpty())
  237.         {
  238.             for (ModelIdReferralType modelIdReferral : scenario.get(0).getModelIdReferral())
  239.             {
  240.                 map.put(modelIdReferral.getId(), modelIdReferral.getModelId().get(eval));
  241.             }
  242.         }
  243.         return map;
  244.     }

  246.     /**
  247.      * Generic scenario form for parsing.
  248.      * <p>
  249.      * Copyright (c) 2023-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
  250.      * <br>
  251.      * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  252.      * </p>
  253.      * @author <a href="https://github.com/wjschakel">Wouter Schakel</a>
  254.      */
  255.     public static interface ScenariosWrapper
  256.     {
  257.         /**
  258.          * Returns default parameters in generic form for parsing.
  259.          * @return Iterable&lt;ParameterWrapper&gt;; default parameters in generic form for parsing.
  260.          */
  261.         Iterable<ParameterWrapper> getDefaultInputParameters();

  263.         /**
  264.          * Returns scenario parameters in generic form for parsing.
  265.          * @return Iterable&lt;ParameterWrapper&gt;; scenario parameters in generic form for parsing.
  266.          */
  267.         Iterable<ParameterWrapper> getScenarioInputParameters();
  268.     }

  270.     /**
  271.      * Generic parameters for for parsing.
  272.      * <p>
  273.      * Copyright (c) 2023-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
  274.      * <br>
  275.      * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  276.      * </p>
  277.      * @author <a href="https://github.com/wjschakel">Wouter Schakel</a>
  278.      * @param id String; id.
  279.      * @param value ExpressionType&lt;?&gt;; value expression type.
  280.      */
  281.     public static record ParameterWrapper(String id, ExpressionType<?> value)
  282.             implements Identifiable, Supplier<ExpressionType<?>>
  283.     {
  284.         /** {@inheritDoc} */
  285.         @Override
  286.         public String getId()
  287.         {
  288.             return this.id();
  289.         }

  291.         /** {@inheritDoc} */
  292.         @Override
  293.         public ExpressionType<?> get()
  294.         {
  295.             return this.value();
  296.         }
  297.     }

  299.     /**
  300.      * Wraps parameters to provide for expressions.
  301.      * <p>
  302.      * Copyright (c) 2023-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
  303.      * <br>
  304.      * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  305.      * </p>
  306.      * @author <a href="https://github.com/wjschakel">Wouter Schakel</a>
  307.      */
  308.     private static class ParameterMap implements RetrieveValue
  309.     {
  310.         /** Map of name to suppliers (constant or distribution). */
  311.         private final Map<String, Supplier<?>> map;

  313.         /** Set of currently looked up values, to detect circular dependency. */
  314.         private final Set<String> lookingUp = new LinkedHashSet<>();

  316.         /** More scenario input parameters. */
  317.         private ParameterMap scenario;

  319.         /**
  320.          * Constructor.
  321.          * @param map Map&lt;String, Supplier&lt;?&gt;&gt;; map that underlines input parameters.
  322.          */
  323.         public ParameterMap(final Map<String, Supplier<?>> map)
  324.         {
  325.             this.map = map;
  326.         }

  328.         /**
  329.          * Set scenario input parameters.
  330.          * @param scenario ParameterMap; parameter map of the scenario.
  331.          */
  332.         public void setScenarioMap(final ParameterMap scenario)
  333.         {
  334.             this.scenario = scenario;
  335.         }

  337.         /** {@inheritDoc} */
  338.         @Override
  339.         public Object lookup(final String name)
  340.         {
  341.             if (!this.lookingUp.add(name))
  342.             {
  343.                 throw new CircularDependencyException("Parameter " + name + " is part of a circular dependency.");
  344.             }
  345.             Object value;
  346.             if (this.scenario != null && this.scenario.map.containsKey(name))
  347.             {
  348.                 value = this.scenario.map.get(name).get();
  349.             }
  350.             else if (this.map.containsKey(name))
  351.             {
  352.                 value = this.map.get(name).get();
  353.             }
  354.             else
  355.             {
  356.                 this.lookingUp.remove(name);
  357.                 throw new RuntimeException("Parameter " + name + " not available.");
  358.             }
  359.             this.lookingUp.remove(name);
  360.             if (value instanceof Double)
  361.             {
  362.                 return Dimensionless.instantiateSI((Double) value);
  363.             }
  364.             return value;
  365.         }
  366.     }
  367. }
Created with JaCoCo 0.8.12.202403310830