private void storeVehicleTypeInfo() {
    modeVehicleTypes = new HashMap<String, VehicleType>();
    mode2FlowData = new HashMap<>();

    VehicleType car =
        VehicleUtils.getFactory().createVehicleType(Id.create("car", VehicleType.class));
    car.setMaximumVelocity(16.667);
    car.setPcuEquivalents(1.0);
    modeVehicleTypes.put("car", car);

    VehicleType bike =
        VehicleUtils.getFactory().createVehicleType(Id.create("bike", VehicleType.class));
    bike.setMaximumVelocity(4.167);
    bike.setPcuEquivalents(0.25);
    modeVehicleTypes.put("bike", bike);

    VehicleType truck =
        VehicleUtils.getFactory().createVehicleType(Id.create("truck", VehicleType.class));
    truck.setMaximumVelocity(8.33);
    truck.setPcuEquivalents(3.);
    modeVehicleTypes.put("truck", truck);

    for (String mode : travelModes) {
      TravelModesFlowDynamicsUpdator modeUpdator =
          new TravelModesFlowDynamicsUpdator(modeVehicleTypes.get(mode));
      mode2FlowData.put(modeVehicleTypes.get(mode).getId(), modeUpdator);
    }
  }
  public CreateInitialTimeSchedule(
      String networkInFile, double gridDistance, Coord minXY, Coord maxXY, int numberOfAgents) {
    ScenarioImpl sc = (ScenarioImpl) ScenarioUtils.createScenario(ConfigUtils.createConfig());
    MatsimNetworkReader netReader = new MatsimNetworkReader(sc);
    netReader.readFile(networkInFile);
    this.net = (NetworkImpl) sc.getNetwork();

    this.tS = CreateStops.createStops(this.net, gridDistance, minXY, maxXY);
    this.veh = VehicleUtils.createVehiclesContainer();
    this.numberOfAgents = numberOfAgents;
  }
Пример #3
0
  /**
   * Setting up the simulation {@link Scenario}, using a given {@link Config}. In the scenario setup
   * each network link is given both {@code car} and {@code commercial} as mode. Also, each person
   * is assigned a vehicle, which is based on the Gauteng Freeway Improvement Project (GFIP) vehicle
   * toll classes. the following vehicle types are available.
   *
   * <ul>
   *   <li>{@code A2}: Light delivery vehicle with length 7.0m, maximum velocity of 100km/h, and
   *       accounting for 80% of all commercial vehicles;
   *   <li>{@code B}: Short heavy vehicles with length 12.0m, maximum velocity of 90km/h, and
   *       accounting for 15% of all commercial vehicles; and
   *   <li>{@code C}: Long heavy vehicles with length 20.0m, maximum velocity of 90km/h, and
   *       accounting for the remaining 5% of all commercial vehicles.
   * </ul>
   *
   * These vehicle classes are randomly sampled and assigned to the individuals. No cognisance is
   * given to intra- and inter-area traffic (based on the activity chain structure). This
   * <i><b>should</b></i> be refined.
   *
   * @param config typically the {@link Config} resulting from calling the method {@link
   *     #setupConfig(String, Machine)}.
   * @return a scenario in which the network has the necessary {@code commercial} mode; and each
   *     agent has a vehicle with a particular commercial vehicle class.
   */
  public static Scenario setupScenario(Config config) {
    Scenario sc = ScenarioUtils.loadScenario(config);

    /* Ensure that all links take 'commercial' as mode. */
    LOG.warn("Ensuring all links take 'commercial' as mode...");
    Collection<String> modesCollection = Arrays.asList("car", "commercial");
    Set<String> modesSet = new HashSet<>(modesCollection);
    for (Link link : sc.getNetwork().getLinks().values()) {
      link.setAllowedModes(modesSet);
    }
    LOG.warn("Done adding 'commercial' modes.");

    /* Add all VehicleTypes. */
    Vehicles vehicles = sc.getVehicles();
    for (VehicleTypeSA vt : VehicleTypeSA.values()) {
      vehicles.addVehicleType(vt.getVehicleType());
    }

    MatsimRandom.reset(2015093001l);
    for (Person person : sc.getPopulation().getPersons().values()) {
      /* Randomly sample a vehicle type for each person. */
      VehicleType vehicleType = null;
      double r = MatsimRandom.getRandom().nextDouble();
      if (r <= 0.8) {
        vehicleType = VehicleTypeSA.A2.getVehicleType();
      } else if (r <= 0.95) {
        vehicleType = VehicleTypeSA.B.getVehicleType();
      } else {
        vehicleType = VehicleTypeSA.C.getVehicleType();
      }

      Vehicle truck =
          VehicleUtils.getFactory()
              .createVehicle(Id.create(person.getId(), Vehicle.class), vehicleType);
      vehicles.addVehicle(truck);

      /* Link the vehicle type to the person's attributes. */
      sc.getPopulation()
          .getPersonAttributes()
          .putAttribute(person.getId().toString(), "vehicleType", vehicleType.getId().toString());
    }

    return sc;
  }
