Esempio n. 1
0
  @Override
  @SuppressWarnings("unchecked")
  public List<UserAlert> getAvailableAlerts() {
    List<UserAlert> alerts = new ArrayList<UserAlert>();

    final SortedMap<Integer, Pair> categoryNames = new ConcurrentSkipListMap<Integer, Pair>();

    HierarchicalConfiguration hc = (HierarchicalConfiguration) configuration;
    List<HierarchicalConfiguration> categories = hc.configurationsAt(ALERTS_CATEGORIES_CATEGORY);

    for (HierarchicalConfiguration c : categories) {
      String key = c.getString("[@key]");
      int order = c.getInt("[@displayOrder]", categoryNames.size());
      String value = c.getString("");

      categoryNames.put(order, new Pair<String, String>(key, value));
    }

    final String[] weeklyCategories = hc.getStringArray(ALERTS_WEEKLY);
    final String[] monthlyCategories = hc.getStringArray(ALERTS_MONTHLY);
    final String[] subjectFilters = hc.getStringArray(SUBJECT_FILTER);

    final Set<Map.Entry<Integer, Pair>> categoryNamesSet = categoryNames.entrySet();

    for (final Map.Entry<Integer, Pair> category : categoryNamesSet) {
      final String key = (String) category.getValue().getFirst();
      boolean weeklyCategoryKey = false;
      boolean monthlyCategoryKey = false;
      boolean subjectFilter = false;

      if (ArrayUtils.contains(weeklyCategories, key)) {
        weeklyCategoryKey = true;
      }
      if (ArrayUtils.contains(monthlyCategories, key)) {
        monthlyCategoryKey = true;
      }
      if (ArrayUtils.contains(subjectFilters, key)) {
        subjectFilter = true;
      }

      alerts.add(
          new UserAlert(
              (String) category.getValue().getFirst(),
              (String) category.getValue().getSecond(),
              weeklyCategoryKey,
              monthlyCategoryKey,
              subjectFilter));
    }
    return alerts;
  }
Esempio n. 2
0
  /** @return the availableThemes */
  public SortedMap<String, String> getAvailableThemes() {
    synchronized (this) {
      if (availableThemes == null) {
        this.availableThemes = new TreeMap<String, String>();

        List<HierarchicalConfiguration> configurations =
            configuration.configurationsAt("appearances.ui-theme.available-themes.theme");
        for (HierarchicalConfiguration config : configurations) {
          String name = config.getString("[@name]");
          availableThemes.put(StringUtils.capitalize(name), name);
        }
      }
    }

    return availableThemes;
  }
  public RoutingConfiguration parseConfiguration(HierarchicalConfiguration config)
      throws ConfigurationException {
    RoutingConfigurationImpl result = new RoutingConfigurationImpl();
    Set<AddressFamilyKey> keys = new HashSet<AddressFamilyKey>();

    for (HierarchicalConfiguration afConfig : config.configurationsAt("AddressFamily")) {
      AddressFamilyRoutingConfiguration afRouting = afParser.parseConfiguration(afConfig);

      if (keys.contains(afRouting.getKey()))
        throw new ConfigurationException("Duplicate address family: " + afRouting.getKey());

      result.getRoutingConfigurations().add(afRouting);
      keys.add(afRouting.getKey());
    }

    return result;
  }
  public GraphConfigurationContainer(final List<HierarchicalConfiguration> configurations)
      throws GraphConfigurationException {

    if (configurations == null) {
      throw new GraphConfigurationException("No graph configurations");
    }

    // create one graph for each configuration for each <graph> element
    final Iterator<HierarchicalConfiguration> it = configurations.iterator();
    while (it.hasNext()) {
      final HierarchicalConfiguration graphConfig = it.next();
      final String graphName = graphConfig.getString(Tokens.REXSTER_GRAPH_NAME, "");

      if (graphName.equals("")) {
        // all graphs must have a graph name
        logger.warn("Could not load graph " + graphName + ".  The graph-name element was not set.");
        this.failedConfigurations.add(graphConfig);
      } else {
        // check for duplicate graph configuration
        if (!this.graphs.containsKey(graphName)) {

          if (graphConfig.getBoolean(Tokens.REXSTER_GRAPH_ENABLED, true)) {

            // one graph failing initialization will not prevent the rest in
            // their attempt to be created
            try {
              final Graph graph = getGraphFromConfiguration(graphConfig);
              final RexsterApplicationGraph rag = new RexsterApplicationGraph(graphName, graph);

              // loads extensions that are allowed to be served for this graph
              final List extensionConfigs =
                  graphConfig.getList(Tokens.REXSTER_GRAPH_EXTENSIONS_ALLOWS_PATH);
              rag.loadAllowableExtensions(extensionConfigs);

              // loads extension configuration for this graph
              final List<HierarchicalConfiguration> extensionConfigurations =
                  graphConfig.configurationsAt(Tokens.REXSTER_GRAPH_EXTENSIONS_PATH);
              rag.loadExtensionsConfigurations(extensionConfigurations);

              this.graphs.put(rag.getGraphName(), rag);

              logger.info("Graph " + graphName + " - " + graph + " loaded");
            } catch (GraphConfigurationException gce) {
              logger.warn(
                  "Could not load graph " + graphName + ". Please check the XML configuration.");
              logger.warn(gce.getMessage());

              if (gce.getCause() != null) {
                logger.warn(gce.getCause().getMessage());
              }

              failedConfigurations.add(graphConfig);
            } catch (Exception e) {
              logger.warn("Could not load graph " + graphName + ".", e);

              failedConfigurations.add(graphConfig);
            }
          } else {
            logger.info("Graph " + graphName + " - " + " not enabled and not loaded.");
          }
        } else {
          logger.warn(
              "A graph with the name "
                  + graphName
                  + " was already configured.  Please check the XML configuration.");

          failedConfigurations.add(graphConfig);
        }
      }
    }
  }
