예제 #1
0
  @SuppressWarnings("unchecked")
  private G randomDraw(G graph, double p, long randomSeed) {
    long n = graph.getVertices().size();
    long M = n * (n - 1) / 2;
    int m = (int) (p * M);

    Random random = new Random(randomSeed);
    List<V> vertices = new ArrayList<V>((Collection<? extends V>) graph.getVertices());
    ProgressLogger.init(m, 1, 5);
    for (int i = 0; i < m; i++) {
      E edge = null;
      while (edge == null) {
        V vi = vertices.get(random.nextInt((int) n));
        V vj = vertices.get(random.nextInt((int) n));
        edge = builder.addEdge(graph, vi, vj);
      }
      ProgressLogger.step();
      //			if(i % 10000 == 0)
      //				logger.info(String.format("Created %1$s of %2$s edges.", i+1, m));
    }
    ProgressLogger.termiante();
    return graph;
  }
예제 #2
0
  @Override
  public void apply(Collection<? extends Person> persons) {
    LandUseData landUseData = (LandUseData) dataPool.get(LandUseDataLoader.KEY);

    // ZoneLayer<Map<String, Object>> zoneLayer =
    // landUseData.getNuts3Layer();
    ZoneLayer<Map<String, Object>> zoneLayer = landUseData.getModenaLayer();
    List<Zone<Map<String, Object>>> zones = new ArrayList<>(zoneLayer.getZones());
    TObjectDoubleHashMap<Zone<?>> zoneProba = new TObjectDoubleHashMap<>();

    double sum = 0;
    for (Zone<Map<String, Object>> zone : zoneLayer.getZones()) {
      sum += (Double) zone.getAttribute().get(LandUseData.POPULATION_KEY);
    }

    for (Zone<Map<String, Object>> zone : zoneLayer.getZones()) {
      double inhabs = (Double) zone.getAttribute().get(LandUseData.POPULATION_KEY);
      double p = inhabs / sum;
      zoneProba.put(zone, p);
    }

    logger.info("Assigning facilities to zones...");

    int unassigned = 0;

    FacilityData facilityData = (FacilityData) dataPool.get(FacilityDataLoader.KEY);
    Map<Zone<?>, List<ActivityFacility>> zoneFacilities = new IdentityHashMap<>(zones.size());
    List<ActivityFacility> homeFacils = facilityData.getFacilities(ActivityTypes.HOME);
    ProgressLogger.init(homeFacils.size(), 2, 10);
    for (ActivityFacility facility : homeFacils) {
      Zone<?> zone = zoneLayer.getZone(MatsimCoordUtils.coordToPoint(facility.getCoord()));
      if (zone != null) {
        List<ActivityFacility> facilities = zoneFacilities.get(zone);
        if (facilities == null) {
          facilities = new ArrayList<>();
          zoneFacilities.put(zone, facilities);
        }
        facilities.add(facility);
      } else {
        unassigned++;
      }
      ProgressLogger.step();
    }

    if (unassigned > 0) {
      logger.warn(String.format("%s facilities are out if zone bounds.", unassigned));
    }

    logger.info("Assigning facilities to persons...");
    ProgressLogger.init(persons.size(), 2, 10);
    List<Person> shuffledPersons = new ArrayList<>(persons);
    Collections.shuffle(shuffledPersons, random);
    TObjectDoubleIterator<Zone<?>> it = zoneProba.iterator();
    int j = 0;
    for (int i = 0; i < zoneProba.size(); i++) {
      it.advance();
      int n = (int) Math.ceil(persons.size() * it.value());
      List<ActivityFacility> facilities = zoneFacilities.get(it.key());
      if (facilities != null) {
        if (n + j > persons.size()) {
          n = persons.size() - j;
        }
        for (int k = j; k < (j + n); k++) {
          ActivityFacility f = facilities.get(random.nextInt(facilities.size()));
          ((PlainPerson) shuffledPersons.get(k))
              .setUserData(SwitchHomeLocation.USER_FACILITY_KEY, f);

          ProgressLogger.step();
        }

        j += n;
      }
    }

    logger.info("Checking for homeless persons...");
    int cnt = 0;
    for (Person person : shuffledPersons) {
      if (((PlainPerson) person).getUserData(SwitchHomeLocation.USER_FACILITY_KEY) == null) {
        ActivityFacility f = homeFacils.get(random.nextInt(homeFacils.size()));
        ((PlainPerson) person).setUserData(SwitchHomeLocation.USER_FACILITY_KEY, f);
        cnt++;
      }
    }
    if (cnt > 0) {
      logger.info(String.format("Assigend %s persons a random home.", cnt));
    }

    ProgressLogger.termiante();
  }