Пример #4
0
 public TaxiModule(TaxiData taxiData) {
   this(taxiData, VehicleUtils.getDefaultVehicleType());
 }
Пример #5
0
  public static void main(String[] args) {

    //		SubpopulationConfig subPopConfig = new SubpopulationConfig();
    //		subPopConfig.run();
    //		Config config = subPopConfig.getPatnaConfig();
    Config config = ConfigUtils.loadConfig(args[0]);
    Scenario sc = ScenarioUtils.loadScenario(config);

    sc.getConfig().qsim().setUseDefaultVehicles(false);
    ((ScenarioImpl) sc).createVehicleContainer();

    Map<String, VehicleType> modesType = new HashMap<String, VehicleType>();
    VehicleType slum_car =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_car", VehicleType.class));
    slum_car.setMaximumVelocity(60.0 / 3.6);
    slum_car.setPcuEquivalents(1.0);
    modesType.put("slum_car", slum_car);
    sc.getVehicles().addVehicleType(slum_car);

    VehicleType nonSlum_car =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_car", VehicleType.class));
    nonSlum_car.setMaximumVelocity(60.0 / 3.6);
    nonSlum_car.setPcuEquivalents(1.0);
    modesType.put("nonSlum_car", nonSlum_car);
    sc.getVehicles().addVehicleType(nonSlum_car);

    VehicleType slum_motorbike =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_motorbike", VehicleType.class));
    slum_motorbike.setMaximumVelocity(60.0 / 3.6);
    slum_motorbike.setPcuEquivalents(0.25);
    modesType.put("slum_motorbike", slum_motorbike);
    sc.getVehicles().addVehicleType(slum_motorbike);

    VehicleType nonSlum_motorbike =
        VehicleUtils.getFactory()
            .createVehicleType(Id.create("nonSlum_motorbike", VehicleType.class));
    nonSlum_motorbike.setMaximumVelocity(60.0 / 3.6);
    nonSlum_motorbike.setPcuEquivalents(0.25);
    modesType.put("nonSlum_motorbike", nonSlum_motorbike);
    sc.getVehicles().addVehicleType(nonSlum_motorbike);

    VehicleType slum_bike =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_bike", VehicleType.class));
    slum_bike.setMaximumVelocity(15.0 / 3.6);
    slum_bike.setPcuEquivalents(0.25);
    modesType.put("slum_bike", slum_bike);
    sc.getVehicles().addVehicleType(slum_bike);

    VehicleType nonSlum_bike =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_bike", VehicleType.class));
    nonSlum_bike.setMaximumVelocity(15.0 / 3.6);
    nonSlum_bike.setPcuEquivalents(0.25);
    modesType.put("nonSlum_bike", nonSlum_bike);
    sc.getVehicles().addVehicleType(nonSlum_bike);

    VehicleType slum_walk =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_walk", VehicleType.class));
    slum_walk.setMaximumVelocity(1.5);
    //		walk.setPcuEquivalents(0.10);
    modesType.put("slum_walk", slum_walk);
    sc.getVehicles().addVehicleType(slum_walk);

    VehicleType nonSlum_walk =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_walk", VehicleType.class));
    nonSlum_walk.setMaximumVelocity(1.5);
    //		walk.setPcuEquivalents(0.10);
    modesType.put("nonSlum_walk", nonSlum_walk);
    sc.getVehicles().addVehicleType(nonSlum_walk);

    VehicleType slum_pt =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_pt", VehicleType.class));
    slum_pt.setMaximumVelocity(40 / 3.6);
    //		pt.setPcuEquivalents(5);
    modesType.put("slum_pt", slum_pt);
    sc.getVehicles().addVehicleType(slum_pt);

    VehicleType nonSlum_pt =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_pt", VehicleType.class));
    nonSlum_pt.setMaximumVelocity(40 / 3.6);
    //		pt.setPcuEquivalents(5);
    modesType.put("nonSlum_pt", nonSlum_pt);
    sc.getVehicles().addVehicleType(nonSlum_pt);

    for (Person p : sc.getPopulation().getPersons().values()) {
      Id<Vehicle> vehicleId = Id.create(p.getId(), Vehicle.class);
      String travelMode = null;
      for (PlanElement pe : p.getSelectedPlan().getPlanElements()) {
        if (pe instanceof Leg) {
          travelMode = ((Leg) pe).getMode();
          break;
        }
      }
      Vehicle vehicle =
          VehicleUtils.getFactory().createVehicle(vehicleId, modesType.get(travelMode));
      sc.getVehicles().addVehicle(vehicle);
    }

    final Controler controler = new Controler(sc);

    //		IOUtils.deleteDirectory(new File(controler.getConfig().controler().getOutputDirectory()));
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
    controler.setDumpDataAtEnd(true);
    controler.getConfig().controler().setCreateGraphs(true);

    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            addPlanStrategyBinding("ChangeLegMode_slum")
                .toProvider(
                    new javax.inject.Provider<PlanStrategy>() {
                      String[] availableModes_slum = {
                        "slum_bike", "slum_motorbike", "slum_pt", "slum_walk"
                      };

                      @Override
                      public PlanStrategy get() {
                        final Builder builder = new Builder(new RandomPlanSelector<Plan, Person>());
                        builder.addStrategyModule(
                            new ChangeLegMode(
                                controler.getConfig().global().getNumberOfThreads(),
                                availableModes_slum,
                                true));
                        builder.addStrategyModule(new ReRoute(controler.getScenario()));
                        return builder.build();
                      }
                    });
          }
        });

    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            addPlanStrategyBinding("ChangeLegMode_nonSlum")
                .toProvider(
                    new javax.inject.Provider<PlanStrategy>() {
                      String[] availableModes_nonSlum = {
                        "nonSlum_car",
                        "nonSlum_bike",
                        "nonSlum_motorbike",
                        "nonSlum_pt",
                        "nonSlum_walk"
                      };

                      @Override
                      public PlanStrategy get() {
                        final Builder builder = new Builder(new RandomPlanSelector<Plan, Person>());
                        builder.addStrategyModule(
                            new ChangeLegMode(
                                controler.getConfig().global().getNumberOfThreads(),
                                availableModes_nonSlum,
                                true));
                        builder.addStrategyModule(new ReRoute(controler.getScenario()));
                        return builder.build();
                      }
                    });
          }
        });

    //		controler.setScoringFunctionFactory(new
    // SubPopulationScoringFactory(controler.getScenario()));
    controler.run();
  }