Esempio n. 5
0
  private void readVehiclesAndTheirTypes(XMLConfiguration vrpProblem) {

    // read vehicle-types
    Map<String, VehicleType> types = new HashMap<String, VehicleType>();
    List<HierarchicalConfiguration> typeConfigs = vrpProblem.configurationsAt("vehicleTypes.type");
    for (HierarchicalConfiguration typeConfig : typeConfigs) {
      String typeId = typeConfig.getString("id");
      if (typeId == null) throw new IllegalStateException("typeId is missing.");

      String capacityString = typeConfig.getString("capacity");
      boolean capacityDimensionsExist = typeConfig.containsKey("capacity-dimensions.dimension(0)");
      if (capacityString == null && !capacityDimensionsExist) {
        throw new IllegalStateException("capacity of type is not set. use 'capacity-dimensions'");
      }
      if (capacityString != null && capacityDimensionsExist) {
        throw new IllegalStateException(
            "either use capacity or capacity-dimension, not both. prefer the use of 'capacity-dimensions' over 'capacity'.");
      }

      VehicleTypeImpl.Builder typeBuilder;
      if (capacityString != null) {
        typeBuilder =
            VehicleTypeImpl.Builder.newInstance(typeId)
                .addCapacityDimension(0, Integer.parseInt(capacityString));
      } else {
        typeBuilder = VehicleTypeImpl.Builder.newInstance(typeId);
        List<HierarchicalConfiguration> dimensionConfigs =
            typeConfig.configurationsAt("capacity-dimensions.dimension");
        for (HierarchicalConfiguration dimension : dimensionConfigs) {
          Integer index = dimension.getInt("[@index]");
          Integer value = dimension.getInt("");
          typeBuilder.addCapacityDimension(index, value);
        }
      }
      Double fix = typeConfig.getDouble("costs.fixed");
      Double timeC = typeConfig.getDouble("costs.time");
      Double distC = typeConfig.getDouble("costs.distance");

      if (fix != null) typeBuilder.setFixedCost(fix);
      if (timeC != null) typeBuilder.setCostPerTime(timeC);
      if (distC != null) typeBuilder.setCostPerDistance(distC);
      VehicleType type = typeBuilder.build();
      String id = type.getTypeId();
      String penalty = typeConfig.getString("[@type]");
      if (penalty != null) {
        if (penalty.equals("penalty")) {
          String penaltyFactor = typeConfig.getString("[@penaltyFactor]");
          if (penaltyFactor != null) {
            type = new PenaltyVehicleType(type, Double.parseDouble(penaltyFactor));
          } else type = new PenaltyVehicleType(type);
          id = id + "_penalty";
        }
      }

      types.put(id, type);
    }

    // read vehicles
    List<HierarchicalConfiguration> vehicleConfigs =
        vrpProblem.configurationsAt("vehicles.vehicle");
    boolean doNotWarnAgain = false;
    for (HierarchicalConfiguration vehicleConfig : vehicleConfigs) {
      String vehicleId = vehicleConfig.getString("id");
      if (vehicleId == null) throw new IllegalStateException("vehicleId is missing.");
      Builder builder = VehicleImpl.Builder.newInstance(vehicleId);
      String typeId = vehicleConfig.getString("typeId");
      if (typeId == null) throw new IllegalStateException("typeId is missing.");
      String vType = vehicleConfig.getString("[@type]");
      if (vType != null) {
        if (vType.equals("penalty")) {
          typeId += "_penalty";
        }
      }
      VehicleType type = types.get(typeId);
      if (type == null)
        throw new IllegalStateException("vehicleType with typeId " + typeId + " is missing.");
      builder.setType(type);
      String locationId = vehicleConfig.getString("location.id");
      if (locationId == null) {
        locationId = vehicleConfig.getString("startLocation.id");
      }
      if (locationId == null) throw new IllegalStateException("location.id is missing.");
      builder.setStartLocationId(locationId);
      String coordX = vehicleConfig.getString("location.coord[@x]");
      String coordY = vehicleConfig.getString("location.coord[@y]");
      if (coordX == null || coordY == null) {
        coordX = vehicleConfig.getString("startLocation.coord[@x]");
        coordY = vehicleConfig.getString("startLocation.coord[@y]");
      }
      if (coordX == null || coordY == null) {
        if (!doNotWarnAgain) {
          logger.warn("location.coord is missing. will not warn you again.");
          doNotWarnAgain = true;
        }
      } else {
        Coordinate coordinate =
            Coordinate.newInstance(Double.parseDouble(coordX), Double.parseDouble(coordY));
        builder.setStartLocationCoordinate(coordinate);
      }

      String endLocationId = vehicleConfig.getString("endLocation.id");
      if (endLocationId != null) builder.setEndLocationId(endLocationId);
      String endCoordX = vehicleConfig.getString("endLocation.coord[@x]");
      String endCoordY = vehicleConfig.getString("endLocation.coord[@y]");
      if (endCoordX == null || endCoordY == null) {
        if (!doNotWarnAgain) {
          logger.warn("endLocation.coord is missing. will not warn you again.");
          doNotWarnAgain = true;
        }
      } else {
        Coordinate coordinate =
            Coordinate.newInstance(Double.parseDouble(endCoordX), Double.parseDouble(endCoordY));
        builder.setEndLocationCoordinate(coordinate);
      }

      String start = vehicleConfig.getString("timeSchedule.start");
      String end = vehicleConfig.getString("timeSchedule.end");
      if (start != null) builder.setEarliestStart(Double.parseDouble(start));
      if (end != null) builder.setLatestArrival(Double.parseDouble(end));
      String returnToDepot = vehicleConfig.getString("returnToDepot");
      if (returnToDepot != null) {
        builder.setReturnToDepot(vehicleConfig.getBoolean("returnToDepot"));
      }
      VehicleImpl vehicle = builder.build();
      vrpBuilder.addVehicle(vehicle);
      vehicleMap.put(vehicleId, vehicle);
    }
  }