예제 #3
0
  public static final void main(String args[]) throws IOException {
    String outdir = "/home/johannes/gsv/miv-matrix/qs2013/";
    String matrixFile = "/home/johannes/gsv/miv-matrix/qs2013/matrix.txt";
    String zoneFile = "/home/johannes/gsv/gis/zones/geojson/nuts3.psm.gk3.geojson";
    String inhabFile = "/home/johannes/gsv/miv-matrix/qs2013/inhabitants.csv";

    final NumericMatrix carVol = new NumericMatrix();
    final NumericMatrix railVol = new NumericMatrix();
    final NumericMatrix airVol = new NumericMatrix();

    logger.info("Loading zones...");
    ZoneCollection zones = ZoneGeoJsonIO.readFromGeoJSON(zoneFile, "NO");
    TObjectDoubleHashMap<String> zoneRho = calcDensity(inhabFile, zones);

    logger.info("Reading matrix...");
    MatrixReader mReader = new MatrixReader();
    mReader.read(
        matrixFile,
        new MatrixReader.RowHandler() {
          @Override
          public void handleRow(
              String from,
              String to,
              String purpose,
              String year,
              String mode,
              String direction,
              String day,
              String season,
              double volume) {
            if (mode.equalsIgnoreCase("M")) {
              carVol.add(from, to, volume);
            } else if (mode.equalsIgnoreCase("B")) {
              railVol.add(from, to, volume);
            } else if (mode.equalsIgnoreCase("F")) {
              airVol.add(from, to, volume);
            }
          }
        });

    logger.info("Calculating shares per od-pair...");
    NumericMatrix carShare = new NumericMatrix();
    NumericMatrix railShare = new NumericMatrix();
    NumericMatrix airShare = new NumericMatrix();
    NumericMatrix odCounts = new NumericMatrix();

    Discretizer discr = FixedSampleSizeDiscretizer.create(zoneRho.values(), 1, 20);
    //        Discretizer discr = new DummyDiscretizer();

    Set<String> keys = carVol.keys();
    keys.addAll(railVol.keys());
    keys.addAll(airVol.keys());

    ProgressLogger.init(keys.size(), 2, 10);

    for (String from : keys) {
      for (String to : keys) {
        Double car = carVol.get(from, to);
        if (car == null) car = 0.0;
        Double rail = railVol.get(from, to);
        if (rail == null) rail = 0.0;
        Double air = airVol.get(from, to);
        if (air == null) air = 0.0;

        if (car > 0 && rail > 0 && air > 0) {
          double total = car + rail + air;

          double fromRho = zoneRho.get(from);
          double toRho = zoneRho.get(to);

          fromRho = discr.discretize(fromRho);
          toRho = discr.discretize(toRho);

          String fromRhoStr = String.valueOf(fromRho);
          String toRhoStr = String.valueOf(toRho);
          odCounts.add(fromRhoStr, toRhoStr, 1);
          //                    odCounts.add(fromRhoStr, toRhoStr, total);

          carShare.add(fromRhoStr, toRhoStr, car / total);
          railShare.add(fromRhoStr, toRhoStr, rail / total);
          airShare.add(fromRhoStr, toRhoStr, air / total);
        }
      }
      ProgressLogger.step();
    }
    ProgressLogger.terminate();

    logger.info("Calculating averages...");
    keys = odCounts.keys();
    for (String from : keys) {
      for (String to : keys) {
        Double count = odCounts.get(from, to);
        if (count != null) {
          carShare.multiply(from, to, 1 / count);
          railShare.multiply(from, to, 1 / count);
          airShare.multiply(from, to, 1 / count);
        }
      }
    }

    logger.info("Writing matrices...");
    NumericMatrixTxtIO.write(carShare, String.format("%s/carShare.txt", outdir));
    NumericMatrixTxtIO.write(railShare, String.format("%s/railShare.txt", outdir));
    NumericMatrixTxtIO.write(airShare, String.format("%s/airShare.txt", outdir));
    logger.info("Done.");
  }
예제 #4
0
  public NumericMatrix generate(
      Network network, ZoneCollection zones, String zoneIdKey, int nThreads) {
    this.network = network;

    logger.info("Initializing node mappings...");
    initMappings(zones, zoneIdKey);

    logger.info("Calculation travel times...");
    ExecutorService executor = Executors.newFixedThreadPool(nThreads);
    Set<Future<Worker>> futures = new HashSet<>();

    for (Zone zone : zones.getZones()) {
      Worker worker = new Worker(zone.getAttribute(zoneIdKey));
      futures.add(executor.submit(worker, worker));
    }

    ProgressLogger.init(futures.size(), 1, 10);

    HashMatrix<String, CellData> sumMatrix = new HashMatrix<>();
    int errors = 0;

    for (Future<Worker> future : futures) {
      try {
        Worker worker = future.get();
        HashMatrix<String, CellData> m = worker.getMatrix();
        Set<String> keys = m.keys();

        for (String i : keys) {
          for (String j : keys) {

            CellData cData = m.get(i, j);
            if (cData != null) {

              CellData cDataSum = sumMatrix.get(i, j);
              if (cDataSum == null) {
                cDataSum = new CellData();
                sumMatrix.set(i, j, cDataSum);
              }

              cDataSum.count += cData.count;
              cDataSum.ttSum += cData.ttSum;
            }
          }
        }

        errors += worker.getErrors();

        ProgressLogger.step();
      } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
      }
    }

    ProgressLogger.terminate();

    if (errors > 0) {
      logger.info(String.format("%s errors occured.", errors));
    }

    logger.info("Collection results...");

    NumericMatrix ttMatrix = new NumericMatrix();
    Set<String> keys = sumMatrix.keys();
    for (String i : keys) {
      for (String j : keys) {
        CellData cData = sumMatrix.get(i, j);
        double avr = cData.ttSum / cData.count;
        ttMatrix.set(i, j, avr);
      }
    }

    return ttMatrix;
  }