Пример #6
0
/**
 * Calculates a least-cost-path tree using Dijkstra's algorithm for calculating a shortest-path
 * tree, given a node as root of the tree.
 *
 * @author balmermi, mrieser
 */
public class LeastCostPathTree {

  // ////////////////////////////////////////////////////////////////////
  // member variables
  // ////////////////////////////////////////////////////////////////////

  private Node origin1 = null;
  private double dTime = Time.UNDEFINED_TIME;

  private final TravelTime ttFunction;
  private final TravelDisutility tcFunction;
  private HashMap<Id<Node>, NodeData> nodeData = null;

  private final Vehicle VEHICLE =
      VehicleUtils.getFactory()
          .createVehicle(
              Id.create("theVehicle", Vehicle.class), VehicleUtils.getDefaultVehicleType());
  private final Person PERSON = PopulationUtils.createPerson(Id.create("thePerson", Person.class));

  // ////////////////////////////////////////////////////////////////////
  // constructors
  // ////////////////////////////////////////////////////////////////////

  public LeastCostPathTree(TravelTime tt, TravelDisutility tc) {
    this.ttFunction = tt;
    this.tcFunction = tc;
  }

  public void calculate(final Network network, final Node origin, final double time) {
    this.origin1 = origin;
    this.dTime = time;

    this.nodeData = new HashMap<Id<Node>, NodeData>((int) (network.getNodes().size() * 1.1), 0.95f);
    NodeData d = new NodeData();
    d.time = time;
    d.cost = 0;
    this.nodeData.put(origin.getId(), d);

    ComparatorCost comparator = new ComparatorCost(this.nodeData);
    PriorityQueue<Node> pendingNodes = new PriorityQueue<Node>(500, comparator);
    relaxNode(origin, pendingNodes);
    while (!pendingNodes.isEmpty()) {
      Node n = pendingNodes.poll();
      relaxNode(n, pendingNodes);
    }
  }

  // ////////////////////////////////////////////////////////////////////
  // inner classes
  // ////////////////////////////////////////////////////////////////////

  public static class NodeData {
    private Id<Node> prevId = null;
    private double cost = Double.MAX_VALUE;
    private double time = 0;