Esempio n. 6
0
  private void readServices(XMLConfiguration vrpProblem) {
    List<HierarchicalConfiguration> serviceConfigs =
        vrpProblem.configurationsAt("services.service");
    for (HierarchicalConfiguration serviceConfig : serviceConfigs) {
      String id = serviceConfig.getString("[@id]");
      if (id == null) throw new IllegalStateException("service[@id] is missing.");
      String type = serviceConfig.getString("[@type]");
      if (type == null) type = "service";

      String capacityString = serviceConfig.getString("capacity-demand");
      boolean capacityDimensionsExist =
          serviceConfig.containsKey("capacity-dimensions.dimension(0)");
      if (capacityString == null && !capacityDimensionsExist) {
        throw new IllegalStateException(
            "capacity of service is not set. use 'capacity-dimensions'");
      }
      if (capacityString != null && capacityDimensionsExist) {
        throw new IllegalStateException(
            "either use capacity or capacity-dimension, not both. prefer the use of 'capacity-dimensions' over 'capacity'.");
      }

      Service.Builder builder;
      if (capacityString != null) {
        builder = serviceBuilderFactory.createBuilder(type, id, Integer.parseInt(capacityString));
      } else {
        builder = serviceBuilderFactory.createBuilder(type, id, null);
        List<HierarchicalConfiguration> dimensionConfigs =
            serviceConfig.configurationsAt("capacity-dimensions.dimension");
        for (HierarchicalConfiguration dimension : dimensionConfigs) {
          Integer index = dimension.getInt("[@index]");
          Integer value = dimension.getInt("");
          builder.addSizeDimension(index, value);
        }
      }
      String serviceLocationId = serviceConfig.getString("locationId");
      if (serviceLocationId != null) builder.setLocationId(serviceLocationId);
      Coordinate serviceCoord = getCoord(serviceConfig, "");
      if (serviceCoord != null) {
        builder.setCoord(serviceCoord);
        if (serviceLocationId != null) {
          //					vrpBuilder.addLocation(serviceLocationId,serviceCoord);
        } else {
          //					vrpBuilder.addLocation(serviceCoord.toString(),serviceCoord);
          builder.setLocationId(serviceCoord.toString());
        }
      }
      if (serviceConfig.containsKey("duration")) {
        builder.setServiceTime(serviceConfig.getDouble("duration"));
      }
      List<HierarchicalConfiguration> deliveryTWConfigs =
          serviceConfig.configurationsAt("timeWindows.timeWindow");
      if (!deliveryTWConfigs.isEmpty()) {
        for (HierarchicalConfiguration twConfig : deliveryTWConfigs) {
          builder.setTimeWindow(
              TimeWindow.newInstance(twConfig.getDouble("start"), twConfig.getDouble("end")));
        }
      }
      Service service = builder.build();
      serviceMap.put(service.getId(), service);
      //			vrpBuilder.addJob(service);

    }
  }
