public static void readWorkplaces(Scenario scenario, String file) {
BufferedReader reader = IOUtils.getBufferedReader(file);
final int idxX = 0;
final int idxY = 1;
int counter = 0;
try {
String line = reader.readLine();
while ((line = reader.readLine()) != null) {
String[] parts = line.split(",");
Coord coord =
Global.ct.transform(
new Coord(Double.parseDouble(parts[idxX]), Double.parseDouble(parts[idxY])));
ActivityFacility facility =
scenario
.getActivityFacilities()
.getFactory()
.createActivityFacility(
Id.create(Global.ActType.work.name() + "_" + counter, ActivityFacility.class),
coord);
ActivityOption work =
scenario
.getActivityFacilities()
.getFactory()
.createActivityOption(Global.ActType.work.name());
facility.addActivityOption(work);
scenario.getActivityFacilities().addActivityFacility(facility);
GAPScenarioBuilder.getWorkLocations()
.put(facility.getCoord().getX(), facility.getCoord().getY(), facility);
counter++;
}
} catch (IOException e) {
e.printStackTrace();
}
}
// Create external Facilities that are used by transit traffic agents.
private static void createExternalFacilities(Scenario scenario, Set<Id<Node>> externalNodes) {
ActivityFacilities activityFacilities = scenario.getActivityFacilities();
ActivityFacilitiesFactory factory = activityFacilities.getFactory();
/*
* We check for all OutLinks of all external nodes if they already host a facility. If not,
* a new facility with a tta ActivityOption will be created and added.
*/
for (Id<Node> id : externalNodes) {
Node externalNode = scenario.getNetwork().getNodes().get(id);
for (Link externalLink : externalNode.getOutLinks().values()) {
ActivityFacility facility = activityFacilities.getFacilities().get(externalLink.getId());
// if already a facility exists we have nothing left to do
if (facility != null) continue;
/*
* No Facility exists at that link therefore we create and add a new one.
*/
double fromX = externalLink.getFromNode().getCoord().getX();
double fromY = externalLink.getFromNode().getCoord().getY();
double toX = externalLink.getToNode().getCoord().getX();
double toY = externalLink.getToNode().getCoord().getY();
double dX = toX - fromX;
double dY = toY - fromY;
double length = Math.sqrt(Math.pow(dX, 2) + Math.pow(dY, 2));
double centerX = externalLink.getCoord().getX();
double centerY = externalLink.getCoord().getY();
/*
* Unit vector that directs with an angle of 90° away from the link.
*/
double unitVectorX = dY / length;
double unitVectorY = -dX / length;
Coord coord = new Coord(centerX + unitVectorX, centerY + unitVectorY);
facility =
activityFacilities
.getFactory()
.createActivityFacility(
Id.create(externalLink.getId().toString(), ActivityFacility.class), coord);
activityFacilities.addActivityFacility(facility);
((ActivityFacilityImpl) facility).setLinkId(externalLink.getId());
ActivityOption activityOption = factory.createActivityOption(ttaActivityType);
activityOption.addOpeningTime(new OpeningTimeImpl(0 * 3600, 24 * 3600));
activityOption.setCapacity(capacity);
facility.addActivityOption(activityOption);
}
}
}
/** test, that the number of created facilities corresponds to what is expected. */
public void testGenerateParkingFacilities() {
String inputPlansFile = getPackageInputDirectory() + "plans2.xml";
String networkFile = "test/scenarios/berlin/network.xml.gz";
Scenario scenario = ScenarioUtils.createScenario(super.loadConfig(null));
new MatsimNetworkReader(scenario.getNetwork()).readFile(networkFile);
new MatsimPopulationReader(scenario).readFile(inputPlansFile);
GenerateParkingFacilities.generateParkingFacilties(scenario);
ActivityFacilities facilities = scenario.getActivityFacilities();
assertEquals(4, facilities.getFacilities().size());
}
// Create Facilities inside the simulated area.
private static void createInternalFacilities(
Scenario scenario,
Map<Integer, Emme2Zone> zonalAttributes,
Map<Integer, SimpleFeature> zonalShapes) {
// create indices for the zones
Map<Integer, Integer> indices = new HashMap<Integer, Integer>();
int index = 0;
for (Integer taz : zonalShapes.keySet()) {
indices.put(taz, index);
index++;
}
NetworkImpl network = (NetworkImpl) scenario.getNetwork();
ActivityFacilities activityFacilities = scenario.getActivityFacilities();
ObjectAttributes facilitiesAttributes = activityFacilities.getFacilityAttributes();
ActivityFacilitiesFactory factory = activityFacilities.getFactory();
for (Entry<Integer, SimpleFeature> entry : zonalShapes.entrySet()) {
int taz = entry.getKey();
SimpleFeature feature = entry.getValue();
Geometry geometry = (Geometry) feature.getDefaultGeometry();
List<Coord> coordinates = getRandomCoordinatesInZone(facilitiesPerZone, geometry, random);
int i = 0;
for (Coord coord : coordinates) {
Id<ActivityFacility> id = Id.create(taz + "_" + i, ActivityFacility.class);
ActivityFacility facility = factory.createActivityFacility(id, coord);
createAndAddActivityOptions(scenario, facility, zonalAttributes.get(taz));
activityFacilities.addActivityFacility(facility);
Link link = network.getNearestLinkExactly(coord);
((ActivityFacilityImpl) facility).setLinkId(link.getId());
i++;
// Also add a tta activity to all facilities.
ActivityOption activityOption = factory.createActivityOption(ttaActivityType);
activityOption.addOpeningTime(new OpeningTimeImpl(0 * 3600, 24 * 3600));
activityOption.setCapacity(capacity);
facility.addActivityOption(activityOption);
facilitiesAttributes.putAttribute(id.toString(), TAZObjectAttributesName, taz);
facilitiesAttributes.putAttribute(
id.toString(), indexObjectAttributesName, indices.get(taz));
}
}
}
// create f2l mapping file
private static void createAndWriteF2LMapping(Scenario scenario) {
log.info("creating f2l mapping and write it to a file ...");
try {
BufferedWriter bw = IOUtils.getBufferedWriter(basePath + f2lFile);
// write Header
bw.write("fid" + "\t" + "lid" + "\n");
for (ActivityFacility facility : scenario.getActivityFacilities().getFacilities().values()) {
bw.write(facility.getId().toString() + "\t" + facility.getLinkId().toString() + "\n");
}
bw.flush();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
log.info("done.");
}
public static void main(final String[] args) {
final String pathToFolder = args[0];
final String pathToTargetFolder = args[1];
final double xCoordCenter = Double.parseDouble(args[2]);
final double yCoordCenter = Double.parseDouble(args[3]);
final int radius = Integer.parseInt(args[4]);
// For 30km around Zurich Center (Bellevue): X - 2683518.0, Y - 1246836.0, radius - 30000
// load files
Scenario scenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
new PopulationReaderMatsimV5(scenario).readFile(pathToFolder + POPULATION);
ObjectAttributes personAttributes = new ObjectAttributes();
new ObjectAttributesXmlReader(personAttributes).parse(pathToFolder + POPULATION_ATTRIBUTES);
Households origHouseholds = new HouseholdsImpl();
new HouseholdsReaderV10(origHouseholds).readFile(pathToFolder + HOUSEHOLDS);
ObjectAttributes householdAttributes = new ObjectAttributes();
new ObjectAttributesXmlReader(householdAttributes).parse(pathToFolder + HOUSEHOLD_ATTRIBUTES);
new FacilitiesReaderMatsimV1(scenario).readFile(pathToFolder + FACILITIES);
// cut to area
ZHCutter cutter = new ZHCutter();
cutter.setArea(new Coord(xCoordCenter, yCoordCenter), radius);
Population filteredPopulation =
cutter.geographicallyFilterPopulation(scenario.getPopulation(), personAttributes);
Households filteredHouseholds =
cutter.filterHouseholdsWithPopulation(origHouseholds, householdAttributes);
ActivityFacilities filteredFacilities =
cutter.filterFacilitiesWithPopulation(scenario.getActivityFacilities());
// write new files
new PopulationWriter(filteredPopulation).write(pathToTargetFolder + POPULATION);
new ObjectAttributesXmlWriter(personAttributes)
.writeFile(pathToTargetFolder + POPULATION_ATTRIBUTES);
new HouseholdsWriterV10(filteredHouseholds).writeFile(pathToTargetFolder + HOUSEHOLDS);
new ObjectAttributesXmlWriter(householdAttributes)
.writeFile(pathToTargetFolder + HOUSEHOLD_ATTRIBUTES);
new FacilitiesWriter(filteredFacilities).writeV1(pathToTargetFolder + FACILITIES);
}
public PopulationReaderMatsimV4(final Scenario scenario) {
this.scenario = scenario;
this.plans = scenario.getPopulation();
this.network = scenario.getNetwork();
this.facilities = scenario.getActivityFacilities();
}
/**
* @param args
* @throws FactoryException
*/
public static void main(String[] args) throws FactoryException {
String popFile = args[0];
String facFile = args[1];
String netFile = args[2];
int n = Integer.parseInt(args[3]);
String outDir = args[4];
Logger logger = Logger.getLogger(DemoScenario.class);
MathTransform transform = CRS.findMathTransform(CRSUtils.getCRS(31467), CRSUtils.getCRS(3857));
Config config = ConfigUtils.createConfig();
Scenario scenario = ScenarioUtils.createScenario(config);
/*
* remove foreign persons and extract subsample
*/
logger.info("Loading persons...");
MatsimPopulationReader pReader = new MatsimPopulationReader(scenario);
pReader.readFile(popFile);
logger.info("Done.");
logger.info("Removing foreign persons...");
Set<Id<Person>> remove = new HashSet<>();
for (Id<Person> id : scenario.getPopulation().getPersons().keySet()) {
if (id.toString().startsWith("foreign")) {
remove.add(id);
}
}
int cnt = 0;
for (Id<Person> id : remove) {
if (scenario.getPopulation().getPersons().remove(id) != null) {
cnt++;
}
}
logger.info(String.format("Done. Removed %s foreign persons.", cnt));
logger.info("Drawing population subsample...");
List<Person> persons = new ArrayList<>(scenario.getPopulation().getPersons().values());
Collections.shuffle(persons);
Population population = PopulationUtils.createPopulation(config);
cnt = 0;
for (int i = 0; i < n; i++) {
population.addPerson(persons.get(i));
}
logger.info("Done.");
logger.info("Bluring activity end times...");
Random random = new XORShiftRandom();
for (Person person : population.getPersons().values()) {
for (Plan plan : person.getPlans()) {
for (int i = 0; i < plan.getPlanElements().size(); i += 2) {
Activity act = (Activity) plan.getPlanElements().get(i);
double endTim = act.getEndTime() - 15 * 60 + (random.nextDouble() * 30 * 60);
act.setEndTime(endTim);
double startTim = act.getStartTime() - 15 * 60 + (random.nextDouble() * 30 * 60);
act.setStartTime(startTim);
}
}
}
logger.info("Done.");
logger.info("Writing population...");
PopulationWriter pWriter = new PopulationWriter(population);
pWriter.write(String.format("%s/plans.xml.gz", outDir));
logger.info("Done.");
/*
* filter only used facilities
*/
logger.info("Loading facilities...");
MatsimFacilitiesReader fReader = new MatsimFacilitiesReader(scenario);
fReader.readFile(facFile);
logger.info("Done.");
logger.info("Removing unsused facilities...");
Set<Id<ActivityFacility>> unused =
new HashSet<>(scenario.getActivityFacilities().getFacilities().keySet());
for (Person person : population.getPersons().values()) {
for (Plan plan : person.getPlans()) {
for (int i = 0; i < plan.getPlanElements().size(); i += 2) {
Activity act = (Activity) plan.getPlanElements().get(i);
unused.remove(act.getFacilityId());
}
}
}
logger.info("Done.");
logger.info("Transforming facility coordinates...");
for (ActivityFacility fac : scenario.getActivityFacilities().getFacilities().values()) {
double[] points = new double[] {fac.getCoord().getX(), fac.getCoord().getY()};
try {
transform.transform(points, 0, points, 0, 1);
} catch (TransformException e) {
e.printStackTrace();
}
((ActivityFacilityImpl) fac).setCoord(new Coord(points[0], points[1]));
}
logger.info("Done.");
logger.info("Writing facilities...");
FacilitiesWriter fWrtier = new FacilitiesWriter(scenario.getActivityFacilities());
fWrtier.write(String.format("%s/facilities.xml.gz", outDir));
logger.info("Done.");
/*
* clean network from foreign links
*/
logger.info("Loading network...");
MatsimNetworkReader nReader = new MatsimNetworkReader(scenario);
nReader.readFile(netFile);
logger.info("Done.");
logger.info("Removing foreign links...");
Set<Id<Link>> linksRemove = new HashSet<>();
for (Id<Link> id : scenario.getNetwork().getLinks().keySet()) {
if (id.toString().contains(".l")) {
linksRemove.add(id);
}
}
for (Id<Link> id : linksRemove) {
scenario.getNetwork().removeLink(id);
}
logger.info("Done.");
logger.info("Removing foreign nodes...");
Set<Id<Node>> nodesRemove = new HashSet<>();
for (Id<Node> id : scenario.getNetwork().getNodes().keySet()) {
if (id.toString().contains(".n")) {
nodesRemove.add(id);
}
}
for (Id<Node> id : nodesRemove) {
scenario.getNetwork().removeNode(id);
}
logger.info("Done.");
logger.info("Transforming node coordinates...");
for (Node node : scenario.getNetwork().getNodes().values()) {
double[] points = new double[] {node.getCoord().getX(), node.getCoord().getY()};
try {
transform.transform(points, 0, points, 0, 1);
} catch (TransformException e) {
e.printStackTrace();
}
((NodeImpl) node).setCoord(new Coord(points[0], points[1]));
}
logger.info("Done.");
logger.info("Writing network...");
NetworkWriter nWriter = new NetworkWriter(scenario.getNetwork());
nWriter.write(String.format("%s/network.xml.gz", outDir));
logger.info("Done.");
}
public static void main(String[] args) {
// Input and output
String networkFile =
"../../matsimExamples/countries/za/nmbm/network/NMBM_Network_CleanV7.xml.gz";
String facilitiesFile =
"../../matsimExamples/countries/za/nmbm/facilities/20121010/facilities.xml.gz";
String outputDirectory = "../../accessibility-sa/data/12/";
// String travelTimeMatrix = folderStructure +
// "matsimExamples/countries/za/nmbm/minibus-pt/JTLU_14i_06/travelTimeMatrix.csv.gz";
// String travelDistanceMatrix = folderStructure +
// "matsimExamples/countries/za/nmbm/minibus-pt/JTLU_14i_06/travelDistanceMatrix.csv.gz";
// String ptStops = folderStructure +
// "matsimExamples/countries/za/nmbm/minibus-pt/JTLU_14i_06/measuringPointsAsStops.csv.gz";
// String minibusPtTravelTimeMatrix = folderStructure +
// "matsimExamples/countries/za/nmbm/minibus-pt/JTLU_14i_07/travelTimeMatrix.csv";
// String minibusPtTravelDistanceMatrix = folderStructure +
// "matsimExamples/countries/za/nmbm/minibus-pt/JTLU_14i_07/travelDistanceMatrix.csv";
// String measuringPointsAsPtStops = folderStructure +
// "matsimExamples/countries/za/nmbm/minibus-pt/JTLU_14i_07/measuringPointsAsStops.csv";
// Parameters
boolean includeDensityLayer = true;
String crs = TransformationFactory.WGS84_SA_Albers;
Double lowerBound = 2.;
Double upperBound = 5.5;
Integer range = 9;
int symbolSize = 1010;
int populationThreshold = (int) (200 / (1000 / cellSize * 1000 / cellSize));
final Config config = ConfigUtils.createConfig(new AccessibilityConfigGroup());
config.controler().setOverwriteFileSetting(OverwriteFileSetting.deleteDirectoryIfExists);
config.controler().setOutputDirectory(outputDirectory);
config.network().setInputFile(networkFile);
config.facilities().setInputFile(facilitiesFile);
config.controler().setLastIteration(0);
final Scenario scenario = ScenarioUtils.loadScenario(config);
String typeWEQ = "w-eq";
List<String> activityTypes = new ArrayList<>();
activityTypes.add(typeWEQ);
final ActivityFacilities homes = FacilitiesUtils.createActivityFacilities("homes");
final ActivityFacilities amenities = FacilitiesUtils.createActivityFacilities("amenities");
for (ActivityFacility fac : scenario.getActivityFacilities().getFacilities().values()) {
for (ActivityOption option : fac.getActivityOptions().values()) {
// figure out all activity types
if (!activityTypes.contains(option.getType())) {
activityTypes.add(option.getType());
}
// add all facilites that are not home or work
if (!option.getType().equals("h")
&& !option.getType().equals("w")
&& !option.getType().equals("minor")) {
if (!amenities.getFacilities().containsKey(fac.getId())) {
amenities.addActivityFacility(fac);
}
}
// figure out where the homes are
if (option.getType().equals("h")) {
homes.addActivityFacility(fac);
}
}
}
// extends of the network are (as they can looked up by using the bounding box):
// minX = 111083.9441831379, maxX = 171098.03695045778, minY = -3715412.097693177, maxY =
// -3668275.43481496
// double[] mapViewExtent = {100000,-3720000,180000,-3675000}; // choose map view a bit bigger
double[] mapViewExtent = {
115000, -3718000, 161000, -3679000
}; // what actually needs to be drawn
Controler controler = new Controler(scenario);
controler.addOverridingModule(
new AbstractModule() {
@Override
public void install() {
addControlerListenerBinding()
.toProvider(
new Provider<ControlerListener>() {
@Inject Scenario scenario;
@Inject Map<String, TravelTime> travelTimes;
@Inject Map<String, TravelDisutilityFactory> travelDisutilityFactories;
@Override
public ControlerListener get() {
GridBasedAccessibilityControlerListenerV3 listener =
new GridBasedAccessibilityControlerListenerV3(
amenities,
null,
config,
scenario,
travelTimes,
travelDisutilityFactories);
listener.setComputingAccessibilityForMode(
Modes4Accessibility.freeSpeed, true);
listener.addAdditionalFacilityData(homes);
listener.generateGridsAndMeasuringPointsByNetwork(cellSize);
listener.writeToSubdirectoryWithName("w-eq");
listener.setUrbansimMode(
false); // avoid writing some (eventually: all) files that related to
// matsim4urbansim
return listener;
}
});
}
});
controler.run();
String workingDirectory = config.controler().getOutputDirectory();
String osName = System.getProperty("os.name");
// for (String actType : activityTypes) {
String actSpecificWorkingDirectory = workingDirectory + typeWEQ + "/";
for (Modes4Accessibility mode : Modes4Accessibility.values()) {
// VisualizationUtilsDZ.createQGisOutput(typeWEQ, mode, mapViewExtent, workingDirectory,
// crs, includeDensityLayer);
VisualizationUtilsDZ.createQGisOutput(
typeWEQ,
mode,
mapViewExtent,
workingDirectory,
crs,
includeDensityLayer,
lowerBound,
upperBound,
range,
symbolSize,
populationThreshold);
VisualizationUtilsDZ.createSnapshot(actSpecificWorkingDirectory, mode, osName);
}
// }
}
/**
* Parses a given osm file in order to extract the amenities defined in it. Amenities are needed
* to create activity facilities for activity types
*
* <ul>
* <li>tourism (splitted into tourism1 (tourist's 'home') and tourism2 (attractions)
* <li>education
* <li>shop
* </ul>
*
* @param scenario
*/
public static void initAmenities(Scenario scenario) {
Map<String, String> osmToMatsimTypeMap = new HashMap<>();
osmToMatsimTypeMap.put("alpine_hut", "tourism1");
osmToMatsimTypeMap.put("apartment", "tourism1");
osmToMatsimTypeMap.put("attraction", "tourism2");
osmToMatsimTypeMap.put("artwork", "tourism2");
osmToMatsimTypeMap.put("camp_site", "tourism1");
osmToMatsimTypeMap.put("caravan_site", "tourism1");
osmToMatsimTypeMap.put("chalet", "tourism1");
osmToMatsimTypeMap.put("gallery", "tourism2");
osmToMatsimTypeMap.put("guest_house", "tourism1");
osmToMatsimTypeMap.put("hostel", "tourism1");
osmToMatsimTypeMap.put("hotel", "tourism1");
osmToMatsimTypeMap.put("information", "tourism2");
osmToMatsimTypeMap.put("motel", "tourism1");
osmToMatsimTypeMap.put("museum", "tourism2");
osmToMatsimTypeMap.put("picnic_site", "tourism2");
osmToMatsimTypeMap.put("theme_park", "tourism2");
osmToMatsimTypeMap.put("viewpoint", "tourism2");
osmToMatsimTypeMap.put("wilderness_hut", "tourism1");
osmToMatsimTypeMap.put("zoo", "tourism2");
// education
osmToMatsimTypeMap.put("college", "education");
osmToMatsimTypeMap.put("kindergarten", "education");
osmToMatsimTypeMap.put("school", "education");
osmToMatsimTypeMap.put("university", "education");
// leisure
osmToMatsimTypeMap.put("arts_centre", "leisure");
osmToMatsimTypeMap.put("cinema", "leisure");
osmToMatsimTypeMap.put("community_centre", "leisure");
osmToMatsimTypeMap.put("fountain", "leisure");
osmToMatsimTypeMap.put("nightclub", "leisure");
osmToMatsimTypeMap.put("planetarium", "leisure");
osmToMatsimTypeMap.put("social_centre", "leisure");
osmToMatsimTypeMap.put("theatre", "leisure");
// shopping
osmToMatsimTypeMap.put("alcohol", "shop");
osmToMatsimTypeMap.put("bakery", "shop");
osmToMatsimTypeMap.put("beverages", "shop");
osmToMatsimTypeMap.put("butcher", "shop");
osmToMatsimTypeMap.put("cheese", "shop");
osmToMatsimTypeMap.put("chocolate", "shop");
osmToMatsimTypeMap.put("coffee", "shop");
osmToMatsimTypeMap.put("confectionery", "shop");
osmToMatsimTypeMap.put("convenience", "shop");
osmToMatsimTypeMap.put("deli", "shop");
osmToMatsimTypeMap.put("dairy", "shop");
osmToMatsimTypeMap.put("farm", "shop");
osmToMatsimTypeMap.put("greengrocer", "shop");
osmToMatsimTypeMap.put("pasta", "shop");
osmToMatsimTypeMap.put("pastry", "shop");
osmToMatsimTypeMap.put("seafood", "shop");
osmToMatsimTypeMap.put("tea", "shop");
osmToMatsimTypeMap.put("wine", "shop");
osmToMatsimTypeMap.put("department_store", "shop");
osmToMatsimTypeMap.put("general", "shop");
osmToMatsimTypeMap.put("kiosk", "shop");
osmToMatsimTypeMap.put("mall", "shop");
osmToMatsimTypeMap.put("supermarket", "shop");
osmToMatsimTypeMap.put("baby_goods", "shop");
osmToMatsimTypeMap.put("bag", "shop");
osmToMatsimTypeMap.put("boutique", "shop");
osmToMatsimTypeMap.put("clothes", "shop");
osmToMatsimTypeMap.put("fabric", "shop");
osmToMatsimTypeMap.put("fashion", "shop");
osmToMatsimTypeMap.put("jewelry", "shop");
osmToMatsimTypeMap.put("leather", "shop");
osmToMatsimTypeMap.put("shoes", "shop");
osmToMatsimTypeMap.put("tailor", "shop");
osmToMatsimTypeMap.put("watches", "shop");
// TODO many more types of amenities to come...
Set<String> keys = new HashSet<>();
keys.add("tourism");
keys.add("amenity");
keys.add("shop");
OsmObjectsToFacilitiesParser reader =
new OsmObjectsToFacilitiesParser(
Global.dataDir + "/Netzwerk/garmisch-latest.osm", Global.ct, osmToMatsimTypeMap, keys);
reader.parse();
// reader.writeFacilities(Global.matsimInputDir + "facilities/facilities.xml");
// reader.writeFacilityAttributes(Global.matsimInputDir + "facilities/facilityAttribues.xml");
reader.writeFacilityCoordinates(Global.matsimInputDir + "facilities.csv");
for (ActivityFacility facility : reader.getFacilities().getFacilities().values()) {
scenario.getActivityFacilities().addActivityFacility(facility);
}
}
/*
* Creates and adds the possible activities to the facility. The capacities
* have to defined elsewhere...
*
* home / no (Activity) / 0 .. 24
* work / work / 8 .. 18
* education / study / 8 .. 18
* shopping / shopping / 9 .. 19
* leisure / other 6 .. 22
*
* Mapping from the zones file:
*
* Cultural Areas -> leisure, work
* Education -> education_university, education_highschool, education_elementaryschool, work
* Office -> work
* Shopping -> leisure, work
* Health Institutions -> work, leisure
* Urban Cores -> ignore
* Religions Character -> ignore
* Transportation -> work, leisure (airport, big train stations, etc.)
*/
private static void createAndAddActivityOptions(
Scenario scenario, ActivityFacility facility, Emme2Zone zone) {
boolean hasHome = false;
boolean hasWork = false;
boolean hasEducationUniversity = false;
boolean hasEducationHighSchool = false;
boolean hasEducationElementarySchool = false;
boolean hasShopping = false;
boolean hasLeisure = false;
hasHome = zone.hasHome();
hasWork = zone.hasWork();
hasEducationUniversity = zone.hasEducationUniversity();
hasEducationHighSchool = zone.hasEducationHighSchool();
hasEducationElementarySchool = zone.hasEducationElementarySchool();
hasShopping = zone.hasShopping();
hasLeisure = zone.hasLeisure();
// if (zone.POPULATION > 0) { hasHome = true; }
// if (zone.CULTURAL > 0) { hasLeisure = true; hasWork = true; }
// if (zone.EDUCATION == 1) { hasEducationUniversity = true; hasWork = true; }
// if (zone.EDUCATION == 2) { hasEducationHighSchool = true; hasWork = true; }
// if (zone.EDUCATION == 3) { hasEducationElementarySchool = true; hasWork = true; }
// if (zone.OFFICE > 0) { hasWork = true; }
// if (zone.SHOPPING > 0) { hasShopping = true; hasWork = true; }
// if (zone.HEALTH > 0) { hasLeisure = true; hasWork = true; }
// if (zone.TRANSPORTA > 0) { hasLeisure = true; hasWork = true; }
// if (zone.EMPL_TOT > 0) { hasWork = true; }
// "Other" activities - should be possible in every zone.
// hasLeisure = true;
// "Shopping" activities - should be possible in every zone.
// hasShopping = true;
ActivityOption activityOption;
ActivityFacilitiesFactory factory = scenario.getActivityFacilities().getFactory();
if (hasHome) {
activityOption = factory.createActivityOption("home");
facility.addActivityOption(activityOption);
activityOption.addOpeningTime(new OpeningTimeImpl(0 * 3600, 24 * 3600));
activityOption.setCapacity(capacity);
}
if (hasWork) {
activityOption = factory.createActivityOption("work");
facility.addActivityOption(activityOption);
activityOption.addOpeningTime(new OpeningTimeImpl(8 * 3600, 18 * 3600));
activityOption.setCapacity(capacity);
}
if (hasEducationUniversity) {
activityOption = factory.createActivityOption("education_university");
facility.addActivityOption(activityOption);
activityOption.addOpeningTime(new OpeningTimeImpl(9 * 3600, 18 * 3600));
activityOption.setCapacity(capacity);
}
if (hasEducationHighSchool) {
activityOption = factory.createActivityOption("education_highschool");
facility.addActivityOption(activityOption);
activityOption.addOpeningTime(new OpeningTimeImpl(8 * 3600, 16 * 3600));
activityOption.setCapacity(capacity);
}
if (hasEducationElementarySchool) {
activityOption = factory.createActivityOption("education_elementaryschool");
facility.addActivityOption(activityOption);
activityOption.addOpeningTime(new OpeningTimeImpl(8 * 3600, 14 * 3600));
activityOption.setCapacity(capacity);
}
if (hasShopping) {
activityOption = factory.createActivityOption("shopping");
facility.addActivityOption(activityOption);
activityOption.addOpeningTime(new OpeningTimeImpl(9 * 3600, 19 * 3600));
activityOption.setCapacity(capacity);
}
if (hasLeisure) {
activityOption = factory.createActivityOption("leisure");
facility.addActivityOption(activityOption);
activityOption.addOpeningTime(new OpeningTimeImpl(6 * 3600, 22 * 3600));
activityOption.setCapacity(capacity);
}
}
public static void main(String[] args) {
try {
if (args.length > 0) {
String file = args[0];
Map<String, String> parameterMap = new XMLParameterParser().parseFile(file);
String value;
value = parameterMap.remove("basePath");
if (value != null) basePath = value;
value = parameterMap.remove("networkFile");
if (value != null) networkFile = value;
value = parameterMap.remove("zonalAttributesFile");
if (value != null) zonalAttributesFile = value;
value = parameterMap.remove("separator");
if (value != null) separator = value;
value = parameterMap.remove("zonalSHPFile");
if (value != null) zonalSHPFile = value;
value = parameterMap.remove("facilitiesFile");
if (value != null) facilitiesFile = value;
value = parameterMap.remove("facilitiesAttributesFile");
if (value != null) facilitiesAttributesFile = value;
value = parameterMap.remove("f2lFile");
if (value != null) f2lFile = value;
value = parameterMap.remove("facilitiesPerZone");
if (value != null) facilitiesPerZone = Integer.parseInt(value);
value = parameterMap.remove("validLinkTypes");
if (value != null) validLinkTypes = CollectionUtils.stringToSet(value);
for (String key : parameterMap.keySet())
log.warn("Found parameter " + key + " which is not handled!");
} else {
log.error("No input config file was given. Therefore cannot proceed. Aborting!");
return;
}
log.info("loading network ...");
Config config = ConfigUtils.createConfig();
config.network().setInputFile(basePath + networkFile);
Scenario scenario = ScenarioUtils.loadScenario(config);
log.info("done.\n");
log.info("loading zonal attributes ...");
boolean skipHeader = true;
Map<Integer, Emme2Zone> zonalAttributes =
new Emme2ZonesFileParser(basePath + zonalAttributesFile, separator).readFile(skipHeader);
log.info("done.\n");
log.info("loading zonal shp file ...");
// use a TreeMap to be deterministic
Map<Integer, SimpleFeature> zonalShapes = new TreeMap<Integer, SimpleFeature>();
for (SimpleFeature feature : ShapeFileReader.getAllFeatures(basePath + zonalSHPFile)) {
zonalShapes.put((Integer) feature.getAttribute(3), feature);
}
log.info("done.\n");
log.info("identify nodes outside the model area ...");
Set<Id<Node>> externalNodes = getExternalNodes(scenario, zonalShapes);
log.info("\tfound " + externalNodes.size() + " nodes outside the mapped area");
log.info("done.\n");
/*
* We have to create tta activities BEFORE filtering the network. They might also start
* and end at highways. We do not know their real start and end positions. The coordinate
* we know might only be the place where the agents enter the modeled area, which will
* probably be by using a highway.
*/
log.info("creating external facilities for tta activities ...");
createExternalFacilities(scenario, externalNodes);
log.info("done.\n");
/*
* Before creating the internal facilities, we can perform the links filtering.
*/
log.info("removing links from network where no facilities should be attached to ...");
List<Id<Link>> linksToRemove = new ArrayList<Id<Link>>();
for (Link link : scenario.getNetwork().getLinks().values()) {
String type = ((LinkImpl) link).getType();
if (!validLinkTypes.contains(type)) linksToRemove.add(link.getId());
}
log.info("\tfound " + linksToRemove.size() + " links which do not match the criteria");
for (Id<Link> linkId : linksToRemove)
((NetworkImpl) scenario.getNetwork()).removeLink(linkId);
log.info(
"\tprocessed network contains "
+ scenario.getNetwork().getLinks().size()
+ " valid links");
log.info("done.\n");
log.info("creating internal facilities ...");
createInternalFacilities(scenario, zonalAttributes, zonalShapes);
log.info("done.\n");
log.info("writing facilities to links mapping to a file ...");
createAndWriteF2LMapping(scenario);
log.info("done.\n");
log.info(
"writing "
+ scenario.getActivityFacilities().getFacilities().size()
+ " facilities to a file ...");
FacilitiesWriter facilitiesWriter = new FacilitiesWriter(scenario.getActivityFacilities());
facilitiesWriter.write(basePath + facilitiesFile);
new ObjectAttributesXmlWriter(scenario.getActivityFacilities().getFacilityAttributes())
.writeFile(basePath + facilitiesAttributesFile);
log.info("done.\n");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public ActivityFacilities getActivityFacilities() {
return delegate.getActivityFacilities();
}
public class AssignShopAndLeisure {
private final Scenario scenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
private final Population plans = scenario.getPopulation();
private final ActivityFacilities facilities = scenario.getActivityFacilities();
private final Network network = scenario.getNetwork();
private String plansfilePath;
private String facilitiesfilePath;
private String networkfilePath;
private final String outpath = "output/plans/";
private static final Logger log = Logger.getLogger(AssignShopAndLeisure.class);
public static void main(final String[] args) {
Gbl.startMeasurement();
final AssignShopAndLeisure assigner = new AssignShopAndLeisure();
assigner.run(args[0]);
Gbl.printElapsedTime();
}
public void run(String variant) {
this.init();
if (variant.equals("0")) {
ActivityDifferentiationShop differentiator = new ActivityDifferentiationShop(this.scenario);
differentiator.run();
}
// handle leisure
// ...
this.writePlans(variant);
}
private void readInputFile(final String inputFile) {
try {
FileReader fileReader = new FileReader(inputFile);
BufferedReader bufferedReader = new BufferedReader(fileReader);
this.networkfilePath = bufferedReader.readLine();
this.facilitiesfilePath = bufferedReader.readLine();
this.plansfilePath = bufferedReader.readLine();
bufferedReader.close();
fileReader.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private void init() {
String pathsFile = "./input/trb/valid/paths.txt";
this.readInputFile(pathsFile);
log.info("reading the facilities ...");
new FacilitiesReaderMatsimV1(this.scenario).readFile(facilitiesfilePath);
log.info("reading the network ...");
new MatsimNetworkReader(this.scenario.getNetwork()).readFile(networkfilePath);
log.info(" reading file " + plansfilePath);
final PopulationReader plansReader = new MatsimPopulationReader(this.scenario);
plansReader.readFile(plansfilePath);
}
private void writePlans(String variant) {
if (variant.equals("0")) {
new PopulationWriter(this.plans, this.network).write(this.outpath + "plans0.xml.gz");
} else {
new PopulationWriter(this.plans, this.network).write(this.outpath + "plans1.xml.gz");
}
}
}