    /*package*/ void visit(
        final Id<Node> comingFromNodeId, final double cost1, final double time1) {
      this.prevId = comingFromNodeId;
      this.cost = cost1;
      this.time = time1;
    }

    public double getCost() {
      return this.cost;
    }

    public double getTime() {
      return this.time;
    }

    public Id<Node> getPrevNodeId() {
      return this.prevId;
    }
  }

  /*package*/ static class ComparatorCost implements Comparator<Node> {
    protected Map<Id<Node>, ? extends NodeData> nodeData;

    ComparatorCost(final Map<Id<Node>, ? extends NodeData> nodeData) {
      this.nodeData = nodeData;
    }

    @Override
    public int compare(final Node n1, final Node n2) {
      double c1 = getCost(n1);
      double c2 = getCost(n2);
      if (c1 < c2) return -1;
      if (c1 > c2) return +1;
      return n1.getId().compareTo(n2.getId());
    }

    protected double getCost(final Node node) {
      return this.nodeData.get(node.getId()).getCost();
    }
  }

  // ////////////////////////////////////////////////////////////////////
  // get methods
  // ////////////////////////////////////////////////////////////////////

  public final Map<Id<Node>, NodeData> getTree() {
    return this.nodeData;
  }

  /**
   * @return Returns the root of the calculated tree, or <code>null</code> if no tree was calculated
   *     yet.
   */
  public final Node getOrigin() {
    return this.origin1;
  }

  public final double getDepartureTime() {
    return this.dTime;
  }

  // ////////////////////////////////////////////////////////////////////
  // private methods
  // ////////////////////////////////////////////////////////////////////

  private void relaxNode(final Node n, PriorityQueue<Node> pendingNodes) {
    NodeData nData = nodeData.get(n.getId());
    double currTime = nData.getTime();
    double currCost = nData.getCost();
    for (Link l : n.getOutLinks().values()) {
      Node nn = l.getToNode();
      NodeData nnData = nodeData.get(nn.getId());
      if (nnData == null) {
        nnData = new NodeData();
        this.nodeData.put(nn.getId(), nnData);
      }
      double visitCost =
          currCost + tcFunction.getLinkTravelDisutility(l, currTime, PERSON, VEHICLE);
      double visitTime = currTime + ttFunction.getLinkTravelTime(l, currTime, PERSON, VEHICLE);

      if (visitCost < nnData.getCost()) {
        pendingNodes.remove(nn);
        nnData.visit(n.getId(), visitCost, visitTime);
        additionalComputationsHook(l, currTime);
        pendingNodes.add(nn);
      }
    }
  }

  protected void additionalComputationsHook(Link link, double currTime) {
    // left empty for inheritance
  }

  // ////////////////////////////////////////////////////////////////////
  // main method
  // ////////////////////////////////////////////////////////////////////