Esempio n. 7
0
  private void readShipments(XMLConfiguration config) {
    List<HierarchicalConfiguration> shipmentConfigs = config.configurationsAt("shipments.shipment");
    for (HierarchicalConfiguration shipmentConfig : shipmentConfigs) {
      String id = shipmentConfig.getString("[@id]");
      if (id == null) throw new IllegalStateException("shipment[@id] is missing.");

      String capacityString = shipmentConfig.getString("capacity-demand");
      boolean capacityDimensionsExist =
          shipmentConfig.containsKey("capacity-dimensions.dimension(0)");
      if (capacityString == null && !capacityDimensionsExist) {
        throw new IllegalStateException(
            "capacity of shipment is not set. use 'capacity-dimensions'");
      }
      if (capacityString != null && capacityDimensionsExist) {
        throw new IllegalStateException(
            "either use capacity or capacity-dimension, not both. prefer the use of 'capacity-dimensions' over 'capacity'.");
      }

      Shipment.Builder builder;
      if (capacityString != null) {
        builder =
            Shipment.Builder.newInstance(id).addSizeDimension(0, Integer.parseInt(capacityString));
      } else {
        builder = Shipment.Builder.newInstance(id);
        List<HierarchicalConfiguration> dimensionConfigs =
            shipmentConfig.configurationsAt("capacity-dimensions.dimension");
        for (HierarchicalConfiguration dimension : dimensionConfigs) {
          Integer index = dimension.getInt("[@index]");
          Integer value = dimension.getInt("");
          builder.addSizeDimension(index, value);
        }
      }

      // pickup-locationId
      String pickupLocationId = shipmentConfig.getString("pickup.locationId");
      if (pickupLocationId != null) {
        builder.setPickupLocation(pickupLocationId);
      }

      // pickup-coord
      Coordinate pickupCoord = getCoord(shipmentConfig, "pickup.");
      if (pickupCoord != null) {
        builder.setPickupCoord(pickupCoord);
        if (pickupLocationId != null) {
          //					vrpBuilder.addLocation(pickupLocationId,pickupCoord);
        } else {
          //					vrpBuilder.addLocation(pickupCoord.toString(),pickupCoord);
          builder.setPickupLocation(pickupCoord.toString());
        }
      }
      // pickup-serviceTime
      String pickupServiceTime = shipmentConfig.getString("pickup.duration");
      if (pickupServiceTime != null)
        builder.setPickupServiceTime(Double.parseDouble(pickupServiceTime));

      // pickup-tw
      String pickupTWStart = shipmentConfig.getString("pickup.timeWindows.timeWindow(0).start");
      String pickupTWEnd = shipmentConfig.getString("pickup.timeWindows.timeWindow(0).end");
      if (pickupTWStart != null && pickupTWEnd != null) {
        TimeWindow pickupTW =
            TimeWindow.newInstance(
                Double.parseDouble(pickupTWStart), Double.parseDouble(pickupTWEnd));
        builder.setPickupTimeWindow(pickupTW);
      }

      // delivery-locationId
      String deliveryLocationId = shipmentConfig.getString("delivery.locationId");
      if (deliveryLocationId != null) {
        builder.setDeliveryLocation(deliveryLocationId);
      }

      // delivery-coord
      Coordinate deliveryCoord = getCoord(shipmentConfig, "delivery.");
      if (deliveryCoord != null) {
        builder.setDeliveryCoord(deliveryCoord);
        if (deliveryLocationId != null) {
          //					vrpBuilder.addLocation(deliveryLocationId,deliveryCoord);
        } else {
          //					vrpBuilder.addLocation(deliveryCoord.toString(),deliveryCoord);
          builder.setDeliveryLocation(deliveryCoord.toString());
        }
      }
      // delivery-serviceTime
      String deliveryServiceTime = shipmentConfig.getString("delivery.duration");
      if (deliveryServiceTime != null)
        builder.setDeliveryServiceTime(Double.parseDouble(deliveryServiceTime));

      // delivery-tw
      String delTWStart = shipmentConfig.getString("delivery.timeWindows.timeWindow(0).start");
      String delTWEnd = shipmentConfig.getString("delivery.timeWindows.timeWindow(0).end");
      if (delTWStart != null && delTWEnd != null) {
        TimeWindow delTW =
            TimeWindow.newInstance(Double.parseDouble(delTWStart), Double.parseDouble(delTWEnd));
        builder.setDeliveryTimeWindow(delTW);
      }

      Shipment shipment = builder.build();
      //			vrpBuilder.addJob(shipment);
      shipmentMap.put(shipment.getId(), shipment);
    }
  }
Esempio n. 8
0
  private void readSolutions(XMLConfiguration vrpProblem) {
    if (solutions == null) return;
    List<HierarchicalConfiguration> solutionConfigs =
        vrpProblem.configurationsAt("solutions.solution");
    for (HierarchicalConfiguration solutionConfig : solutionConfigs) {
      String totalCost = solutionConfig.getString("cost");
      double cost = -1;
      if (totalCost != null) cost = Double.parseDouble(totalCost);
      List<HierarchicalConfiguration> routeConfigs =
          solutionConfig.configurationsAt("routes.route");
      List<VehicleRoute> routes = new ArrayList<VehicleRoute>();
      for (HierarchicalConfiguration routeConfig : routeConfigs) {
        // ! here, driverId is set to noDriver, no matter whats in driverId.
        Driver driver = DriverImpl.noDriver();
        String vehicleId = routeConfig.getString("vehicleId");
        Vehicle vehicle = getVehicle(vehicleId);
        if (vehicle == null) throw new IllegalStateException("vehicle is missing.");
        String start = routeConfig.getString("start");
        if (start == null) throw new IllegalStateException("route start-time is missing.");
        double departureTime = Double.parseDouble(start);

        String end = routeConfig.getString("end");
        if (end == null) throw new IllegalStateException("route end-time is missing.");

        VehicleRoute.Builder routeBuilder = VehicleRoute.Builder.newInstance(vehicle, driver);
        routeBuilder.setDepartureTime(departureTime);
        routeBuilder.setRouteEndArrivalTime(Double.parseDouble(end));
        List<HierarchicalConfiguration> actConfigs = routeConfig.configurationsAt("act");
        for (HierarchicalConfiguration actConfig : actConfigs) {
          String type = actConfig.getString("[@type]");
          if (type == null) throw new IllegalStateException("act[@type] is missing.");
          double arrTime = 0.;
          double endTime = 0.;
          String arrTimeS = actConfig.getString("arrTime");
          if (arrTimeS != null) arrTime = Double.parseDouble(arrTimeS);
          String endTimeS = actConfig.getString("endTime");
          if (endTimeS != null) endTime = Double.parseDouble(endTimeS);

          String serviceId = actConfig.getString("serviceId");
          if (serviceId != null) {
            Service service = getService(serviceId);
            routeBuilder.addService(service, arrTime, endTime);
          } else {
            String shipmentId = actConfig.getString("shipmentId");
            if (shipmentId == null)
              throw new IllegalStateException("either serviceId or shipmentId is missing");
            Shipment shipment = getShipment(shipmentId);
            if (shipment == null)
              throw new IllegalStateException(
                  "shipment with id " + shipmentId + " does not exist.");
            if (type.equals("pickupShipment")) {
              routeBuilder.addPickup(shipment, arrTime, endTime);
            } else if (type.equals("deliverShipment")) {
              routeBuilder.addDelivery(shipment, arrTime, endTime);
            } else
              throw new IllegalStateException(
                  "type "
                      + type
                      + " is not supported. Use 'pickupShipment' or 'deliverShipment' here");
          }
        }
        routes.add(routeBuilder.build());
      }
      VehicleRoutingProblemSolution solution = new VehicleRoutingProblemSolution(routes, cost);
      solutions.add(solution);
    }
  }