  public static void main(String[] args) {
    MutableScenario scenario =
        (MutableScenario) ScenarioUtils.createScenario(ConfigUtils.createConfig());
    Network network = scenario.getNetwork();
    new MatsimNetworkReader(scenario).readFile("../../input/network.xml");

    TravelTimeCalculator ttc =
        new TravelTimeCalculator(
            network, 60, 30 * 3600, scenario.getConfig().travelTimeCalculator());
    LeastCostPathTree st =
        new LeastCostPathTree(
            ttc.getLinkTravelTimes(),
            new RandomizingTimeDistanceTravelDisutility.Builder(TransportMode.car)
                .createTravelDisutility(
                    ttc.getLinkTravelTimes(), scenario.getConfig().planCalcScore()));
    Node origin = network.getNodes().get(Id.create(1, Node.class));
    st.calculate(network, origin, 8 * 3600);
    Map<Id<Node>, NodeData> tree = st.getTree();
    for (Map.Entry<Id<Node>, NodeData> e : tree.entrySet()) {
      Id<Node> id = e.getKey();
      NodeData d = e.getValue();
      if (d.getPrevNodeId() != null) {
        System.out.println(id + "\t" + d.getTime() + "\t" + d.getCost() + "\t" + d.getPrevNodeId());
      } else {
        System.out.println(id + "\t" + d.getTime() + "\t" + d.getCost() + "\t" + "0");
      }
    }
  }
}
Пример #7
0
  public static void main(final String[] args) throws FileNotFoundException, IOException {

    //////////////////
    // OPEN CONFIG FILE
    //////////////////

    JFileChooser fc;
    int state;
    String GTFSCONFIGNAME = null;
    if (args.length == 1) {
      GTFSCONFIGNAME = args[0];
    } else {
      fc = new JFileChooser();
      fc.setDialogTitle("Please select GTFS config file");
      fc.setFileFilter(
          new FileFilter() {
            @Override
            public String getDescription() {
              return "GTFS config file *.xml";
            }

            @Override
            public boolean accept(File f) {
              return f.isDirectory() || f.getName().toLowerCase(Locale.ROOT).endsWith(".xml");
            }
          });
      state = fc.showOpenDialog(null);
      if (state == JFileChooser.APPROVE_OPTION) {
        GTFSCONFIGNAME = fc.getSelectedFile().getAbsolutePath();
      } else if (state == JFileChooser.CANCEL_OPTION) return;
    }

    if (GTFSCONFIGNAME == null) return;

    Config config = ConfigUtils.loadConfig(GTFSCONFIGNAME);

    String[] rts = config.getParam("gtfs", "roots").split(",");
    File[] roots = new File[rts.length];
    for (int i = 0; i < roots.length; i++) roots[i] = new File(rts[i]);

    // (File[] roots, String[] modes, Network network, String[] serviceIds, String
    // outCoordinateSystem)
    GTFS2MATSimTransitSchedule gtfsTTC =
        new GTFS2MATSimTransitSchedule(
            roots,
            config.getParam("gtfs", "modes").split(","),
            ScenarioUtils.loadScenario(config).getNetwork(),
            config.getParam("gtfs", "service").split(","),
            config.getParam("gtfs", "outCoordinateSystem"));

    ///////////////
    // RUN CONVERTER
    ///////////////
    TransitSchedule outputSchedule = gtfsTTC.getTransitSchedule();

    /////////////////
    // CREATE VEHICLES
    /////////////////

    Vehicles outputVehicles = VehicleUtils.createVehiclesContainer();
    CreateMultipleVehicleTypesForSchedule vehicleConverter =
        new CreateMultipleVehicleTypesForSchedule(outputSchedule, outputVehicles);

    String VEHICLETYPESFILE = null;
    fc = new JFileChooser();
    fc.setDialogTitle("Please select a table of vehicle types");
    fc.setFileFilter(
        new FileFilter() {
          @Override
          public String getDescription() {
            return "Table file *.txt";
          }

          @Override
          public boolean accept(File f) {
            return f.isDirectory() || f.getName().toLowerCase(Locale.ROOT).endsWith(".txt");
          }
        });
    state = fc.showOpenDialog(null);
    if (state == JFileChooser.APPROVE_OPTION) {
      VEHICLETYPESFILE = fc.getSelectedFile().getAbsolutePath();
    } else if (state == JFileChooser.CANCEL_OPTION) return;
    if (VEHICLETYPESFILE == null) return;

    vehicleConverter.ReadVehicleTypes(VEHICLETYPESFILE);

    String ROUTEVEHCILEMAPFILE = null;
    fc = new JFileChooser();
    fc.setDialogTitle("Please select a table of route vehicle mapping");
    fc.setFileFilter(
        new FileFilter() {
          @Override
          public String getDescription() {
            return "Table file *.txt";
          }

          @Override
          public boolean accept(File f) {
            return f.isDirectory() || f.getName().toLowerCase(Locale.ROOT).endsWith(".txt");
          }
        });
    state = fc.showOpenDialog(null);
    if (state == JFileChooser.APPROVE_OPTION) {
      ROUTEVEHCILEMAPFILE = fc.getSelectedFile().getAbsolutePath();
    } else if (state == JFileChooser.CANCEL_OPTION) return;
    if (ROUTEVEHCILEMAPFILE == null) return;

    vehicleConverter.ReadRouteVehicleMapping(ROUTEVEHCILEMAPFILE);

    vehicleConverter.run();

    String VEHICLEOUTPUTFILE = null;
    fc = new JFileChooser();
    fc.setDialogTitle("Save vehicles file");
    state = fc.showSaveDialog(null);
    if (state == JFileChooser.APPROVE_OPTION) {
      VEHICLEOUTPUTFILE = fc.getSelectedFile().getAbsolutePath();
    } else if (state == JFileChooser.CANCEL_OPTION) return;
    if (VEHICLEOUTPUTFILE == null) return;

    vehicleConverter.exportVehicles(VEHICLEOUTPUTFILE);

    /////////////////////////
    // EXPORT TRANSIT SCHEDULE
    /////////////////////////

    final String SCHEDULEOUTPUTNAME = config.getParam("gtfs", "outputFile");

    TransitScheduleWriterV1 writer = new TransitScheduleWriterV1(outputSchedule);
    writer.write(SCHEDULEOUTPUTNAME);
  }