Esempio n. 9
0
  private void readInitialRoutes(XMLConfiguration xmlConfig) {
    List<HierarchicalConfiguration> initialRouteConfigs =
        xmlConfig.configurationsAt("initialRoutes.route");
    for (HierarchicalConfiguration routeConfig : initialRouteConfigs) {
      Driver driver = DriverImpl.noDriver();
      String vehicleId = routeConfig.getString("vehicleId");
      Vehicle vehicle = getVehicle(vehicleId);
      if (vehicle == null) throw new IllegalStateException("vehicle is missing.");
      String start = routeConfig.getString("start");
      if (start == null) throw new IllegalStateException("route start-time is missing.");
      double departureTime = Double.parseDouble(start);

      VehicleRoute.Builder routeBuilder = VehicleRoute.Builder.newInstance(vehicle, driver);
      routeBuilder.setDepartureTime(departureTime);

      List<HierarchicalConfiguration> actConfigs = routeConfig.configurationsAt("act");
      for (HierarchicalConfiguration actConfig : actConfigs) {
        String type = actConfig.getString("[@type]");
        if (type == null) throw new IllegalStateException("act[@type] is missing.");
        double arrTime = 0.;
        double endTime = 0.;
        String arrTimeS = actConfig.getString("arrTime");
        if (arrTimeS != null) arrTime = Double.parseDouble(arrTimeS);
        String endTimeS = actConfig.getString("endTime");
        if (endTimeS != null) endTime = Double.parseDouble(endTimeS);

        String serviceId = actConfig.getString("serviceId");
        if (serviceId != null) {
          Service service = getService(serviceId);
          if (service == null)
            throw new IllegalStateException(
                "service to serviceId "
                    + serviceId
                    + " is missing (reference in one of your initial routes). make sure you define the service you refer to here in <services> </services>.");
          // !!!since job is part of initial route, it does not belong to jobs in problem, i.e.
          // variable jobs that can be assigned/scheduled
          freezedJobIds.add(serviceId);
          routeBuilder.addService(service, arrTime, endTime);
        } else {
          String shipmentId = actConfig.getString("shipmentId");
          if (shipmentId == null)
            throw new IllegalStateException("either serviceId or shipmentId is missing");
          Shipment shipment = getShipment(shipmentId);
          if (shipment == null)
            throw new IllegalStateException(
                "shipment to shipmentId "
                    + shipmentId
                    + " is missing (reference in one of your initial routes). make sure you define the shipment you refer to here in <shipments> </shipments>.");
          freezedJobIds.add(shipmentId);
          if (type.equals("pickupShipment")) {
            routeBuilder.addPickup(shipment, arrTime, endTime);
          } else if (type.equals("deliverShipment")) {
            routeBuilder.addDelivery(shipment, arrTime, endTime);
          } else
            throw new IllegalStateException(
                "type "
                    + type
                    + " is not supported. Use 'pickupShipment' or 'deliverShipment' here");
        }
      }
      VehicleRoute route = routeBuilder.build();
      vrpBuilder.addInitialVehicleRoute(route);
    }
  }