From 600e6e17878aa1c2def883107360caa0c7787b2a Mon Sep 17 00:00:00 2001 From: Nico Date: Thu, 31 Oct 2019 16:02:41 +0100 Subject: [PATCH 01/24] noise feedback initial commit --- extensions/matsim2silo/pom.xml | 13 ++++++++--- .../msm/matsim/NoiseScenarioAssembler.java | 23 +++++++++++++++++++ extensions/pom.xml | 1 - siloCore/pom.xml | 2 +- 4 files changed, 34 insertions(+), 5 deletions(-) create mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java diff --git a/extensions/matsim2silo/pom.xml b/extensions/matsim2silo/pom.xml index 16163c81a..e86182287 100644 --- a/extensions/matsim2silo/pom.xml +++ b/extensions/matsim2silo/pom.xml @@ -8,8 +8,15 @@ 0.1.0-SNAPSHOT 4.0.0 - matsim2silo - - + + + org.matsim.contrib + noise + ${matsimVersion} + + + + 12.0-SNAPSHOT + \ No newline at end of file diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java new file mode 100644 index 000000000..33538533c --- /dev/null +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java @@ -0,0 +1,23 @@ +package de.tum.bgu.msm.matsim; + +import de.tum.bgu.msm.container.DataContainer; +import de.tum.bgu.msm.properties.Properties; +import org.matsim.api.core.v01.Scenario; +import org.matsim.core.config.Config; + +public class NoiseScenarioAssembler implements MatsimScenarioAssembler { + + private final SimpleMatsimScenarioAssembler delegate; + private final DataContainer dataContainer; + + public NoiseScenarioAssembler(DataContainer dataContainer, Properties properties) { + this.dataContainer = dataContainer; + this.delegate = new SimpleMatsimScenarioAssembler(dataContainer, properties); + this.noiseReceiverPoints = new NoiseReceiverPoints(); + } + + @Override + public Scenario assembleScenario(Config initialMatsimConfig, int year) { + return null; + } +} diff --git a/extensions/pom.xml b/extensions/pom.xml index fcd3b7fb0..9ff57f608 100644 --- a/extensions/pom.xml +++ b/extensions/pom.xml @@ -219,7 +219,6 @@ UTF-8 false 2.9.5 - 11.0 diff --git a/siloCore/pom.xml b/siloCore/pom.xml index 4be054f23..367fd47f3 100644 --- a/siloCore/pom.xml +++ b/siloCore/pom.xml @@ -406,7 +406,7 @@ ${buildNumber} false - 11.0 + 12.0-SNAPSHOT 1.8 1.8 1.8 From b410c5e830b73659d33b6d9a2c315986807335dd Mon Sep 17 00:00:00 2001 From: Nico Date: Thu, 31 Oct 2019 19:03:16 +0100 Subject: [PATCH 02/24] updates on noise feedback --- .../de/tum/bgu/msm/matsim/MatsimData.java | 3 +- .../msm/matsim/NoiseScenarioAssembler.java | 23 -- .../msm/matsim/noise/NoiseDataContainer.java | 8 + .../msm/matsim/noise/NoiseDataManager.java | 57 ++++ .../bgu/msm/matsim/noise/NoiseDwelling.java | 11 + .../tum/bgu/msm/matsim/noise/NoiseModel.java | 51 ++++ .../matsim/noise/NoiseScenarioAssembler.java | 27 ++ .../accessibility/MatsimAccessibility.java | 40 +-- .../de/tum/bgu/msm/models/AbstractModel.java | 22 +- .../disability}/DataBuilderDisability.java | 2 +- .../disability}/SiloMucDisability.java | 4 +- .../msm/scenarios/noise/DataBuilderNoise.java | 69 +++++ .../scenarios/noise/NoiseDataContainer.java | 87 ++++++ .../msm/transportModel/matsim/SBBTest.java | 270 +++++++++--------- 14 files changed, 474 insertions(+), 200 deletions(-) delete mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java create mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java create mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java create mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDwelling.java create mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java create mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java rename useCases/munich/src/main/java/de/tum/bgu/msm/{ => scenarios/disability}/DataBuilderDisability.java (99%) rename useCases/munich/src/main/java/de/tum/bgu/msm/{ => scenarios/disability}/SiloMucDisability.java (97%) create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainer.java diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index 21be4d552..d067e821e 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -16,6 +16,7 @@ import org.matsim.core.router.util.LeastCostPathCalculatorFactory; import org.matsim.core.router.util.TravelDisutility; import org.matsim.core.router.util.TravelTime; +import org.matsim.core.scenario.ScenarioUtils; import org.matsim.pt.transitSchedule.api.TransitSchedule; import java.util.Collection; @@ -130,7 +131,7 @@ TripRouter createTripRouter() { final RoutingModule networkRoutingModule = DefaultRoutingModules.createPureNetworkRouter( TransportMode.car, PopulationUtils.getFactory(), carNetwork, leastCostPathCalculatorFactory.createPathCalculator(carNetwork, travelDisutility, travelTime)); final RoutingModule teleportationRoutingModule = DefaultRoutingModules.createTeleportationRouter( - TransportMode.walk, PopulationUtils.getFactory(), config.plansCalcRoute().getOrCreateModeRoutingParams(TransportMode.walk)); + TransportMode.walk, ScenarioUtils.createScenario(config), config.plansCalcRoute().getOrCreateModeRoutingParams(TransportMode.walk)); final RoutingModule ptRoutingModule; if (schedule != null) { diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java deleted file mode 100644 index 33538533c..000000000 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/NoiseScenarioAssembler.java +++ /dev/null @@ -1,23 +0,0 @@ -package de.tum.bgu.msm.matsim; - -import de.tum.bgu.msm.container.DataContainer; -import de.tum.bgu.msm.properties.Properties; -import org.matsim.api.core.v01.Scenario; -import org.matsim.core.config.Config; - -public class NoiseScenarioAssembler implements MatsimScenarioAssembler { - - private final SimpleMatsimScenarioAssembler delegate; - private final DataContainer dataContainer; - - public NoiseScenarioAssembler(DataContainer dataContainer, Properties properties) { - this.dataContainer = dataContainer; - this.delegate = new SimpleMatsimScenarioAssembler(dataContainer, properties); - this.noiseReceiverPoints = new NoiseReceiverPoints(); - } - - @Override - public Scenario assembleScenario(Config initialMatsimConfig, int year) { - return null; - } -} diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java new file mode 100644 index 000000000..00e776eaf --- /dev/null +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java @@ -0,0 +1,8 @@ +package de.tum.bgu.msm.matsim.noise; + +import de.tum.bgu.msm.container.DataContainer; + +public interface NoiseDataContainer extends DataContainer { + + NoiseDataManager getNoiseData(); +} diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java new file mode 100644 index 000000000..145180950 --- /dev/null +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java @@ -0,0 +1,57 @@ +package de.tum.bgu.msm.matsim.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingData; +import de.tum.bgu.msm.simulator.UpdateListener; +import org.matsim.api.core.v01.Id; +import org.matsim.contrib.noise.NoiseReceiverPoint; +import org.matsim.contrib.noise.NoiseReceiverPoints; +import org.matsim.contrib.noise.ReceiverPoint; +import org.matsim.core.utils.geometry.CoordUtils; + +public class NoiseDataManager implements UpdateListener { + + private final NoiseReceiverPoints noiseReceiverPoints; + private final DwellingData dwellingData; + + public NoiseDataManager(DwellingData dwellingData) { + this.dwellingData = dwellingData; + this.noiseReceiverPoints = new NoiseReceiverPoints(); + } + + @Override + public void setup() { + + } + + @Override + public void prepareYear(int year) { + + } + + @Override + public void endYear(int year) { + + } + + @Override + public void endSimulation() { + noiseReceiverPoints.clear(); + } + + public NoiseReceiverPoints getNoiseReceiverPoints() { + NoiseReceiverPoints newNoiseReceiverPoints = new NoiseReceiverPoints(); + for(Dwelling dwelling: dwellingData.getDwellings()) { + Id id = Id.create(dwelling.getId(), ReceiverPoint.class); + final NoiseReceiverPoint existing = noiseReceiverPoints.remove(id); + if(existing == null) { + newNoiseReceiverPoints.put(id, new NoiseReceiverPoint(id, CoordUtils.createCoord(dwelling.getCoordinate()))); + } else { + newNoiseReceiverPoints.put(id, existing); + } + } + this.noiseReceiverPoints.clear(); + this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); + return noiseReceiverPoints; + } +} diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDwelling.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDwelling.java new file mode 100644 index 000000000..75b3288cd --- /dev/null +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDwelling.java @@ -0,0 +1,11 @@ +package de.tum.bgu.msm.matsim.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; + +public interface NoiseDwelling extends Dwelling { + + void setNoiseImmision(double lden); + + double getNoiseImmission(); + +} diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java new file mode 100644 index 000000000..d91b7bf10 --- /dev/null +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -0,0 +1,51 @@ +package de.tum.bgu.msm.matsim.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.models.AbstractModel; +import de.tum.bgu.msm.properties.Properties; +import org.matsim.api.core.v01.Id; +import org.matsim.contrib.noise.NoiseReceiverPoints; +import org.matsim.contrib.noise.ReceiverPoint; + +import java.util.Random; + +public class NoiseModel extends AbstractModel { + + private final NoiseDataManager noiseDataManager; + + public NoiseModel(NoiseDataContainer data, Properties properties, Random random) { + super(data, properties, random); + this.noiseDataManager = data.getNoiseData(); + } + + @Override + public void setup() { + updateNoiseImmissions(); + } + + @Override + public void prepareYear(int year) { + if (properties.transportModel.transportModelYears.contains(year)) { + updateNoiseImmissions(); + } + } + + private void updateNoiseImmissions() { + //Transport model ran at end of last year + final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); + for (Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { + final Id id = Id.create(dwelling.getId(), ReceiverPoint.class); + if(noiseReceiverPoints.containsKey(id)) { + ((NoiseDwelling) dwelling).setNoiseImmision(noiseReceiverPoints.get(id).getLden()); + } + } + } + + @Override + public void endYear(int year) { + } + + @Override + public void endSimulation() { + } +} diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java new file mode 100644 index 000000000..684d54be3 --- /dev/null +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java @@ -0,0 +1,27 @@ +package de.tum.bgu.msm.matsim.noise; + +import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; +import org.matsim.api.core.v01.Scenario; +import org.matsim.contrib.noise.NoiseReceiverPoints; +import org.matsim.core.config.Config; +import org.matsim.core.config.groups.ControlerConfigGroup; + +public final class NoiseScenarioAssembler implements MatsimScenarioAssembler { + + private final MatsimScenarioAssembler delegate; + private final NoiseDataManager noiseDataManager; + + public NoiseScenarioAssembler(MatsimScenarioAssembler delegate, NoiseDataManager noiseDataManager) { + this.delegate = delegate; + this.noiseDataManager = noiseDataManager; + } + + @Override + public Scenario assembleScenario(Config initialMatsimConfig, int year) { + Scenario scenario = delegate.assembleScenario(initialMatsimConfig, year); + final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); + scenario.getConfig().controler().setRoutingAlgorithmType(ControlerConfigGroup.RoutingAlgorithmType.FastDijkstra); + scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); + return scenario; + } +} diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/accessibility/MatsimAccessibility.java b/siloCore/src/main/java/de/tum/bgu/msm/data/accessibility/MatsimAccessibility.java index 5d13fe1ac..e6e21a579 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/accessibility/MatsimAccessibility.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/accessibility/MatsimAccessibility.java @@ -1,20 +1,19 @@ package de.tum.bgu.msm.data.accessibility; -import java.util.Collection; -import java.util.HashMap; -import java.util.Map; - +import de.tum.bgu.msm.data.Region; +import de.tum.bgu.msm.data.Zone; +import de.tum.bgu.msm.data.geo.GeoData; +import de.tum.bgu.msm.util.matrices.IndexedDoubleMatrix1D; import org.apache.log4j.Logger; import org.jfree.util.Log; import org.matsim.api.core.v01.Id; -import org.matsim.contrib.accessibility.interfaces.FacilityDataExchangeInterface; +import org.matsim.contrib.accessibility.FacilityDataExchangeInterface; import org.matsim.core.utils.collections.Tuple; import org.matsim.facilities.ActivityFacility; -import de.tum.bgu.msm.data.Region; -import de.tum.bgu.msm.data.Zone; -import de.tum.bgu.msm.data.geo.GeoData; -import de.tum.bgu.msm.util.matrices.IndexedDoubleMatrix1D; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; /** * @author dziemke @@ -29,20 +28,25 @@ public class MatsimAccessibility implements Accessibility, FacilityDataExchangeI private Map, Double> autoAccessibilities = new HashMap<>(); private Map, Double> transitAccessibilities = new HashMap<>(); private IndexedDoubleMatrix1D regionalAccessibilities; - + public MatsimAccessibility(GeoData geoData) { this.geoData = geoData; } - + // FacilityDataExchangeInterface methods - @Override +// @Override public void setFacilityAccessibilities(ActivityFacility measurePoint, Double timeOfDay, Map accessibilities){ if (timeOfDay == 8 * 60. * 60.) { // TODO Find better way for this check accessibilitiesMap.put(new Tuple(measurePoint, timeOfDay), accessibilities); } } - + @Override + public void setFacilityAccessibilities(ActivityFacility activityFacility, Double aDouble, String s, double v) { + + } + + // @Override public void finish() { } // Accessibility interface methods @@ -61,7 +65,7 @@ public void calculateHansenAccessibilities(int year) { logger.info("Calculating regional accessibilities"); regionalAccessibilities.assign(calculateRegionalAccessibility(geoData.getRegions().values(), autoAccessibilities)); } - + @Override public double getAutoAccessibilityForZone(Zone zone) { Id afId = Id.create(zone.getId(), ActivityFacility.class); @@ -69,7 +73,7 @@ public double getAutoAccessibilityForZone(Zone zone) { // logger.info("Auto accessibility of zone " + zone + " is " + autoAccessibility); return autoAccessibility; } - + @Override public double getTransitAccessibilityForZone(Zone zone) { // logger.warn("Transit accessibilities not yet properly implemented."); @@ -83,7 +87,7 @@ public double getTransitAccessibilityForZone(Zone zone) { public double getRegionalAccessibility(Region region) { return regionalAccessibilities.getIndexed(region.getId()); } - + // Other methods private static void scaleAccessibility(Map, Double> accessibility) { double highestAccessibility = Double.MIN_VALUE; // TODO Rather use minus infinity @@ -97,7 +101,7 @@ private static void scaleAccessibility(Map, Double> accessi accessibility.put(measurePointId, accessibility.get(measurePointId) * scaleFactor); } } - + private static IndexedDoubleMatrix1D calculateRegionalAccessibility(Collection regions, Map, Double> autoAccessibilities) { final IndexedDoubleMatrix1D matrix = new IndexedDoubleMatrix1D(regions); for (Region region : regions) { @@ -119,7 +123,7 @@ public void setup() { @Override public void prepareYear(int year) { Log.warn("Preparing year in accessibilities."); - calculateHansenAccessibilities(year); + calculateHansenAccessibilities(year); } @Override diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/AbstractModel.java b/siloCore/src/main/java/de/tum/bgu/msm/models/AbstractModel.java index af5fe8127..2a1686283 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/AbstractModel.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/AbstractModel.java @@ -7,7 +7,7 @@ import java.util.Random; -public class AbstractModel implements UpdateListener { +public abstract class AbstractModel implements UpdateListener { private final static Logger logger = Logger.getLogger(AbstractModel.class); @@ -21,26 +21,6 @@ public AbstractModel(DataContainer dataContainer, Properties properties, Random this.random = random; } - @Override - public void setup() { - - } - - @Override - public void prepareYear(int year) { - - } - - @Override - public void endYear(int year) { - - } - - @Override - public void endSimulation() { - - } - public void logCurrentRandomState() { logger.info(this.getClass().getSimpleName() + " | random: " + random.nextDouble()); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilderDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/DataBuilderDisability.java similarity index 99% rename from useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilderDisability.java rename to useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/DataBuilderDisability.java index 9004ec243..599b4895c 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilderDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/DataBuilderDisability.java @@ -1,4 +1,4 @@ -package de.tum.bgu.msm; +package de.tum.bgu.msm.scenarios.disability; import de.tum.bgu.msm.data.accessibility.Accessibility; import de.tum.bgu.msm.data.accessibility.AccessibilityImpl; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/SiloMucDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/SiloMucDisability.java similarity index 97% rename from useCases/munich/src/main/java/de/tum/bgu/msm/SiloMucDisability.java rename to useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/SiloMucDisability.java index de0472e3b..527eb9b0a 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/SiloMucDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/SiloMucDisability.java @@ -1,5 +1,7 @@ -package de.tum.bgu.msm; +package de.tum.bgu.msm.scenarios.disability; +import de.tum.bgu.msm.ModelBuilderMuc; +import de.tum.bgu.msm.SiloModel; import de.tum.bgu.msm.container.ModelContainer; import de.tum.bgu.msm.schools.DataContainerWithSchoolsImpl; import de.tum.bgu.msm.events.DisabilityEvent; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java new file mode 100644 index 000000000..fda20d3f5 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java @@ -0,0 +1,69 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.DataBuilder; +import de.tum.bgu.msm.container.DataContainer; +import de.tum.bgu.msm.data.accessibility.Accessibility; +import de.tum.bgu.msm.data.accessibility.AccessibilityImpl; +import de.tum.bgu.msm.data.accessibility.CommutingTimeProbability; +import de.tum.bgu.msm.data.dwelling.*; +import de.tum.bgu.msm.data.geo.DefaultGeoData; +import de.tum.bgu.msm.data.geo.GeoData; +import de.tum.bgu.msm.data.household.*; +import de.tum.bgu.msm.data.job.*; +import de.tum.bgu.msm.data.person.PersonFactoryMuc; +import de.tum.bgu.msm.data.travelTimes.SkimTravelTimes; +import de.tum.bgu.msm.data.travelTimes.TravelTimes; +import de.tum.bgu.msm.io.*; +import de.tum.bgu.msm.io.input.*; +import de.tum.bgu.msm.matsim.MatsimTravelTimes; +import de.tum.bgu.msm.matsim.noise.NoiseDataManager; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.schools.*; +import org.matsim.core.config.Config; + +public class DataBuilderNoise { + + private DataBuilderNoise() { + } + + public static DataContainer getModelDataForMuc(Properties properties, Config config) { + DataContainer delegate = DataBuilder.getModelDataForMuc(properties, config); + + + NoiseDataManager noiseDataManager = new NoiseDataManager(); + return new NoiseDataContainer(delegate, noiseDataManager); + } + + static public void read(Properties properties, DataContainerWithSchoolsImpl dataContainer){ + + GeoDataReader reader = new GeoDataReaderMuc(dataContainer.getGeoData()); + String pathShp = properties.main.baseDirectory + properties.geo.zoneShapeFile; + String fileName = properties.main.baseDirectory + properties.geo.zonalDataFile; + reader.readZoneCsv(fileName); + reader.readZoneShapefile(pathShp); + + int year = properties.main.startYear; + String householdFile = properties.main.baseDirectory + properties.householdData.householdFileName; + householdFile += "_" + year + ".csv"; + HouseholdReader hhReader = new HouseholdReaderMuc(dataContainer.getHouseholdDataManager(), (HouseholdFactoryMuc) dataContainer.getHouseholdDataManager().getHouseholdFactory()); + hhReader.readData(householdFile); + + String personFile = properties.main.baseDirectory + properties.householdData.personFileName; + personFile += "_" + year + ".csv"; + PersonReader personReader = new PersonReaderMuc(dataContainer.getHouseholdDataManager()); + personReader.readData(personFile); + + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager()); + String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; + ddReader.readData(dwellingsFile); + + new JobType(properties.jobData.jobTypes); + JobReader jjReader = new JobReaderMuc(dataContainer.getJobDataManager(), (JobFactoryMuc) dataContainer.getJobDataManager().getFactory()); + String jobsFile = properties.main.baseDirectory + properties.jobData.jobsFileName + "_" + year + ".csv"; + jjReader.readData(jobsFile); + + SchoolReader ssReader = new SchoolReaderImpl(dataContainer.getSchoolData()); + String schoolsFile = properties.main.baseDirectory + properties.schoolData.schoolsFileName + "_" + year + ".csv"; + ssReader.readData(schoolsFile); + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainer.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainer.java new file mode 100644 index 000000000..1ce6077f1 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainer.java @@ -0,0 +1,87 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.accessibility.Accessibility; +import de.tum.bgu.msm.data.accessibility.CommutingTimeProbability; +import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; +import de.tum.bgu.msm.data.geo.GeoData; +import de.tum.bgu.msm.data.household.HouseholdDataManager; +import de.tum.bgu.msm.data.job.JobDataManager; +import de.tum.bgu.msm.data.travelTimes.TravelTimes; +import de.tum.bgu.msm.matsim.noise.NoiseDataManager; +import de.tum.bgu.msm.schools.DataContainerWithSchools; +import de.tum.bgu.msm.schools.SchoolData; + +public class NoiseDataContainer implements de.tum.bgu.msm.matsim.noise.NoiseDataContainer { + + private final DataContainerWithSchools delegate; + private final NoiseDataManager noiseDataManager; + + public NoiseDataContainer(DataContainerWithSchools delegate, NoiseDataManager noiseDataManager) { + this.delegate = delegate; + this.noiseDataManager = noiseDataManager; + } + + public SchoolData getSchoolData() { + return delegate.getSchoolData(); + } + + @Override + public HouseholdDataManager getHouseholdDataManager() { + return delegate.getHouseholdDataManager(); + } + + @Override + public RealEstateDataManager getRealEstateDataManager() { + return delegate.getRealEstateDataManager(); + } + + @Override + public JobDataManager getJobDataManager() { + return delegate.getJobDataManager(); + } + + @Override + public GeoData getGeoData() { + return delegate.getGeoData(); + } + + @Override + public TravelTimes getTravelTimes() { + return delegate.getTravelTimes(); + } + + @Override + public Accessibility getAccessibility() { + return delegate.getAccessibility(); + } + + @Override + public CommutingTimeProbability getCommutingTimeProbability() { + return delegate.getCommutingTimeProbability(); + } + + @Override + public void setup() { + delegate.setup(); + } + + @Override + public void prepareYear(int year) { + delegate.prepareYear(year); + } + + @Override + public void endYear(int year) { + delegate.endYear(year); + } + + @Override + public void endSimulation() { + delegate.endSimulation(); + } + + @Override + public NoiseDataManager getNoiseData() { + return noiseDataManager; + } +} diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java index bb1ab5c73..f3716f4e9 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java @@ -1,148 +1,148 @@ -package de.tum.bgu.msm.transportModel.matsim; - -import ch.sbb.matsim.routing.pt.raptor.*; -import com.google.common.collect.Lists; -import org.junit.Ignore; -import org.junit.Test; -import org.matsim.api.core.v01.Coord; -import org.matsim.api.core.v01.Id; -import org.matsim.api.core.v01.Scenario; -import org.matsim.api.core.v01.TransportMode; -import org.matsim.api.core.v01.population.Activity; -import org.matsim.api.core.v01.population.Leg; -import org.matsim.api.core.v01.population.PlanElement; -import org.matsim.api.core.v01.population.Population; -import org.matsim.core.config.Config; -import org.matsim.core.config.ConfigUtils; -import org.matsim.core.controler.Controler; -import org.matsim.core.controler.OutputDirectoryHierarchy; -import org.matsim.core.network.io.MatsimNetworkReader; -import org.matsim.core.population.PopulationUtils; -import org.matsim.core.router.*; -import org.matsim.core.router.util.LeastCostPathCalculator; -import org.matsim.core.scenario.ScenarioUtils; -import org.matsim.facilities.ActivityFacilitiesFactory; -import org.matsim.facilities.ActivityFacilitiesFactoryImpl; -import org.matsim.facilities.ActivityFacility; -import org.matsim.facilities.Facility; -import org.matsim.pt.PtConstants; -import org.matsim.pt.transitSchedule.api.TransitScheduleReader; -import org.matsim.pt.transitSchedule.api.TransitStopFacility; -import org.matsim.vehicles.VehicleReaderV1; - -import javax.inject.Provider; -import java.util.List; -import java.util.Map; - -public class SBBTest { - - @Ignore - @Test - public void test() { - Config config = ConfigUtils.createConfig(); - - Scenario scenario = ScenarioUtils.createScenario(config); - - new MatsimNetworkReader(scenario.getNetwork()).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\network2018.xml"); - new TransitScheduleReader(scenario).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\schedule2018.xml"); - -// Provider provider = () -> -// new DefaultRaptorStopFinder( -// null, -// new DefaultRaptorIntermodalAccessEgress(), -// null); -// -// Population pop = PopulationUtils.createPopulation(config); -// final SwissRailRaptorFactory swissRailRaptorFactory = new SwissRailRaptorFactory( -// scenario.getTransitSchedule(), -// config, -// scenario.getNetwork(), -// new DefaultRaptorParametersForPerson(config), -// new LeastCostRaptorRouteSelector(), -// provider, -// config.plans(), -// pop, -// null -// ); -// -// TripRouter.Builder bd = new TripRouter.Builder(ConfigUtils.createConfig()); +//package de.tum.bgu.msm.transportModel.matsim; +// +//import ch.sbb.matsim.routing.pt.raptor.*; +//import com.google.common.collect.Lists; +//import org.junit.Ignore; +//import org.junit.Test; +//import org.matsim.api.core.v01.Coord; +//import org.matsim.api.core.v01.Id; +//import org.matsim.api.core.v01.Scenario; +//import org.matsim.api.core.v01.TransportMode; +//import org.matsim.api.core.v01.population.Activity; +//import org.matsim.api.core.v01.population.Leg; +//import org.matsim.api.core.v01.population.PlanElement; +//import org.matsim.api.core.v01.population.Population; +//import org.matsim.core.config.Config; +//import org.matsim.core.config.ConfigUtils; +//import org.matsim.core.controler.Controler; +//import org.matsim.core.controler.OutputDirectoryHierarchy; +//import org.matsim.core.network.io.MatsimNetworkReader; +//import org.matsim.core.population.PopulationUtils; +//import org.matsim.core.router.*; +//import org.matsim.core.router.util.LeastCostPathCalculator; +//import org.matsim.core.scenario.ScenarioUtils; +//import org.matsim.facilities.ActivityFacilitiesFactory; +//import org.matsim.facilities.ActivityFacilitiesFactoryImpl; +//import org.matsim.facilities.ActivityFacility; +//import org.matsim.facilities.Facility; +//import org.matsim.pt.PtConstants; +//import org.matsim.pt.transitSchedule.api.TransitScheduleReader; +//import org.matsim.pt.transitSchedule.api.TransitStopFacility; +//import org.matsim.vehicles.VehicleReaderV1; +// +//import javax.inject.Provider; +//import java.util.List; +//import java.util.Map; +// +//public class SBBTest { +// +// @Ignore +// @Test +// public void test() { +// Config config = ConfigUtils.createConfig(); +// +// Scenario scenario = ScenarioUtils.createScenario(config); +// +// new MatsimNetworkReader(scenario.getNetwork()).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\network2018.xml"); +// new TransitScheduleReader(scenario).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\schedule2018.xml"); +// +//// Provider provider = () -> +//// new DefaultRaptorStopFinder( +//// null, +//// new DefaultRaptorIntermodalAccessEgress(), +//// null); +//// +//// Population pop = PopulationUtils.createPopulation(config); +//// final SwissRailRaptorFactory swissRailRaptorFactory = new SwissRailRaptorFactory( +//// scenario.getTransitSchedule(), +//// config, +//// scenario.getNetwork(), +//// new DefaultRaptorParametersForPerson(config), +//// new LeastCostRaptorRouteSelector(), +//// provider, +//// config.plans(), +//// pop, +//// null +//// ); +//// +//// TripRouter.Builder bd = new TripRouter.Builder(ConfigUtils.createConfig()); +//// TeleportationRoutingModule teleportationRoutingModule = +//// new TeleportationRoutingModule( +//// TransportMode.transit_walk, +//// PopulationUtils.getFactory(), +//// 1.4, +//// 1.3); +//// RoutingModule routingModule = +//// new SwissRailRaptorRoutingModule( +//// swissRailRaptorFactory.get(), +//// scenario.getTransitSchedule(), +//// scenario.getNetwork(), +//// teleportationRoutingModule); +//// bd.setRoutingModule(TransportMode.pt, routingModule); +//// +// +// Population population = PopulationUtils.createPopulation(config); +// TripRouter.Builder bd = new TripRouter.Builder(config); +// +//// TeleportationRoutingModule teleportationRoutingModule = new TeleportationRoutingModule(TransportMode.pt, PopulationUtils.getFactory(), 10, 1.3); +//// bd.setRoutingModule(TransportMode.pt, teleportationRoutingModule); +// +// // TeleportationRoutingModule teleportationRoutingModule = // new TeleportationRoutingModule( // TransportMode.transit_walk, // PopulationUtils.getFactory(), // 1.4, // 1.3); +// +// RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); +// raptorConfig.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); +// SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), raptorConfig, scenario.getNetwork()); +// SwissRailRaptor raptor = new SwissRailRaptor(raptorData, new DefaultRaptorParametersForPerson(config), null, new DefaultRaptorStopFinder( +// null, +// new DefaultRaptorIntermodalAccessEgress(), +// null)); +// // RoutingModule routingModule = // new SwissRailRaptorRoutingModule( -// swissRailRaptorFactory.get(), +// raptor, // scenario.getTransitSchedule(), // scenario.getNetwork(), // teleportationRoutingModule); // bd.setRoutingModule(TransportMode.pt, routingModule); // - - Population population = PopulationUtils.createPopulation(config); - TripRouter.Builder bd = new TripRouter.Builder(config); - -// TeleportationRoutingModule teleportationRoutingModule = new TeleportationRoutingModule(TransportMode.pt, PopulationUtils.getFactory(), 10, 1.3); -// bd.setRoutingModule(TransportMode.pt, teleportationRoutingModule); - - - TeleportationRoutingModule teleportationRoutingModule = - new TeleportationRoutingModule( - TransportMode.transit_walk, - PopulationUtils.getFactory(), - 1.4, - 1.3); - - RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); - raptorConfig.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); - SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), raptorConfig, scenario.getNetwork()); - SwissRailRaptor raptor = new SwissRailRaptor(raptorData, new DefaultRaptorParametersForPerson(config), null, new DefaultRaptorStopFinder( - null, - new DefaultRaptorIntermodalAccessEgress(), - null)); - - RoutingModule routingModule = - new SwissRailRaptorRoutingModule( - raptor, - scenario.getTransitSchedule(), - scenario.getNetwork(), - teleportationRoutingModule); - bd.setRoutingModule(TransportMode.pt, routingModule); - - - final Coord originCoord = new Coord(4436689.657372447, 5368527.815536651); - ActivityFacilitiesFactoryImpl activityFacilitiesFactory = new ActivityFacilitiesFactoryImpl(); - Facility fromFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(1, ActivityFacility.class), originCoord); - - long time = System.currentTimeMillis(); - final Map, SwissRailRaptorCore.TravelInfo> idTravelInfoMap = raptor.calcTree(fromFacility, 28800, null); - - System.out.println(System.currentTimeMillis() - time); - - TripRouter router = bd.build(); - -// final Coord destinationCoord = new Coord(4489369.625538794, 5294502.251605561); -// -// Facility toFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(2, ActivityFacility.class), destinationCoord); -// -// long timeQuery = System.currentTimeMillis(); -// -// double time = 0; -// List planElements = router.calcRoute(TransportMode.pt, fromFacility, toFacility, 28800, null); -// System.out.println(System.currentTimeMillis()-timeQuery); -// -// for (PlanElement e : planElements) { -// if (e instanceof Leg) { -// time += ((Leg) e).getTravelTime(); -// } else if (e instanceof Activity) { -// if (((Activity) e).getType().equalsIgnoreCase(PtConstants.TRANSIT_ACTIVITY_TYPE)) { -// time += ((Activity) e).getEndTime() - ((Activity) e).getStartTime(); -// } -// } -// } - - - } -} +// +// final Coord originCoord = new Coord(4436689.657372447, 5368527.815536651); +// ActivityFacilitiesFactoryImpl activityFacilitiesFactory = new ActivityFacilitiesFactoryImpl(); +// Facility fromFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(1, ActivityFacility.class), originCoord); +// +// long time = System.currentTimeMillis(); +// final Map, SwissRailRaptorCore.TravelInfo> idTravelInfoMap = raptor.calcTree(fromFacility, 28800, null); +// +// System.out.println(System.currentTimeMillis() - time); +// +// TripRouter router = bd.build(); +// +//// final Coord destinationCoord = new Coord(4489369.625538794, 5294502.251605561); +//// +//// Facility toFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(2, ActivityFacility.class), destinationCoord); +//// +//// long timeQuery = System.currentTimeMillis(); +//// +//// double time = 0; +//// List planElements = router.calcRoute(TransportMode.pt, fromFacility, toFacility, 28800, null); +//// System.out.println(System.currentTimeMillis()-timeQuery); +//// +//// for (PlanElement e : planElements) { +//// if (e instanceof Leg) { +//// time += ((Leg) e).getTravelTime(); +//// } else if (e instanceof Activity) { +//// if (((Activity) e).getType().equalsIgnoreCase(PtConstants.TRANSIT_ACTIVITY_TYPE)) { +//// time += ((Activity) e).getEndTime() - ((Activity) e).getStartTime(); +//// } +//// } +//// } +// +// +// } +//} From ac2f0d4feeb38d89965c134677e92f0ec162f06c Mon Sep 17 00:00:00 2001 From: Nico Date: Mon, 4 Nov 2019 13:45:50 +0100 Subject: [PATCH 03/24] noise feedback works for test case now --- .../bgu/msm/matsim/MatsimTransportModel.java | 5 + .../tum/bgu/msm/matsim/noise/NoiseModel.java | 22 ++- .../matsim/noise/NoiseScenarioAssembler.java | 11 ++ .../main/java/de/tum/bgu/msm/DataBuilder.java | 2 +- .../java/de/tum/bgu/msm/ModelBuilderMuc.java | 15 +- .../msm/data/mito/MitoDataConverterMuc.java | 4 +- .../de/tum/bgu/msm/io/DwellingReaderMuc.java | 5 +- .../tum/bgu/msm/models/EducationModelMuc.java | 8 +- .../models/relocation/InOutMigrationMuc.java | 15 +- .../disability/DataBuilderDisability.java | 2 +- .../msm/scenarios/noise/DataBuilderNoise.java | 60 ++++++- .../scenarios/noise/ModelBuilderMucNoise.java | 161 ++++++++++++++++++ ...ainer.java => NoiseDataContainerImpl.java} | 4 +- .../scenarios/noise/NoiseDwellingFactory.java | 22 +++ .../msm/scenarios/noise/NoiseDwellingIml.java | 127 ++++++++++++++ .../bgu/msm/scenarios/noise/SiloMucNoise.java | 38 +++++ .../transportModel/matsim/SiloNoiseTest.java | 57 +++++++ useCases/pom.xml | 2 +- 18 files changed, 521 insertions(+), 39 deletions(-) create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java rename useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/{NoiseDataContainer.java => NoiseDataContainerImpl.java} (90%) create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java create mode 100644 useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java index 43bfe5e29..85a7df807 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java @@ -39,6 +39,8 @@ import org.matsim.contrib.accessibility.AccessibilityConfigGroup; import org.matsim.contrib.accessibility.AccessibilityModule; import org.matsim.contrib.dvrp.trafficmonitoring.TravelTimeUtils; +import org.matsim.contrib.noise.NoiseModule; +import org.matsim.contrib.noise.NoiseReceiverPoints; import org.matsim.core.config.Config; import org.matsim.core.config.ConfigUtils; import org.matsim.core.config.groups.FacilitiesConfigGroup; @@ -157,6 +159,9 @@ private void runTransportModel(int year) { if (accessibility != null) { setupAccessibility(assembledScenario, controler); } + if(assembledScenario.getScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS) != null) { + controler.addOverridingModule(new NoiseModule()); + } controler.run(); logger.warn("Running MATSim transport model for year " + year + " finished."); diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index d91b7bf10..e3827a879 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -2,15 +2,18 @@ import de.tum.bgu.msm.data.dwelling.Dwelling; import de.tum.bgu.msm.models.AbstractModel; +import de.tum.bgu.msm.models.ModelUpdateListener; import de.tum.bgu.msm.properties.Properties; +import org.apache.log4j.Logger; import org.matsim.api.core.v01.Id; import org.matsim.contrib.noise.NoiseReceiverPoints; import org.matsim.contrib.noise.ReceiverPoint; import java.util.Random; -public class NoiseModel extends AbstractModel { +public class NoiseModel extends AbstractModel implements ModelUpdateListener { + private static final Logger logger = Logger.getLogger(NoiseModel.class); private final NoiseDataManager noiseDataManager; public NoiseModel(NoiseDataContainer data, Properties properties, Random random) { @@ -33,12 +36,27 @@ public void prepareYear(int year) { private void updateNoiseImmissions() { //Transport model ran at end of last year final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); + int counter65 = 0; + int counter55 = 0; for (Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { final Id id = Id.create(dwelling.getId(), ReceiverPoint.class); if(noiseReceiverPoints.containsKey(id)) { - ((NoiseDwelling) dwelling).setNoiseImmision(noiseReceiverPoints.get(id).getLden()); + double lden = noiseReceiverPoints.get(id).getLden(); + ((NoiseDwelling) dwelling).setNoiseImmision(lden); + if(lden > 55) { + if(lden > 65) { + counter65++; + } else { + counter55++; + } + } } } + int total = dataContainer.getRealEstateDataManager().getDwellings().size(); + int quiet = total - counter55 - counter65; + logger.info("Dwellings <55dB(A) : " + quiet + " (" + ((double) quiet) / total + "%)"); + logger.info("Dwellings 55dB(A)-65dB(A) : " + counter55 + " (" + ((double) counter55) / total + "%)"); + logger.info("Dwellings >65dB(A) : " + counter65 + " (" + ((double) counter65) / total + "%)"); } @Override diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java index 684d54be3..c95128bed 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java @@ -2,8 +2,10 @@ import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; import org.matsim.api.core.v01.Scenario; +import org.matsim.contrib.noise.NoiseConfigGroup; import org.matsim.contrib.noise.NoiseReceiverPoints; import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; import org.matsim.core.config.groups.ControlerConfigGroup; public final class NoiseScenarioAssembler implements MatsimScenarioAssembler { @@ -22,6 +24,15 @@ public Scenario assembleScenario(Config initialMatsimConfig, int year) { final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); scenario.getConfig().controler().setRoutingAlgorithmType(ControlerConfigGroup.RoutingAlgorithmType.FastDijkstra); scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); + NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); + noiseParameters.setInternalizeNoiseDamages(false); + noiseParameters.setComputeCausingAgents(false); + noiseParameters.setComputeNoiseDamages(false); + noiseParameters.setComputePopulationUnits(false); + noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); + noiseParameters.setWriteOutputIteration(0); + scenario.getConfig().qsim().setEndTime(24*60*60); + return scenario; } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java b/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java index 7cdb414dc..298247a9c 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java @@ -95,7 +95,7 @@ static public void read(Properties properties, DataContainerWithSchools dataCont PersonReader personReader = new PersonReaderMuc(dataContainer.getHouseholdDataManager()); personReader.readData(personFile); - DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager()); + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager(), new DwellingFactoryImpl()); String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; ddReader.readData(dwellingsFile); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/ModelBuilderMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/ModelBuilderMuc.java index 6714351b6..dad5330d4 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/ModelBuilderMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/ModelBuilderMuc.java @@ -1,17 +1,16 @@ package de.tum.bgu.msm; +import de.tum.bgu.msm.container.DataContainer; import de.tum.bgu.msm.container.ModelContainer; -import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; -import de.tum.bgu.msm.matsim.SimpleMatsimScenarioAssembler; -import de.tum.bgu.msm.mito.MitoMatsimScenarioAssembler; -import de.tum.bgu.msm.models.relocation.moves.RegionProbabilityStrategyImpl; -import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.data.dwelling.DwellingFactory; import de.tum.bgu.msm.data.household.HouseholdFactory; import de.tum.bgu.msm.data.mito.MitoDataConverterMuc; import de.tum.bgu.msm.data.person.PersonFactory; +import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; import de.tum.bgu.msm.matsim.MatsimTransportModel; +import de.tum.bgu.msm.matsim.SimpleMatsimScenarioAssembler; import de.tum.bgu.msm.matsim.ZoneConnectorManager; +import de.tum.bgu.msm.mito.MitoMatsimScenarioAssembler; import de.tum.bgu.msm.models.EducationModelMuc; import de.tum.bgu.msm.models.MarriageModelMuc; import de.tum.bgu.msm.models.autoOwnership.CreateCarOwnershipModel; @@ -58,14 +57,16 @@ import de.tum.bgu.msm.models.relocation.moves.DefaultDwellingProbabilityStrategy; import de.tum.bgu.msm.models.relocation.moves.DefaultMovesStrategy; import de.tum.bgu.msm.models.relocation.moves.MovesModelImpl; +import de.tum.bgu.msm.models.relocation.moves.RegionProbabilityStrategyImpl; import de.tum.bgu.msm.models.transportModel.TransportModel; import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.utils.SiloUtil; import org.matsim.core.config.Config; public class ModelBuilderMuc { - public static ModelContainer getModelContainerForMuc(DataContainerWithSchools dataContainer, Properties properties, Config config) { + public static ModelContainer getModelContainerForMuc(DataContainer dataContainer, Properties properties, Config config) { PersonFactory ppFactory = dataContainer.getHouseholdDataManager().getPersonFactory(); HouseholdFactory hhFactory = dataContainer.getHouseholdDataManager().getHouseholdFactory(); @@ -93,7 +94,7 @@ public static ModelContainer getModelContainerForMuc(DataContainerWithSchools da DriversLicenseModel driversLicenseModel = new DriversLicenseModelImpl(dataContainer, properties, new DefaultDriversLicenseStrategy(), SiloUtil.provideNewRandom()); - EducationModel educationModel = new EducationModelMuc(dataContainer, properties, SiloUtil.provideNewRandom()); + EducationModel educationModel = new EducationModelMuc((DataContainerWithSchools) dataContainer, properties, SiloUtil.provideNewRandom()); EmploymentModel employmentModel = new EmploymentModelImpl(dataContainer, properties, SiloUtil.provideNewRandom()); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java index cad3156c5..dfe685dbc 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java @@ -13,7 +13,7 @@ import de.tum.bgu.msm.data.person.Person; import de.tum.bgu.msm.data.person.PersonMuc; import de.tum.bgu.msm.mito.MitoDataConverter; -import de.tum.bgu.msm.schools.DataContainerWithSchoolsImpl; +import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.schools.School; import de.tum.bgu.msm.schools.SchoolImpl; import org.apache.log4j.Logger; @@ -45,7 +45,7 @@ private void convertZones(DataSet dataSet, DataContainer dataContainer) { private void convertSchools(DataSet dataSet, DataContainer dataContainer) { Map zones = dataSet.getZones(); - for (School school : ((DataContainerWithSchoolsImpl) dataContainer).getSchoolData().getSchools()) { + for (School school : ((DataContainerWithSchools) dataContainer).getSchoolData().getSchools()) { MitoZone zone = zones.get(school.getZoneId()); Coordinate coordinate; if (school instanceof SchoolImpl) { diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/io/DwellingReaderMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/io/DwellingReaderMuc.java index 74cfb049d..d69d1c865 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/io/DwellingReaderMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/io/DwellingReaderMuc.java @@ -14,14 +14,15 @@ public class DwellingReaderMuc implements DwellingReader { private final static Logger logger = Logger.getLogger(DwellingReaderMuc.class); private final RealEstateDataManager dwellingData; + private final DwellingFactory factory; - public DwellingReaderMuc(RealEstateDataManager dwellingData) { + public DwellingReaderMuc(RealEstateDataManager dwellingData, DwellingFactory factory) { this.dwellingData= dwellingData; + this.factory = factory; } @Override public void readData(String path) { - DwellingFactory factory = DwellingUtils.getFactory(); logger.info("Reading dwelling micro data from ascii file"); String recString = ""; int recCount = 0; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/models/EducationModelMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/models/EducationModelMuc.java index c9bdcc394..f66aaffe1 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/models/EducationModelMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/models/EducationModelMuc.java @@ -69,7 +69,7 @@ public Collection getEventsForCurrentYear(int year) { case STUDENT: int oldSchoolType = -1; if(((PersonMuc)person).getSchoolId()> 0){ - oldSchoolType = ((DataContainerWithSchoolsImpl)dataContainer).getSchoolData().getSchoolFromId(((PersonMuc)person).getSchoolId()).getType(); + oldSchoolType = ((DataContainerWithSchools)dataContainer).getSchoolData().getSchoolFromId(((PersonMuc)person).getSchoolId()).getType(); }else if(((PersonMuc)person).getSchoolId()== -2){ oldSchoolType = SchoolDataImpl.guessSchoolType((PersonWithSchool) person); }else{ @@ -105,7 +105,7 @@ public boolean handleEvent(EducationEvent event) { if(pp.getSchoolId()== -2) { currentSchoolType = pp.getSchoolType(); }else{ - currentSchoolType = ((DataContainerWithSchoolsImpl)dataContainer).getSchoolData().getSchoolFromId(pp.getSchoolId()).getType(); + currentSchoolType = ((DataContainerWithSchools)dataContainer).getSchoolData().getSchoolFromId(pp.getSchoolId()).getType(); } if (currentSchoolType == 3) { @@ -154,7 +154,7 @@ boolean leaveSchoolToWork(PersonMuc person) { person.setSchoolId(-1); person.setSchoolType(-1); }else{ - School school = ((DataContainerWithSchoolsImpl)dataContainer).getSchoolData().getSchoolFromId(person.getSchoolId()); + School school = ((DataContainerWithSchools)dataContainer).getSchoolData().getSchoolFromId(person.getSchoolId()); school.setOccupancy(school.getOccupancy() + 1); person.setSchoolId(-1); } @@ -167,6 +167,6 @@ boolean leaveSchoolToWork(PersonMuc person) { } public School findSchool(Person person, int schoolType) { - return ((DataContainerWithSchoolsImpl)dataContainer).getSchoolData().getClosestSchool(person, schoolType); + return ((DataContainerWithSchools)dataContainer).getSchoolData().getClosestSchool(person, schoolType); } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/models/relocation/InOutMigrationMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/models/relocation/InOutMigrationMuc.java index dc30e8903..91e06569a 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/models/relocation/InOutMigrationMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/models/relocation/InOutMigrationMuc.java @@ -13,10 +13,7 @@ import de.tum.bgu.msm.models.relocation.migration.InOutMigrationImpl; import de.tum.bgu.msm.models.relocation.moves.MovesModelImpl; import de.tum.bgu.msm.properties.Properties; -import de.tum.bgu.msm.schools.DataContainerWithSchoolsImpl; -import de.tum.bgu.msm.schools.PersonWithSchool; -import de.tum.bgu.msm.schools.School; -import de.tum.bgu.msm.schools.SchoolDataImpl; +import de.tum.bgu.msm.schools.*; import de.tum.bgu.msm.utils.SiloUtil; import org.apache.log4j.Logger; @@ -26,14 +23,14 @@ public class InOutMigrationMuc implements InOutMigration { private static final Logger logger = Logger.getLogger(InOutMigrationMuc.class); private InOutMigrationImpl delegate; - private DataContainerWithSchoolsImpl dataContainerWithSchoolsImpl; + private DataContainerWithSchools dataContainerWithSchools; public InOutMigrationMuc(DataContainer dataContainer, EmploymentModel employment, MovesModelImpl movesModel, CreateCarOwnershipModel carOwnership, DriversLicenseModel driversLicense, Properties properties) { delegate = new InOutMigrationImpl(dataContainer, employment, movesModel, carOwnership, driversLicense, properties, SiloUtil.provideNewRandom()); - dataContainerWithSchoolsImpl = (DataContainerWithSchoolsImpl) dataContainer; + dataContainerWithSchools = (DataContainerWithSchools) dataContainer; } @@ -63,16 +60,16 @@ public boolean handleEvent(MigrationEvent event) { //SchoolType is duplicated from original person int SchoolType = -1; if(((PersonMuc)person).getSchoolId()> 0){ - SchoolType = dataContainerWithSchoolsImpl.getSchoolData().getSchoolFromId(((PersonMuc) person).getSchoolId()).getType(); + SchoolType = dataContainerWithSchools.getSchoolData().getSchoolFromId(((PersonMuc) person).getSchoolId()).getType(); }else if(((PersonMuc)person).getSchoolId()== -2){ SchoolType = SchoolDataImpl.guessSchoolType((PersonWithSchool) person); } - School newSchool = dataContainerWithSchoolsImpl.getSchoolData().getClosestSchool(person, SchoolType); + School newSchool = dataContainerWithSchools.getSchoolData().getClosestSchool(person, SchoolType); ((PersonMuc) person).setSchoolId(newSchool.getId()); newSchool.setOccupancy(newSchool.getOccupancy() - 1); } else if (event.getType().equals(MigrationEvent.Type.OUT)) { if(((PersonMuc)person).getSchoolId()> 0) { - School school = dataContainerWithSchoolsImpl.getSchoolData().getSchoolFromId(((PersonMuc) person).getSchoolId()); + School school = dataContainerWithSchools.getSchoolData().getSchoolFromId(((PersonMuc) person).getSchoolId()); school.setOccupancy(school.getOccupancy() + 1); }else{ logger.info("person id " + person.getId()+" has school id: " + ((PersonMuc) person).getSchoolId() + ". Person has a school outside study area or has no school assigned. " +person.getAge()+" Occupation: "+ person.getOccupation().name()); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/DataBuilderDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/DataBuilderDisability.java index 599b4895c..bfbe1a15b 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/DataBuilderDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disability/DataBuilderDisability.java @@ -95,7 +95,7 @@ static public void read(Properties properties, DataContainerWithSchoolsImpl data PersonReader personReader = new PersonReaderMucDisability(dataContainer.getHouseholdDataManager(), new DefaultDisabilityStrategy()); personReader.readData(personFile); - DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager()); + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager(), new DwellingFactoryImpl()); String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; ddReader.readData(dwellingsFile); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java index fda20d3f5..b4410ecae 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java @@ -1,7 +1,5 @@ package de.tum.bgu.msm.scenarios.noise; -import de.tum.bgu.msm.DataBuilder; -import de.tum.bgu.msm.container.DataContainer; import de.tum.bgu.msm.data.accessibility.Accessibility; import de.tum.bgu.msm.data.accessibility.AccessibilityImpl; import de.tum.bgu.msm.data.accessibility.CommutingTimeProbability; @@ -26,15 +24,61 @@ public class DataBuilderNoise { private DataBuilderNoise() { } - public static DataContainer getModelDataForMuc(Properties properties, Config config) { - DataContainer delegate = DataBuilder.getModelDataForMuc(properties, config); + public static NoiseDataContainerImpl getModelDataForMuc(Properties properties, Config config) { + HouseholdData householdData = new HouseholdDataImpl(); + JobData jobData = new JobDataImpl(); + DwellingData dwellingData = new DwellingDataImpl(); + GeoData geoData = new DefaultGeoData(); + + + TravelTimes travelTimes = null; + Accessibility accessibility = null; + + switch (properties.transportModel.travelTimeImplIdentifier) { + case SKIM: + travelTimes = new SkimTravelTimes(); + accessibility = new AccessibilityImpl(geoData, travelTimes, properties, dwellingData, jobData); + break; + case MATSIM: + travelTimes = new MatsimTravelTimes(config); +// accessibility = new MatsimAccessibility(geoData); + accessibility = new AccessibilityImpl(geoData, travelTimes, properties, dwellingData, jobData); + break; + default: + throw new RuntimeException("Travel time not recognized! Please set property \"travel.time\" accordingly!"); + } + + CommutingTimeProbability commutingTimeProbability = new CommutingTimeProbability(properties); + + //TODO: revise this! + new JobType(properties.jobData.jobTypes); + + + JobFactoryMuc jobFactory = new JobFactoryMuc(); + jobFactory.readWorkingTimeDistributions(properties); + + + RealEstateDataManager realEstateDataManager = new RealEstateDataManagerImpl( + DefaultDwellingTypeImpl.values(), dwellingData, householdData, geoData, new NoiseDwellingFactory(new DwellingFactoryImpl()), properties); + + JobDataManager jobDataManager = new JobDataManagerImpl( + properties, jobFactory, jobData, geoData, travelTimes, commutingTimeProbability); + + final HouseholdFactoryMuc hhFactory = new HouseholdFactoryMuc(); + HouseholdDataManager householdDataManager = new HouseholdDataManagerImpl( + householdData, dwellingData, new PersonFactoryMuc(), + hhFactory, properties, realEstateDataManager); + + SchoolData schoolData = new SchoolDataImpl(geoData, dwellingData, properties); + + DataContainerWithSchools delegate = new DataContainerWithSchoolsImpl(geoData, realEstateDataManager, jobDataManager, householdDataManager, travelTimes, accessibility, + commutingTimeProbability, schoolData, properties); + return new NoiseDataContainerImpl(delegate, new NoiseDataManager(dwellingData)); - NoiseDataManager noiseDataManager = new NoiseDataManager(); - return new NoiseDataContainer(delegate, noiseDataManager); } - static public void read(Properties properties, DataContainerWithSchoolsImpl dataContainer){ + static public void read(Properties properties, NoiseDataContainerImpl dataContainer){ GeoDataReader reader = new GeoDataReaderMuc(dataContainer.getGeoData()); String pathShp = properties.main.baseDirectory + properties.geo.zoneShapeFile; @@ -53,7 +97,7 @@ static public void read(Properties properties, DataContainerWithSchoolsImpl data PersonReader personReader = new PersonReaderMuc(dataContainer.getHouseholdDataManager()); personReader.readData(personFile); - DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager()); + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager(), new NoiseDwellingFactory(new DwellingFactoryImpl())); String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; ddReader.readData(dwellingsFile); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java new file mode 100644 index 000000000..f5b55344e --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -0,0 +1,161 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.container.ModelContainer; +import de.tum.bgu.msm.data.dwelling.DwellingFactory; +import de.tum.bgu.msm.data.household.HouseholdFactory; +import de.tum.bgu.msm.data.mito.MitoDataConverterMuc; +import de.tum.bgu.msm.data.person.PersonFactory; +import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; +import de.tum.bgu.msm.matsim.MatsimTransportModel; +import de.tum.bgu.msm.matsim.SimpleMatsimScenarioAssembler; +import de.tum.bgu.msm.matsim.ZoneConnectorManager; +import de.tum.bgu.msm.matsim.noise.NoiseScenarioAssembler; +import de.tum.bgu.msm.mito.MitoMatsimScenarioAssembler; +import de.tum.bgu.msm.models.EducationModelMuc; +import de.tum.bgu.msm.models.MarriageModelMuc; +import de.tum.bgu.msm.models.autoOwnership.CreateCarOwnershipModel; +import de.tum.bgu.msm.models.carOwnership.CreateCarOwnershipModelMuc; +import de.tum.bgu.msm.models.carOwnership.UpdateCarOwnershipModelMuc; +import de.tum.bgu.msm.models.demography.birth.BirthModelImpl; +import de.tum.bgu.msm.models.demography.birth.DefaultBirthStrategy; +import de.tum.bgu.msm.models.demography.birthday.BirthdayModel; +import de.tum.bgu.msm.models.demography.birthday.BirthdayModelImpl; +import de.tum.bgu.msm.models.demography.death.DeathModel; +import de.tum.bgu.msm.models.demography.death.DeathModelImpl; +import de.tum.bgu.msm.models.demography.death.DefaultDeathStrategy; +import de.tum.bgu.msm.models.demography.divorce.DefaultDivorceStrategy; +import de.tum.bgu.msm.models.demography.divorce.DivorceModel; +import de.tum.bgu.msm.models.demography.divorce.DivorceModelImpl; +import de.tum.bgu.msm.models.demography.driversLicense.DefaultDriversLicenseStrategy; +import de.tum.bgu.msm.models.demography.driversLicense.DriversLicenseModel; +import de.tum.bgu.msm.models.demography.driversLicense.DriversLicenseModelImpl; +import de.tum.bgu.msm.models.demography.education.EducationModel; +import de.tum.bgu.msm.models.demography.employment.EmploymentModel; +import de.tum.bgu.msm.models.demography.employment.EmploymentModelImpl; +import de.tum.bgu.msm.models.demography.leaveParentalHousehold.DefaultLeaveParentalHouseholdStrategy; +import de.tum.bgu.msm.models.demography.leaveParentalHousehold.LeaveParentHhModel; +import de.tum.bgu.msm.models.demography.leaveParentalHousehold.LeaveParentHhModelImpl; +import de.tum.bgu.msm.models.demography.marriage.DefaultMarriageStrategy; +import de.tum.bgu.msm.models.demography.marriage.MarriageModel; +import de.tum.bgu.msm.models.jobmography.JobMarketUpdate; +import de.tum.bgu.msm.models.jobmography.JobMarketUpdateImpl; +import de.tum.bgu.msm.models.realEstate.construction.*; +import de.tum.bgu.msm.models.realEstate.demolition.DefaultDemolitionStrategy; +import de.tum.bgu.msm.models.realEstate.demolition.DemolitionModel; +import de.tum.bgu.msm.models.realEstate.demolition.DemolitionModelImpl; +import de.tum.bgu.msm.models.realEstate.pricing.DefaultPricingStrategy; +import de.tum.bgu.msm.models.realEstate.pricing.PricingModel; +import de.tum.bgu.msm.models.realEstate.pricing.PricingModelImpl; +import de.tum.bgu.msm.models.realEstate.renovation.DefaultRenovationStrategy; +import de.tum.bgu.msm.models.realEstate.renovation.RenovationModel; +import de.tum.bgu.msm.models.realEstate.renovation.RenovationModelImpl; +import de.tum.bgu.msm.models.relocation.DwellingUtilityStrategyImpl; +import de.tum.bgu.msm.models.relocation.HousingStrategyMuc; +import de.tum.bgu.msm.models.relocation.InOutMigrationMuc; +import de.tum.bgu.msm.models.relocation.RegionUtilityStrategyMucImpl; +import de.tum.bgu.msm.models.relocation.migration.InOutMigration; +import de.tum.bgu.msm.models.relocation.moves.DefaultDwellingProbabilityStrategy; +import de.tum.bgu.msm.models.relocation.moves.DefaultMovesStrategy; +import de.tum.bgu.msm.models.relocation.moves.MovesModelImpl; +import de.tum.bgu.msm.models.relocation.moves.RegionProbabilityStrategyImpl; +import de.tum.bgu.msm.models.transportModel.TransportModel; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.schools.DataContainerWithSchools; +import de.tum.bgu.msm.utils.SiloUtil; +import org.matsim.core.config.Config; + +public class ModelBuilderMucNoise { + + public static ModelContainer getModelContainerForMuc(DataContainerWithSchools dataContainer, Properties properties, Config config) { + + PersonFactory ppFactory = dataContainer.getHouseholdDataManager().getPersonFactory(); + HouseholdFactory hhFactory = dataContainer.getHouseholdDataManager().getHouseholdFactory(); + DwellingFactory ddFactory = dataContainer.getRealEstateDataManager().getDwellingFactory(); + + final BirthModelImpl birthModel = new BirthModelImpl(dataContainer, ppFactory, properties, new DefaultBirthStrategy(), SiloUtil.provideNewRandom()); + + BirthdayModel birthdayModel = new BirthdayModelImpl(dataContainer, properties, SiloUtil.provideNewRandom()); + + DeathModel deathModel = new DeathModelImpl(dataContainer, properties, new DefaultDeathStrategy(), SiloUtil.provideNewRandom()); + + MovesModelImpl movesModel = new MovesModelImpl( + dataContainer, properties, + new DefaultMovesStrategy(), + new HousingStrategyMuc(dataContainer, + properties, + dataContainer.getTravelTimes(), new DefaultDwellingProbabilityStrategy(), + new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), new RegionProbabilityStrategyImpl()), SiloUtil.provideNewRandom()); + + CreateCarOwnershipModel carOwnershipModel = new CreateCarOwnershipModelMuc(dataContainer); + + DivorceModel divorceModel = new DivorceModelImpl( + dataContainer, movesModel, carOwnershipModel, hhFactory, + properties, new DefaultDivorceStrategy(), SiloUtil.provideNewRandom()); + + DriversLicenseModel driversLicenseModel = new DriversLicenseModelImpl(dataContainer, properties, new DefaultDriversLicenseStrategy(), SiloUtil.provideNewRandom()); + + EducationModel educationModel = new EducationModelMuc(dataContainer, properties, SiloUtil.provideNewRandom()); + + EmploymentModel employmentModel = new EmploymentModelImpl(dataContainer, properties, SiloUtil.provideNewRandom()); + + LeaveParentHhModel leaveParentsModel = new LeaveParentHhModelImpl(dataContainer, movesModel, + carOwnershipModel, hhFactory, properties, new DefaultLeaveParentalHouseholdStrategy(), SiloUtil.provideNewRandom()); + + JobMarketUpdate jobMarketUpdateModel = new JobMarketUpdateImpl(dataContainer, properties, SiloUtil.provideNewRandom()); + + ConstructionModel construction = new ConstructionModelImpl(dataContainer, ddFactory, + properties, new DefaultConstructionLocationStrategy(), new DefaultConstructionDemandStrategy(), SiloUtil.provideNewRandom()); + + + PricingModel pricing = new PricingModelImpl(dataContainer, properties, new DefaultPricingStrategy(), SiloUtil.provideNewRandom()); + + RenovationModel renovation = new RenovationModelImpl(dataContainer, properties, new DefaultRenovationStrategy(), SiloUtil.provideNewRandom()); + + ConstructionOverwrite constructionOverwrite = new ConstructionOverwriteImpl(dataContainer, ddFactory, properties, SiloUtil.provideNewRandom()); + + InOutMigration inOutMigration = new InOutMigrationMuc(dataContainer, employmentModel, movesModel, + carOwnershipModel, driversLicenseModel, properties); + + DemolitionModel demolition = new DemolitionModelImpl(dataContainer, movesModel, + inOutMigration, properties, new DefaultDemolitionStrategy(), SiloUtil.provideNewRandom()); + + MarriageModel marriageModel = new MarriageModelMuc(dataContainer, movesModel, inOutMigration, + carOwnershipModel, hhFactory, properties, new DefaultMarriageStrategy(), SiloUtil.provideNewRandom()); + + + TransportModel transportModel; + MatsimScenarioAssembler scenarioAssembler; + switch (properties.transportModel.transportModelIdentifier) { + case MITO_MATSIM: + MatsimScenarioAssembler delegate = new MitoMatsimScenarioAssembler(dataContainer, properties, new MitoDataConverterMuc()); + scenarioAssembler= new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); + transportModel = new MatsimTransportModel(dataContainer, config, properties, null, + ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, scenarioAssembler); + break; + case MATSIM: + delegate = new SimpleMatsimScenarioAssembler(dataContainer, properties); + scenarioAssembler= new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); + + transportModel = new MatsimTransportModel(dataContainer, config, properties, null, + ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, scenarioAssembler); + break; + case NONE: + default: + transportModel = null; + } + + final ModelContainer modelContainer = new ModelContainer( + birthModel, birthdayModel, + deathModel, marriageModel, + divorceModel, driversLicenseModel, + educationModel, employmentModel, + leaveParentsModel, jobMarketUpdateModel, + construction, demolition, pricing, renovation, + constructionOverwrite, inOutMigration, movesModel, transportModel); + + modelContainer.registerModelUpdateListener(new UpdateCarOwnershipModelMuc(dataContainer, properties, SiloUtil.provideNewRandom())); + + + return modelContainer; + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainer.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java similarity index 90% rename from useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainer.java rename to useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java index 1ce6077f1..ef4aafc18 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainer.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java @@ -11,12 +11,12 @@ import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.schools.SchoolData; -public class NoiseDataContainer implements de.tum.bgu.msm.matsim.noise.NoiseDataContainer { +public class NoiseDataContainerImpl implements de.tum.bgu.msm.matsim.noise.NoiseDataContainer, DataContainerWithSchools { private final DataContainerWithSchools delegate; private final NoiseDataManager noiseDataManager; - public NoiseDataContainer(DataContainerWithSchools delegate, NoiseDataManager noiseDataManager) { + public NoiseDataContainerImpl(DataContainerWithSchools delegate, NoiseDataManager noiseDataManager) { this.delegate = delegate; this.noiseDataManager = noiseDataManager; } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java new file mode 100644 index 000000000..8020b86dc --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java @@ -0,0 +1,22 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingFactory; +import de.tum.bgu.msm.data.dwelling.DwellingImpl; +import de.tum.bgu.msm.data.dwelling.DwellingType; +import org.locationtech.jts.geom.Coordinate; + +public class NoiseDwellingFactory implements DwellingFactory { + + private DwellingFactory delegate; + + public NoiseDwellingFactory(DwellingFactory delegate) { + this.delegate = delegate; + } + + + @Override + public Dwelling createDwelling(int id, int zoneId, Coordinate coordinate, int hhId, DwellingType type, int bedrooms, int quality, int price, int year) { + return new NoiseDwellingIml(delegate.createDwelling(id, zoneId, coordinate, hhId, type, bedrooms, quality, price, year)); + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java new file mode 100644 index 000000000..2c77f4184 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java @@ -0,0 +1,127 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingType; +import de.tum.bgu.msm.data.dwelling.DwellingUsage; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; +import org.locationtech.jts.geom.Coordinate; + +public class NoiseDwellingIml implements NoiseDwelling { + + private final Dwelling delegate; + private double immission; + + public NoiseDwellingIml(Dwelling delegate) { + this.delegate = delegate; + } + + @Override + public Coordinate getCoordinate() { + return delegate.getCoordinate(); + } + + @Override + public int getZoneId() { + return delegate.getZoneId(); + } + + @Override + public int getId() { + return delegate.getId(); + } + + @Override + public int getQuality() { + return delegate.getQuality(); + } + + @Override + public int getResidentId() { + return delegate.getResidentId(); + } + + @Override + public int getPrice() { + return delegate.getPrice(); + } + + @Override + public DwellingType getType() { + return delegate.getType(); + } + + @Override + public int getBedrooms() { + return delegate.getBedrooms(); + } + + @Override + public int getYearBuilt() { + return delegate.getYearBuilt(); + } + + @Override + public void setResidentID(int residentID) { + delegate.setResidentID(residentID); + } + + @Override + public void setQuality(int quality) { + delegate.setQuality(quality); + } + + @Override + public void setPrice(int price) { + delegate.setPrice(price); + } + + @Override + public void setFloorSpace(int floorSpace) { + delegate.setFloorSpace(floorSpace); + } + + @Override + public int getFloorSpace() { + return delegate.getFloorSpace(); + } + + @Override + public void setCoordinate(Coordinate coordinate) { + delegate.setCoordinate(coordinate); + } + + @Override + public void setUsage(DwellingUsage usage) { + delegate.setUsage(usage); + } + + @Override + public DwellingUsage getUsage() { + return delegate.getUsage(); + } + + @Override + public String toString() { + return delegate.toString(); + } + + @Override + public int hashCode() { + return delegate.hashCode(); + } + + @Override + public boolean equals(Object o) { + return delegate.equals(o); + } + + @Override + public void setNoiseImmision(double lden) { + this.immission = lden; + } + + @Override + public double getNoiseImmission() { + return this.immission; + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java new file mode 100644 index 000000000..5970365ac --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java @@ -0,0 +1,38 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.ModelBuilderMuc; +import de.tum.bgu.msm.SiloModel; +import de.tum.bgu.msm.SiloMuc; +import de.tum.bgu.msm.container.ModelContainer; +import de.tum.bgu.msm.io.ResultsMonitorMuc; +import de.tum.bgu.msm.io.output.ResultsMonitor; +import de.tum.bgu.msm.matsim.noise.NoiseModel; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.utils.SiloUtil; +import org.apache.log4j.Logger; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; + +public class SiloMucNoise { + + private final static Logger logger = Logger.getLogger(SiloMuc.class); + + public static void main(String[] args) { + + Properties properties = SiloUtil.siloInitialization(args[0]); + + Config config = null; + if (args.length > 1 && args[1] != null) { + config = ConfigUtils.loadConfig(args[1]); + } + logger.info("Started SILO land use model for the Munich Metropolitan Area"); + NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); + DataBuilderNoise.read(properties, dataContainer); + ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, config); + modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); + ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); + SiloModel model = new SiloModel(properties, dataContainer, modelContainer, resultsMonitor); + model.runModel(); + logger.info("Finished SILO."); + } +} diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java new file mode 100644 index 000000000..bcdeb16d7 --- /dev/null +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -0,0 +1,57 @@ +package de.tum.bgu.msm.transportModel.matsim; + +import de.tum.bgu.msm.SiloModel; +import de.tum.bgu.msm.container.ModelContainer; +import de.tum.bgu.msm.io.ResultsMonitorMuc; +import de.tum.bgu.msm.io.output.ResultsMonitor; +import de.tum.bgu.msm.matsim.noise.NoiseModel; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.scenarios.noise.DataBuilderNoise; +import de.tum.bgu.msm.scenarios.noise.ModelBuilderMucNoise; +import de.tum.bgu.msm.scenarios.noise.NoiseDataContainerImpl; +import de.tum.bgu.msm.utils.SiloUtil; +import org.apache.log4j.Logger; +import org.junit.Rule; +import org.junit.Test; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; +import org.matsim.testcases.MatsimTestUtils; + +import java.io.File; + +public class SiloNoiseTest { + + @Rule + public MatsimTestUtils utils = new MatsimTestUtils(); + + private static final Logger log = Logger.getLogger(SiloMatsimMucTest.class); + + @Test + public final void testMain() { + + String path = "./test/muc/siloMatsimMucTest.properties"; + Config config = ConfigUtils.loadConfig("./test/muc/matsim_input/config.xml") ; + + try { + utils.initWithoutJUnitForFixture(this.getClass(), this.getClass().getMethod("testMain", null)); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } + + File dir = new File("./test/muc/scenOutput/test/"); + + config.global().setNumberOfThreads(1); + config.parallelEventHandling().setNumberOfThreads(1); + config.qsim().setNumberOfThreads(1); + + Properties properties = SiloUtil.siloInitialization(path); + + NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); + DataBuilderNoise.read(properties, dataContainer); + ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); + modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); + ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); + SiloModel model = new SiloModel(properties, dataContainer, modelContainer, resultsMonitor); + model.runModel(); + } +} diff --git a/useCases/pom.xml b/useCases/pom.xml index e86f1e8d4..52c939ca1 100644 --- a/useCases/pom.xml +++ b/useCases/pom.xml @@ -241,6 +241,6 @@ ${buildNumber} false 2.9.5 - 11.0 + 12.0-SNAPSHOT From a64d79e49c63b1e434ea904e0710336076df782b Mon Sep 17 00:00:00 2001 From: Nico Date: Wed, 6 Nov 2019 14:07:37 +0100 Subject: [PATCH 04/24] updates on noise feedback --- extensions/matsim2silo/pom.xml | 5 + .../msm/matsim/noise/NoiseDataManager.java | 7 +- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 1 + .../msm/scenarios/noise/DataBuilderNoise.java | 2 +- .../scenarios/noise/HousingStrategyNoise.java | 408 ++++++++++++++++++ .../scenarios/noise/ModelBuilderMucNoise.java | 12 +- .../noise/NoiseDataContainerImpl.java | 26 +- .../scenarios/noise/NoiseDwellingWriter.java | 68 +++ ...NoiseSensitiveDwellingUtilityStrategy.java | 14 + .../bgu/msm/scenarios/noise/SiloMucNoise.java | 1 - 10 files changed, 534 insertions(+), 10 deletions(-) create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java diff --git a/extensions/matsim2silo/pom.xml b/extensions/matsim2silo/pom.xml index e86182287..0afff3637 100644 --- a/extensions/matsim2silo/pom.xml +++ b/extensions/matsim2silo/pom.xml @@ -15,6 +15,11 @@ noise ${matsimVersion} + + org.matsim.contrib + dvrp + ${matsimVersion} + 12.0-SNAPSHOT diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java index 145180950..cf1aab1a1 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java @@ -2,6 +2,7 @@ import de.tum.bgu.msm.data.dwelling.Dwelling; import de.tum.bgu.msm.data.dwelling.DwellingData; +import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.simulator.UpdateListener; import org.matsim.api.core.v01.Id; import org.matsim.contrib.noise.NoiseReceiverPoint; @@ -13,9 +14,11 @@ public class NoiseDataManager implements UpdateListener { private final NoiseReceiverPoints noiseReceiverPoints; private final DwellingData dwellingData; + private final Properties properties; - public NoiseDataManager(DwellingData dwellingData) { + public NoiseDataManager(DwellingData dwellingData, Properties properties) { this.dwellingData = dwellingData; + this.properties = properties; this.noiseReceiverPoints = new NoiseReceiverPoints(); } @@ -26,12 +29,10 @@ public void setup() { @Override public void prepareYear(int year) { - } @Override public void endYear(int year) { - } @Override diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index e3827a879..987c0c8a9 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -34,6 +34,7 @@ public void prepareYear(int year) { } private void updateNoiseImmissions() { + logger.info("Updating noise immisisons."); //Transport model ran at end of last year final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); int counter65 = 0; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java index b4410ecae..822691b74 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java @@ -74,7 +74,7 @@ householdData, dwellingData, new PersonFactoryMuc(), DataContainerWithSchools delegate = new DataContainerWithSchoolsImpl(geoData, realEstateDataManager, jobDataManager, householdDataManager, travelTimes, accessibility, commutingTimeProbability, schoolData, properties); - return new NoiseDataContainerImpl(delegate, new NoiseDataManager(dwellingData)); + return new NoiseDataContainerImpl(delegate, new NoiseDataManager(dwellingData, properties), properties); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java new file mode 100644 index 000000000..e720311db --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java @@ -0,0 +1,408 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.container.DataContainer; +import de.tum.bgu.msm.data.Region; +import de.tum.bgu.msm.data.Zone; +import de.tum.bgu.msm.data.accessibility.Accessibility; +import de.tum.bgu.msm.data.accessibility.CommutingTimeProbability; +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; +import de.tum.bgu.msm.data.dwelling.RealEstateDataManagerImpl; +import de.tum.bgu.msm.data.geo.GeoData; +import de.tum.bgu.msm.data.household.*; +import de.tum.bgu.msm.data.job.JobDataManager; +import de.tum.bgu.msm.data.job.JobMuc; +import de.tum.bgu.msm.data.person.Nationality; +import de.tum.bgu.msm.data.person.Occupation; +import de.tum.bgu.msm.data.person.Person; +import de.tum.bgu.msm.data.travelTimes.TravelTimes; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; +import de.tum.bgu.msm.matsim.noise.NoiseModel; +import de.tum.bgu.msm.models.relocation.DwellingUtilityStrategy; +import de.tum.bgu.msm.models.relocation.HousingStrategyMuc; +import de.tum.bgu.msm.models.relocation.RegionUtilityStrategyMuc; +import de.tum.bgu.msm.models.relocation.moves.DwellingProbabilityStrategy; +import de.tum.bgu.msm.models.relocation.moves.HousingStrategy; +import de.tum.bgu.msm.models.relocation.moves.RegionProbabilityStrategy; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.util.matrices.IndexedDoubleMatrix1D; +import org.apache.log4j.Logger; +import org.matsim.api.core.v01.TransportMode; + +import java.util.EnumMap; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.atomic.LongAdder; + +import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; + +public class HousingStrategyNoise implements HousingStrategy { + + private final static Logger logger = Logger.getLogger(HousingStrategyMuc.class); + + private enum Normalizer { + /** + * Use share of empty dwellings to calculate attraction of region + */ + SHARE_VAC_DD, + /** + * Multiply utility of every region by number of vacant dwellings + * to steer households towards available dwellings + * use number of vacant dwellings to calculate attraction of region + */ + VAC_DD, + DAMPENED_VAC_RATE, + POPULATION, + POWER_OF_POPULATION + } + + private static final Normalizer NORMALIZER = Normalizer.POWER_OF_POPULATION; + + private final DataContainer dataContainer; + private final Properties properties; + private final CommutingTimeProbability commutingTimeProbability; + private final Accessibility accessibility; + private final GeoData geoData; + private final RealEstateDataManager realEstateDataManager; + + private final TravelTimes travelTimes; + + private final DwellingProbabilityStrategy dwellingProbabilityStrategy; + private final DwellingUtilityStrategy dwellingUtilityStrategy; + + private final RegionUtilityStrategyMuc regionUtilityStrategyMuc; + private final RegionProbabilityStrategy regionProbabilityStrategy; + + private final NoiseModel noiseModel; + + private static final double MEDIUM_NOISE_DISCOUNT = 0.056; + private static final double LOUD_NOISE_DISCOUNT = 0.096; + + private final LongAdder totalVacantDd = new LongAdder(); + + private IndexedDoubleMatrix1D regionalShareForeigners; + private IndexedDoubleMatrix1D hhByRegion; + + private EnumMap>> utilityByIncomeByNationalityByRegion = new EnumMap<>(IncomeCategory.class); + + public HousingStrategyNoise(DataContainer dataContainer, + Properties properties, + TravelTimes travelTimes, + DwellingProbabilityStrategy dwellingProbabilityStrategy, + DwellingUtilityStrategy dwellingUtilityStrategy, + RegionUtilityStrategyMuc regionUtilityStrategyMuc, + RegionProbabilityStrategy regionProbabilityStrategy, + NoiseModel noiseModel) { + this.dataContainer = dataContainer; + this.properties = properties; + this.commutingTimeProbability = dataContainer.getCommutingTimeProbability(); + this.accessibility = dataContainer.getAccessibility(); + this.geoData = dataContainer.getGeoData(); + this.realEstateDataManager = dataContainer.getRealEstateDataManager(); + this.travelTimes = travelTimes; + this.dwellingProbabilityStrategy = dwellingProbabilityStrategy; + this.dwellingUtilityStrategy = dwellingUtilityStrategy; + this.regionUtilityStrategyMuc = regionUtilityStrategyMuc; + this.regionProbabilityStrategy = regionProbabilityStrategy; + this.noiseModel = noiseModel; + } + + @Override + public void setup() { + regionalShareForeigners = new IndexedDoubleMatrix1D(geoData.getRegions().values()); + hhByRegion = new IndexedDoubleMatrix1D(geoData.getRegions().values()); + } + + @Override + public boolean isHouseholdEligibleToLiveHere(Household household, Dwelling dd) { + return true; + } + + @Override + public double calculateHousingUtility(Household hh, Dwelling dd) { + double ddQualityUtility = convertQualityToUtility(dd.getQuality()); + double ddSizeUtility = convertAreaToUtility(dd.getBedrooms()); + double ddAutoAccessibilityUtility = convertAccessToUtility(accessibility.getAutoAccessibilityForZone(geoData.getZones().get(dd.getZoneId()))); + double transitAccessibilityUtility = convertAccessToUtility(accessibility.getTransitAccessibilityForZone(geoData.getZones().get(dd.getZoneId()))); + HouseholdType ht = hh.getHouseholdType(); + int priceOld = dd.getPrice(); + int price = dd.getPrice(); + + final double noiseImmission = ((NoiseDwelling) dd).getNoiseImmission(); + if(noiseImmission > 55) { + if(noiseImmission > 65) { + price *= (1 - LOUD_NOISE_DISCOUNT); + } else { + price *= (1 - MEDIUM_NOISE_DISCOUNT); + } + } + double ddPriceUtilityOld = convertPriceToUtility(priceOld, ht.getIncomeCategory()); + double ddPriceUtility = convertPriceToUtility(price, ht.getIncomeCategory()); + + //currently this is re-filtering persons to find workers (it was done previously in select region) + // This way looks more flexible to account for other trips, such as education, though. + + double travelCostUtility = 1; //do not have effect at the moment; + + double workDistanceUtility = 1; + JobDataManager jobDataManager = dataContainer.getJobDataManager(); + + double carToWorkersRatio = Math.min(1., ((double) hh.getAutos() / HouseholdUtil.getNumberOfWorkers(hh))); + double factorForThisZone; + for (Person pp : hh.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); + + if(carToWorkersRatio == 0.) { + int ptTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + factorForThisZone = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); + } else if( carToWorkersRatio == 1.) { + int carTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); + factorForThisZone = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); + } else { + int carTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); + int ptTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + double factorCar = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); + double factorPt = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); + + factorForThisZone= factorCar * carToWorkersRatio + (1 - carToWorkersRatio) * factorPt; + } + + /* if(MovesModelImpl.track) { + Zone workZone = geoData.getZones().get(workLocation.getZoneId()); + int transitTimeIndiv = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + final double skimTime = travelTimes.getPeakSkim(TransportMode.car).getIndexed(dd.getZoneId(), workLocation.getZoneId()); + int expectedCommuteTime_FixedQueryTime = (int) travelTimes.getTravelTime(dd, workLocation, properties.transportModel.peakHour_s, TransportMode.car); + int expectedCommuteTime_FixedZone = (int) travelTimes.getTravelTime(ddZone, workZone, workLocation.getStartTimeInSeconds(), TransportMode.car); + int transitTimeIndiv_fixedQueryTime = (int) travelTimes.getTravelTime(dd, workLocation, properties.transportModel.peakHour_s, TransportMode.pt); + int transitTimeIndiv_fixedZone = (int) travelTimes.getTravelTime(ddZone, workZone, workLocation.getStartTimeInSeconds(), TransportMode.pt); + + int transitTimeSkim = (int) travelTimes.getPeakSkim(TransportMode.pt).getIndexed(dd.getZoneId(), workLocation.getZoneId()); + + try { + fileWriter.write(pp.getId()+"," + +hh.getId()+"," + +dd.getId()+"," + +workLocation.getId()+"," + +workLocation.getCoordinate().getX()+"," + +workLocation.getCoordinate().getY()+"," + +dd.getCoordinate().getX()+"," + +dd.getCoordinate().getY()+"," + +workLocation.getZoneId()+"," + +dd.getZoneId()+"," + +expectedCommuteTime+"," + +skimTime+"," + +workLocation.getStartTimeInSeconds()+"," + +workDistanceUtility +"," + +ddZone.getArea_sqmi() +"," + +workZone.getArea_sqmi() +"," + +expectedCommuteTime_FixedQueryTime +"," + +expectedCommuteTime_FixedZone + "," + +transitTimeSkim+"," + +transitTimeIndiv+"," + +transitTimeIndiv_fixedQueryTime+"," + +transitTimeIndiv_fixedZone + +"\n"); + } catch (IOException e) { + e.printStackTrace(); + } + }*/ + workDistanceUtility *= factorForThisZone; + } + } + return dwellingUtilityStrategy.calculateSelectDwellingUtility(ht, ddSizeUtility, ddPriceUtility, + ddQualityUtility, ddAutoAccessibilityUtility, + transitAccessibilityUtility, workDistanceUtility); + } + + @Override + public double calculateSelectDwellingProbability(double util) { + return dwellingProbabilityStrategy.calculateSelectDwellingProbability(util); + } + + @Override + public double calculateSelectRegionProbability(double util) { + return regionProbabilityStrategy.calculateSelectRegionProbability(util); + } + + @Override + public void prepareYear() { + logger.info("Calculating regional utilities"); + calculateShareOfForeignersByZoneAndRegion(); + totalVacantDd.reset(); + final Map rentsByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); + for (IncomeCategory incomeCategory : IncomeCategory.values()) { + EnumMap> utilityByNationalityByRegion = new EnumMap<>(Nationality.class); + for (Nationality nationality : Nationality.values()) { + Map regionUtils = new LinkedHashMap<>(); + for (Region region : geoData.getRegions().values()) { + final int averageRegionalRent = rentsByRegion.get(region.getId()).intValue(); + final float regAcc = (float) convertAccessToUtility(accessibility.getRegionalAccessibility(region)); + float priceUtil = (float) convertPriceToUtility(averageRegionalRent, incomeCategory); + + + double utility = regionUtilityStrategyMuc.calculateRegionUtility(incomeCategory, + nationality, priceUtil, regAcc, (float) regionalShareForeigners.getIndexed(region.getId())); + switch (NORMALIZER) { + case POPULATION: + utility *= hhByRegion.getIndexed(region.getId()); + break; + case POWER_OF_POPULATION: + utility *= Math.pow(hhByRegion.getIndexed(region.getId()), 0.5); + break; + default: + //do nothing. + } + regionUtils.put(region, utility); + } + utilityByNationalityByRegion.put(nationality, regionUtils); + } + utilityByIncomeByNationalityByRegion.put(incomeCategory, utilityByNationalityByRegion); + } + + if(NORMALIZER == HousingStrategyNoise.Normalizer.SHARE_VAC_DD) { + RealEstateDataManager realEstateDataManager = dataContainer.getRealEstateDataManager(); + for (int region : geoData.getRegions().keySet()) { + totalVacantDd.add(realEstateDataManager.getNumberOfVacantDDinRegion(region)); + } + } + } + + @Override + public double calculateRegionalUtility(Household household, Region region) { + + JobDataManager jobDataManager = dataContainer.getJobDataManager(); + double thisRegionFactor = 1; + double carToWorkersRatio = Math.min(1., ((double) household.getAutos() / HouseholdUtil.getNumberOfWorkers(household))); + + for (Person pp : household.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + final JobMuc job = (JobMuc) jobDataManager.getJobFromId(pp.getJobId()); + Zone workZone = geoData.getZones().get(job.getZoneId()); + if(carToWorkersRatio <= 0.) { + int ptTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.pt); + thisRegionFactor = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); + } else if( carToWorkersRatio >= 1.) { + int carTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.car); + thisRegionFactor = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); + } else { + int carTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.car); + int ptTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.pt); + double factorCar = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); + double factorPt = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); + + thisRegionFactor= factorCar * carToWorkersRatio + (1 - carToWorkersRatio) * factorPt; + } + } + } + + HouseholdType ht = household.getHouseholdType(); + Nationality nationality = ((HouseholdMuc) household).getNationality(); + double baseUtil = utilityByIncomeByNationalityByRegion.get(ht.getIncomeCategory()).get(nationality).get(region); + + baseUtil *= thisRegionFactor; + + // todo: adjust probabilities to make that households tend to move shorter distances (dist to work is already represented) + return normalize(region, baseUtil); + } + + private double normalize(Region region, double baseUtil) { + switch (NORMALIZER) { + case SHARE_VAC_DD: { + return baseUtil * ((float) realEstateDataManager.getNumberOfVacantDDinRegion(region.getId()) / totalVacantDd.doubleValue()); + } + case VAC_DD: { + return baseUtil * realEstateDataManager.getNumberOfVacantDDinRegion(region.getId()); + } + case DAMPENED_VAC_RATE: { + int key = region.getId(); + double x = (double) realEstateDataManager.getNumberOfVacantDDinRegion(key) / + (double) realEstateDataManager.getNumberOfVacantDDinRegion(key) * 100d; // % vacancy + double y = 1.4186E-03 * Math.pow(x, 3) - 6.7846E-02 * Math.pow(x, 2) + 1.0292 * x + 4.5485E-03; + y = Math.min(5d, y); // % vacancy assumed to be ready to move in + if (realEstateDataManager.getNumberOfVacantDDinRegion(key) < 1) { + return 0.; + } + return baseUtil * (y / 100d * realEstateDataManager.getNumberOfVacantDDinRegion(key)); + + } + case POPULATION: { + //Is already included in the base util + return baseUtil; + } + case POWER_OF_POPULATION: { + //Is already included in the base util + return baseUtil; + } + default: + return baseUtil; + } + } + + @Override + public HousingStrategy duplicate() { + TravelTimes travelTimes = this.travelTimes.duplicate(); + final HousingStrategyNoise housingStrategy = new HousingStrategyNoise(dataContainer, properties, travelTimes, dwellingProbabilityStrategy, dwellingUtilityStrategy, regionUtilityStrategyMuc, regionProbabilityStrategy, noiseModel); + housingStrategy.regionalShareForeigners = this.regionalShareForeigners; + housingStrategy.hhByRegion = this.hhByRegion; + housingStrategy.utilityByIncomeByNationalityByRegion = this.utilityByIncomeByNationalityByRegion; + return housingStrategy; + } + + private double convertPriceToUtility(int price, IncomeCategory incCategory) { + + Map shares = dataContainer.getRealEstateDataManager().getRentPaymentsForIncomeGroup(incCategory); + // 25 rent categories are defined as , see RealEstateDataManager + int priceCategory = (int) (price / 200f); + priceCategory = Math.min(priceCategory, RENT_CATEGORIES); + double util = 0; + for (int i = 0; i <= priceCategory; i++) { + util += shares.get(i); + } + // invert utility, as lower price has higher utility + return Math.max(0, 1.f - util); + } + + private double convertQualityToUtility(int quality) { + return (float) quality / (float) properties.main.qualityLevels; + } + + //TODO: convertAreaToUtility method name is wrong. + //TODO: implement method to calculate housing utility with area instead of number of rooms + private double convertAreaToUtility(int area) { + return (float) area / (float) RealEstateDataManagerImpl.largestNoBedrooms; + } + + private double convertAccessToUtility(double accessibility) { + return accessibility / 100f; + } + + private void calculateShareOfForeignersByZoneAndRegion() { + final IndexedDoubleMatrix1D hhByZone = new IndexedDoubleMatrix1D(geoData.getZones().values()); + regionalShareForeigners.assign(0); + hhByRegion.assign(0); + for (Household hh : dataContainer.getHouseholdDataManager().getHouseholds()) { + int zone = -1; + Dwelling dwelling = dataContainer.getRealEstateDataManager().getDwelling(hh.getDwellingId()); + if (dwelling != null) { + zone = dwelling.getZoneId(); + } + final int region = geoData.getZones().get(zone).getRegion().getId(); + hhByZone.setIndexed(zone, hhByZone.getIndexed(zone) + 1); + hhByRegion.setIndexed(region, hhByRegion.getIndexed(region) + 1); + + if (((HouseholdMuc) hh).getNationality() != Nationality.GERMAN) { + regionalShareForeigners.setIndexed(region, regionalShareForeigners.getIndexed(region) + 1); + } + } + + regionalShareForeigners.assign(hhByRegion, (foreignerShare, numberOfHouseholds) -> { + if (numberOfHouseholds > 0) { + return foreignerShare / numberOfHouseholds; + } else { + return 0; + } + }); + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java index f5b55344e..402b8c539 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -9,6 +9,7 @@ import de.tum.bgu.msm.matsim.MatsimTransportModel; import de.tum.bgu.msm.matsim.SimpleMatsimScenarioAssembler; import de.tum.bgu.msm.matsim.ZoneConnectorManager; +import de.tum.bgu.msm.matsim.noise.NoiseModel; import de.tum.bgu.msm.matsim.noise.NoiseScenarioAssembler; import de.tum.bgu.msm.mito.MitoMatsimScenarioAssembler; import de.tum.bgu.msm.models.EducationModelMuc; @@ -66,7 +67,7 @@ public class ModelBuilderMucNoise { - public static ModelContainer getModelContainerForMuc(DataContainerWithSchools dataContainer, Properties properties, Config config) { + public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl dataContainer, Properties properties, Config config) { PersonFactory ppFactory = dataContainer.getHouseholdDataManager().getPersonFactory(); HouseholdFactory hhFactory = dataContainer.getHouseholdDataManager().getHouseholdFactory(); @@ -78,13 +79,16 @@ public static ModelContainer getModelContainerForMuc(DataContainerWithSchools da DeathModel deathModel = new DeathModelImpl(dataContainer, properties, new DefaultDeathStrategy(), SiloUtil.provideNewRandom()); + final NoiseModel noiseModel = new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom()); + + MovesModelImpl movesModel = new MovesModelImpl( dataContainer, properties, new DefaultMovesStrategy(), - new HousingStrategyMuc(dataContainer, + new HousingStrategyNoise(dataContainer, properties, dataContainer.getTravelTimes(), new DefaultDwellingProbabilityStrategy(), - new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), new RegionProbabilityStrategyImpl()), SiloUtil.provideNewRandom()); + new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), new RegionProbabilityStrategyImpl(), noiseModel), SiloUtil.provideNewRandom()); CreateCarOwnershipModel carOwnershipModel = new CreateCarOwnershipModelMuc(dataContainer); @@ -154,7 +158,7 @@ public static ModelContainer getModelContainerForMuc(DataContainerWithSchools da constructionOverwrite, inOutMigration, movesModel, transportModel); modelContainer.registerModelUpdateListener(new UpdateCarOwnershipModelMuc(dataContainer, properties, SiloUtil.provideNewRandom())); - + modelContainer.registerModelUpdateListener(noiseModel); return modelContainer; } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java index ef4aafc18..60ef0c77e 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java @@ -8,6 +8,7 @@ import de.tum.bgu.msm.data.job.JobDataManager; import de.tum.bgu.msm.data.travelTimes.TravelTimes; import de.tum.bgu.msm.matsim.noise.NoiseDataManager; +import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.schools.SchoolData; @@ -15,12 +16,17 @@ public class NoiseDataContainerImpl implements de.tum.bgu.msm.matsim.noise.Noise private final DataContainerWithSchools delegate; private final NoiseDataManager noiseDataManager; + private final Properties properties; - public NoiseDataContainerImpl(DataContainerWithSchools delegate, NoiseDataManager noiseDataManager) { + public NoiseDataContainerImpl(DataContainerWithSchools delegate, + NoiseDataManager noiseDataManager, + Properties properties) { this.delegate = delegate; this.noiseDataManager = noiseDataManager; + this.properties = properties; } + @Override public SchoolData getSchoolData() { return delegate.getSchoolData(); } @@ -63,21 +69,39 @@ public CommutingTimeProbability getCommutingTimeProbability() { @Override public void setup() { delegate.setup(); + noiseDataManager.setup(); } @Override public void prepareYear(int year) { delegate.prepareYear(year); + noiseDataManager.setup(); + if (properties.transportModel.transportModelYears.contains(year)) { + writeDwellingsWithNoise(year); + } + } + + private void writeDwellingsWithNoise(int year) { + final String outputDirectory = properties.main.baseDirectory + "scenOutput/" + properties.main.scenarioName +"/"; + String filedd = outputDirectory + + properties.realEstate.dwellingsFinalFileName + + "Noise_" + + year + + ".csv"; + new NoiseDwellingWriter(this).writeDwellings(filedd); } @Override public void endYear(int year) { delegate.endYear(year); + noiseDataManager.setup(); } @Override public void endSimulation() { delegate.endSimulation(); + noiseDataManager.endSimulation(); + writeDwellingsWithNoise(properties.main.endYear); } @Override diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java new file mode 100644 index 000000000..01572eb02 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java @@ -0,0 +1,68 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; +import de.tum.bgu.msm.io.output.DefaultDwellingWriter; +import de.tum.bgu.msm.io.output.DwellingWriter; +import de.tum.bgu.msm.matsim.noise.NoiseDataContainer; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; +import de.tum.bgu.msm.utils.SiloUtil; +import org.apache.log4j.Logger; + +import java.io.PrintWriter; + +public class NoiseDwellingWriter implements DwellingWriter { + + public NoiseDwellingWriter(NoiseDataContainer noiseDataContainer) { + this.realEstateDataManager = noiseDataContainer.getRealEstateDataManager(); + } + + private final static Logger logger = Logger.getLogger(DefaultDwellingWriter.class); + private final RealEstateDataManager realEstateDataManager; + + public NoiseDwellingWriter(RealEstateDataManager realEstateDataManager) { + this.realEstateDataManager = realEstateDataManager; + } + + @Override + public void writeDwellings(String path) { + logger.info(" Writing dwelling file to " + path); + PrintWriter pwd = SiloUtil.openFileForSequentialWriting(path, false); + pwd.print("id,zone,type,hhID,bedrooms,quality,monthlyCost,yearBuilt,coordX,coordY,noise"); + pwd.println(); + + for (Dwelling dd : realEstateDataManager.getDwellings()) { + pwd.print(dd.getId()); + pwd.print(","); + pwd.print(dd.getZoneId()); + pwd.print(",\""); + pwd.print(dd.getType()); + pwd.print("\","); + pwd.print(dd.getResidentId()); + pwd.print(","); + pwd.print(dd.getBedrooms()); + pwd.print(","); + pwd.print(dd.getQuality()); + pwd.print(","); + pwd.print(dd.getPrice()); + pwd.print(","); + pwd.print(dd.getYearBuilt()); + pwd.print(","); + if(dd.getCoordinate() != null) { + pwd.print(dd.getCoordinate().x); + pwd.print(","); + pwd.print(dd.getCoordinate().y); + } else { + pwd.print("NULL,NULL"); + } + pwd.print(","); + pwd.print(((NoiseDwelling)dd).getNoiseImmission()); + pwd.println(); + if (dd.getId() == SiloUtil.trackDd) { + SiloUtil.trackingFile("Writing dd " + dd.getId() + " to micro data file."); + SiloUtil.trackWriter.println(dd.toString()); + } + } + pwd.close(); + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java new file mode 100644 index 000000000..227129479 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java @@ -0,0 +1,14 @@ +package de.tum.bgu.msm.scenarios.noise; + +/** + * This relocation model is based on a stated preference study by J.D. Hunt + * + * Hunt J.D. (2010) Stated Preference Examination of Factors Influencing Residential Attraction. + * In: Pagliara F., Preston J., Simmonds D. (eds) Residential Location Choice. + * Advances in Spatial Science (The Regional Science Series). + * Springer, Berlin, Heidelberg + */ +public class NoiseSensitiveDwellingUtilityStrategy { + + +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java index 5970365ac..d5fc876aa 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java @@ -29,7 +29,6 @@ public static void main(String[] args) { NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); DataBuilderNoise.read(properties, dataContainer); ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, config); - modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); SiloModel model = new SiloModel(properties, dataContainer, modelContainer, resultsMonitor); model.runModel(); From 8acf1f3b2bc8dfcdd8b9040dd29ef94fee16fa4d Mon Sep 17 00:00:00 2001 From: Nico Date: Wed, 6 Nov 2019 21:51:38 +0100 Subject: [PATCH 05/24] updates on noise feedback, add relocation strategy --- .../scenarios/noise/HousingStrategyNoise.java | 408 ------------------ ...NoiseSensitiveDwellingUtilityStrategy.java | 286 ++++++++++++ .../HuntNoiseSensitiveMovesStrategy.java | 10 + .../scenarios/noise/ModelBuilderMucNoise.java | 27 +- .../noise/NoiseDataContainerImpl.java | 2 +- ...NoiseSensitiveDwellingUtilityStrategy.java | 14 - .../bgu/msm/scenarios/noise/SiloMucNoise.java | 3 +- .../matsim/SiloMatsimMucTest.java | 1 - 8 files changed, 315 insertions(+), 436 deletions(-) delete mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveMovesStrategy.java delete mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java deleted file mode 100644 index e720311db..000000000 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HousingStrategyNoise.java +++ /dev/null @@ -1,408 +0,0 @@ -package de.tum.bgu.msm.scenarios.noise; - -import de.tum.bgu.msm.container.DataContainer; -import de.tum.bgu.msm.data.Region; -import de.tum.bgu.msm.data.Zone; -import de.tum.bgu.msm.data.accessibility.Accessibility; -import de.tum.bgu.msm.data.accessibility.CommutingTimeProbability; -import de.tum.bgu.msm.data.dwelling.Dwelling; -import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; -import de.tum.bgu.msm.data.dwelling.RealEstateDataManagerImpl; -import de.tum.bgu.msm.data.geo.GeoData; -import de.tum.bgu.msm.data.household.*; -import de.tum.bgu.msm.data.job.JobDataManager; -import de.tum.bgu.msm.data.job.JobMuc; -import de.tum.bgu.msm.data.person.Nationality; -import de.tum.bgu.msm.data.person.Occupation; -import de.tum.bgu.msm.data.person.Person; -import de.tum.bgu.msm.data.travelTimes.TravelTimes; -import de.tum.bgu.msm.matsim.noise.NoiseDwelling; -import de.tum.bgu.msm.matsim.noise.NoiseModel; -import de.tum.bgu.msm.models.relocation.DwellingUtilityStrategy; -import de.tum.bgu.msm.models.relocation.HousingStrategyMuc; -import de.tum.bgu.msm.models.relocation.RegionUtilityStrategyMuc; -import de.tum.bgu.msm.models.relocation.moves.DwellingProbabilityStrategy; -import de.tum.bgu.msm.models.relocation.moves.HousingStrategy; -import de.tum.bgu.msm.models.relocation.moves.RegionProbabilityStrategy; -import de.tum.bgu.msm.properties.Properties; -import de.tum.bgu.msm.util.matrices.IndexedDoubleMatrix1D; -import org.apache.log4j.Logger; -import org.matsim.api.core.v01.TransportMode; - -import java.util.EnumMap; -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.Objects; -import java.util.concurrent.atomic.LongAdder; - -import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; - -public class HousingStrategyNoise implements HousingStrategy { - - private final static Logger logger = Logger.getLogger(HousingStrategyMuc.class); - - private enum Normalizer { - /** - * Use share of empty dwellings to calculate attraction of region - */ - SHARE_VAC_DD, - /** - * Multiply utility of every region by number of vacant dwellings - * to steer households towards available dwellings - * use number of vacant dwellings to calculate attraction of region - */ - VAC_DD, - DAMPENED_VAC_RATE, - POPULATION, - POWER_OF_POPULATION - } - - private static final Normalizer NORMALIZER = Normalizer.POWER_OF_POPULATION; - - private final DataContainer dataContainer; - private final Properties properties; - private final CommutingTimeProbability commutingTimeProbability; - private final Accessibility accessibility; - private final GeoData geoData; - private final RealEstateDataManager realEstateDataManager; - - private final TravelTimes travelTimes; - - private final DwellingProbabilityStrategy dwellingProbabilityStrategy; - private final DwellingUtilityStrategy dwellingUtilityStrategy; - - private final RegionUtilityStrategyMuc regionUtilityStrategyMuc; - private final RegionProbabilityStrategy regionProbabilityStrategy; - - private final NoiseModel noiseModel; - - private static final double MEDIUM_NOISE_DISCOUNT = 0.056; - private static final double LOUD_NOISE_DISCOUNT = 0.096; - - private final LongAdder totalVacantDd = new LongAdder(); - - private IndexedDoubleMatrix1D regionalShareForeigners; - private IndexedDoubleMatrix1D hhByRegion; - - private EnumMap>> utilityByIncomeByNationalityByRegion = new EnumMap<>(IncomeCategory.class); - - public HousingStrategyNoise(DataContainer dataContainer, - Properties properties, - TravelTimes travelTimes, - DwellingProbabilityStrategy dwellingProbabilityStrategy, - DwellingUtilityStrategy dwellingUtilityStrategy, - RegionUtilityStrategyMuc regionUtilityStrategyMuc, - RegionProbabilityStrategy regionProbabilityStrategy, - NoiseModel noiseModel) { - this.dataContainer = dataContainer; - this.properties = properties; - this.commutingTimeProbability = dataContainer.getCommutingTimeProbability(); - this.accessibility = dataContainer.getAccessibility(); - this.geoData = dataContainer.getGeoData(); - this.realEstateDataManager = dataContainer.getRealEstateDataManager(); - this.travelTimes = travelTimes; - this.dwellingProbabilityStrategy = dwellingProbabilityStrategy; - this.dwellingUtilityStrategy = dwellingUtilityStrategy; - this.regionUtilityStrategyMuc = regionUtilityStrategyMuc; - this.regionProbabilityStrategy = regionProbabilityStrategy; - this.noiseModel = noiseModel; - } - - @Override - public void setup() { - regionalShareForeigners = new IndexedDoubleMatrix1D(geoData.getRegions().values()); - hhByRegion = new IndexedDoubleMatrix1D(geoData.getRegions().values()); - } - - @Override - public boolean isHouseholdEligibleToLiveHere(Household household, Dwelling dd) { - return true; - } - - @Override - public double calculateHousingUtility(Household hh, Dwelling dd) { - double ddQualityUtility = convertQualityToUtility(dd.getQuality()); - double ddSizeUtility = convertAreaToUtility(dd.getBedrooms()); - double ddAutoAccessibilityUtility = convertAccessToUtility(accessibility.getAutoAccessibilityForZone(geoData.getZones().get(dd.getZoneId()))); - double transitAccessibilityUtility = convertAccessToUtility(accessibility.getTransitAccessibilityForZone(geoData.getZones().get(dd.getZoneId()))); - HouseholdType ht = hh.getHouseholdType(); - int priceOld = dd.getPrice(); - int price = dd.getPrice(); - - final double noiseImmission = ((NoiseDwelling) dd).getNoiseImmission(); - if(noiseImmission > 55) { - if(noiseImmission > 65) { - price *= (1 - LOUD_NOISE_DISCOUNT); - } else { - price *= (1 - MEDIUM_NOISE_DISCOUNT); - } - } - double ddPriceUtilityOld = convertPriceToUtility(priceOld, ht.getIncomeCategory()); - double ddPriceUtility = convertPriceToUtility(price, ht.getIncomeCategory()); - - //currently this is re-filtering persons to find workers (it was done previously in select region) - // This way looks more flexible to account for other trips, such as education, though. - - double travelCostUtility = 1; //do not have effect at the moment; - - double workDistanceUtility = 1; - JobDataManager jobDataManager = dataContainer.getJobDataManager(); - - double carToWorkersRatio = Math.min(1., ((double) hh.getAutos() / HouseholdUtil.getNumberOfWorkers(hh))); - double factorForThisZone; - for (Person pp : hh.getPersons().values()) { - if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { - JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); - - if(carToWorkersRatio == 0.) { - int ptTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); - factorForThisZone = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); - } else if( carToWorkersRatio == 1.) { - int carTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); - factorForThisZone = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); - } else { - int carTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); - int ptTime = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); - double factorCar = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); - double factorPt = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); - - factorForThisZone= factorCar * carToWorkersRatio + (1 - carToWorkersRatio) * factorPt; - } - - /* if(MovesModelImpl.track) { - Zone workZone = geoData.getZones().get(workLocation.getZoneId()); - int transitTimeIndiv = (int) travelTimes.getTravelTime(dd, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); - final double skimTime = travelTimes.getPeakSkim(TransportMode.car).getIndexed(dd.getZoneId(), workLocation.getZoneId()); - int expectedCommuteTime_FixedQueryTime = (int) travelTimes.getTravelTime(dd, workLocation, properties.transportModel.peakHour_s, TransportMode.car); - int expectedCommuteTime_FixedZone = (int) travelTimes.getTravelTime(ddZone, workZone, workLocation.getStartTimeInSeconds(), TransportMode.car); - int transitTimeIndiv_fixedQueryTime = (int) travelTimes.getTravelTime(dd, workLocation, properties.transportModel.peakHour_s, TransportMode.pt); - int transitTimeIndiv_fixedZone = (int) travelTimes.getTravelTime(ddZone, workZone, workLocation.getStartTimeInSeconds(), TransportMode.pt); - - int transitTimeSkim = (int) travelTimes.getPeakSkim(TransportMode.pt).getIndexed(dd.getZoneId(), workLocation.getZoneId()); - - try { - fileWriter.write(pp.getId()+"," - +hh.getId()+"," - +dd.getId()+"," - +workLocation.getId()+"," - +workLocation.getCoordinate().getX()+"," - +workLocation.getCoordinate().getY()+"," - +dd.getCoordinate().getX()+"," - +dd.getCoordinate().getY()+"," - +workLocation.getZoneId()+"," - +dd.getZoneId()+"," - +expectedCommuteTime+"," - +skimTime+"," - +workLocation.getStartTimeInSeconds()+"," - +workDistanceUtility +"," - +ddZone.getArea_sqmi() +"," - +workZone.getArea_sqmi() +"," - +expectedCommuteTime_FixedQueryTime +"," - +expectedCommuteTime_FixedZone + "," - +transitTimeSkim+"," - +transitTimeIndiv+"," - +transitTimeIndiv_fixedQueryTime+"," - +transitTimeIndiv_fixedZone - +"\n"); - } catch (IOException e) { - e.printStackTrace(); - } - }*/ - workDistanceUtility *= factorForThisZone; - } - } - return dwellingUtilityStrategy.calculateSelectDwellingUtility(ht, ddSizeUtility, ddPriceUtility, - ddQualityUtility, ddAutoAccessibilityUtility, - transitAccessibilityUtility, workDistanceUtility); - } - - @Override - public double calculateSelectDwellingProbability(double util) { - return dwellingProbabilityStrategy.calculateSelectDwellingProbability(util); - } - - @Override - public double calculateSelectRegionProbability(double util) { - return regionProbabilityStrategy.calculateSelectRegionProbability(util); - } - - @Override - public void prepareYear() { - logger.info("Calculating regional utilities"); - calculateShareOfForeignersByZoneAndRegion(); - totalVacantDd.reset(); - final Map rentsByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); - for (IncomeCategory incomeCategory : IncomeCategory.values()) { - EnumMap> utilityByNationalityByRegion = new EnumMap<>(Nationality.class); - for (Nationality nationality : Nationality.values()) { - Map regionUtils = new LinkedHashMap<>(); - for (Region region : geoData.getRegions().values()) { - final int averageRegionalRent = rentsByRegion.get(region.getId()).intValue(); - final float regAcc = (float) convertAccessToUtility(accessibility.getRegionalAccessibility(region)); - float priceUtil = (float) convertPriceToUtility(averageRegionalRent, incomeCategory); - - - double utility = regionUtilityStrategyMuc.calculateRegionUtility(incomeCategory, - nationality, priceUtil, regAcc, (float) regionalShareForeigners.getIndexed(region.getId())); - switch (NORMALIZER) { - case POPULATION: - utility *= hhByRegion.getIndexed(region.getId()); - break; - case POWER_OF_POPULATION: - utility *= Math.pow(hhByRegion.getIndexed(region.getId()), 0.5); - break; - default: - //do nothing. - } - regionUtils.put(region, utility); - } - utilityByNationalityByRegion.put(nationality, regionUtils); - } - utilityByIncomeByNationalityByRegion.put(incomeCategory, utilityByNationalityByRegion); - } - - if(NORMALIZER == HousingStrategyNoise.Normalizer.SHARE_VAC_DD) { - RealEstateDataManager realEstateDataManager = dataContainer.getRealEstateDataManager(); - for (int region : geoData.getRegions().keySet()) { - totalVacantDd.add(realEstateDataManager.getNumberOfVacantDDinRegion(region)); - } - } - } - - @Override - public double calculateRegionalUtility(Household household, Region region) { - - JobDataManager jobDataManager = dataContainer.getJobDataManager(); - double thisRegionFactor = 1; - double carToWorkersRatio = Math.min(1., ((double) household.getAutos() / HouseholdUtil.getNumberOfWorkers(household))); - - for (Person pp : household.getPersons().values()) { - if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { - final JobMuc job = (JobMuc) jobDataManager.getJobFromId(pp.getJobId()); - Zone workZone = geoData.getZones().get(job.getZoneId()); - if(carToWorkersRatio <= 0.) { - int ptTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.pt); - thisRegionFactor = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); - } else if( carToWorkersRatio >= 1.) { - int carTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.car); - thisRegionFactor = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); - } else { - int carTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.car); - int ptTime = (int) travelTimes.getTravelTimeFromRegion(region, workZone, job.getStartTimeInSeconds(), TransportMode.pt); - double factorCar = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, carTime)); - double factorPt = commutingTimeProbability.getCommutingTimeProbability(Math.max(1, ptTime)); - - thisRegionFactor= factorCar * carToWorkersRatio + (1 - carToWorkersRatio) * factorPt; - } - } - } - - HouseholdType ht = household.getHouseholdType(); - Nationality nationality = ((HouseholdMuc) household).getNationality(); - double baseUtil = utilityByIncomeByNationalityByRegion.get(ht.getIncomeCategory()).get(nationality).get(region); - - baseUtil *= thisRegionFactor; - - // todo: adjust probabilities to make that households tend to move shorter distances (dist to work is already represented) - return normalize(region, baseUtil); - } - - private double normalize(Region region, double baseUtil) { - switch (NORMALIZER) { - case SHARE_VAC_DD: { - return baseUtil * ((float) realEstateDataManager.getNumberOfVacantDDinRegion(region.getId()) / totalVacantDd.doubleValue()); - } - case VAC_DD: { - return baseUtil * realEstateDataManager.getNumberOfVacantDDinRegion(region.getId()); - } - case DAMPENED_VAC_RATE: { - int key = region.getId(); - double x = (double) realEstateDataManager.getNumberOfVacantDDinRegion(key) / - (double) realEstateDataManager.getNumberOfVacantDDinRegion(key) * 100d; // % vacancy - double y = 1.4186E-03 * Math.pow(x, 3) - 6.7846E-02 * Math.pow(x, 2) + 1.0292 * x + 4.5485E-03; - y = Math.min(5d, y); // % vacancy assumed to be ready to move in - if (realEstateDataManager.getNumberOfVacantDDinRegion(key) < 1) { - return 0.; - } - return baseUtil * (y / 100d * realEstateDataManager.getNumberOfVacantDDinRegion(key)); - - } - case POPULATION: { - //Is already included in the base util - return baseUtil; - } - case POWER_OF_POPULATION: { - //Is already included in the base util - return baseUtil; - } - default: - return baseUtil; - } - } - - @Override - public HousingStrategy duplicate() { - TravelTimes travelTimes = this.travelTimes.duplicate(); - final HousingStrategyNoise housingStrategy = new HousingStrategyNoise(dataContainer, properties, travelTimes, dwellingProbabilityStrategy, dwellingUtilityStrategy, regionUtilityStrategyMuc, regionProbabilityStrategy, noiseModel); - housingStrategy.regionalShareForeigners = this.regionalShareForeigners; - housingStrategy.hhByRegion = this.hhByRegion; - housingStrategy.utilityByIncomeByNationalityByRegion = this.utilityByIncomeByNationalityByRegion; - return housingStrategy; - } - - private double convertPriceToUtility(int price, IncomeCategory incCategory) { - - Map shares = dataContainer.getRealEstateDataManager().getRentPaymentsForIncomeGroup(incCategory); - // 25 rent categories are defined as , see RealEstateDataManager - int priceCategory = (int) (price / 200f); - priceCategory = Math.min(priceCategory, RENT_CATEGORIES); - double util = 0; - for (int i = 0; i <= priceCategory; i++) { - util += shares.get(i); - } - // invert utility, as lower price has higher utility - return Math.max(0, 1.f - util); - } - - private double convertQualityToUtility(int quality) { - return (float) quality / (float) properties.main.qualityLevels; - } - - //TODO: convertAreaToUtility method name is wrong. - //TODO: implement method to calculate housing utility with area instead of number of rooms - private double convertAreaToUtility(int area) { - return (float) area / (float) RealEstateDataManagerImpl.largestNoBedrooms; - } - - private double convertAccessToUtility(double accessibility) { - return accessibility / 100f; - } - - private void calculateShareOfForeignersByZoneAndRegion() { - final IndexedDoubleMatrix1D hhByZone = new IndexedDoubleMatrix1D(geoData.getZones().values()); - regionalShareForeigners.assign(0); - hhByRegion.assign(0); - for (Household hh : dataContainer.getHouseholdDataManager().getHouseholds()) { - int zone = -1; - Dwelling dwelling = dataContainer.getRealEstateDataManager().getDwelling(hh.getDwellingId()); - if (dwelling != null) { - zone = dwelling.getZoneId(); - } - final int region = geoData.getZones().get(zone).getRegion().getId(); - hhByZone.setIndexed(zone, hhByZone.getIndexed(zone) + 1); - hhByRegion.setIndexed(region, hhByRegion.getIndexed(region) + 1); - - if (((HouseholdMuc) hh).getNationality() != Nationality.GERMAN) { - regionalShareForeigners.setIndexed(region, regionalShareForeigners.getIndexed(region) + 1); - } - } - - regionalShareForeigners.assign(hhByRegion, (foreignerShare, numberOfHouseholds) -> { - if (numberOfHouseholds > 0) { - return foreignerShare / numberOfHouseholds; - } else { - return 0; - } - }); - } -} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java new file mode 100644 index 000000000..4bcd5a99b --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -0,0 +1,286 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.Region; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingType; +import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; +import de.tum.bgu.msm.data.household.Household; +import de.tum.bgu.msm.data.household.HouseholdUtil; +import de.tum.bgu.msm.data.job.JobDataManager; +import de.tum.bgu.msm.data.job.JobMuc; +import de.tum.bgu.msm.data.person.Occupation; +import de.tum.bgu.msm.data.person.Person; +import de.tum.bgu.msm.data.travelTimes.TravelTimes; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; +import de.tum.bgu.msm.models.relocation.moves.HousingStrategy; +import org.matsim.api.core.v01.TransportMode; + +import java.util.Objects; + +/** + * This relocation model is based on a stated preference study by J.D. Hunt + *

+ * Hunt J.D. (2010) Stated Preference Examination of Factors Influencing Residential Attraction. + * In: Pagliara F., Preston J., Simmonds D. (eds) Residential Location Choice. + * Advances in Spatial Science (The Regional Science Series). + * Springer, Berlin, Heidelberg + * + * @author Nico + */ +public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrategy { + + private static final double MEDIUM_NOISE_DISCOUNT = 0.056; + private static final double LOUD_NOISE_DISCOUNT = 0.096; + + //---------------------------------------------------------------------- + + /** + * Indices: + * [0] Single Family [1] Duplex [2] Townhouse [3] Walkup [4] Highrise + * [0] average + * [1] low inc + * [2] high inc + */ + static double[][] dwellingTypeUtil = { + {0, -1.0570, -1.1130, -1.6340, -1.7940}, + {0, -0.8783, -0.9566, -0.9895, -0.9514}, + {0, -1.0570, -1.1130, -1.6340, -1.7940} + }; + + + //---------------------------------------------------------------------- + + /** + * Indices: + * [0] Never bad [1] Bad 1 day per year [2] Bad 1 day per month [3] Bad 1 day per week + * [0] average + * [1] low inc + * [2] high inc + */ + static double[][] airQualityUtilAvg = { + {0, -0.2446, -0.5092, -0.9796}, + {0, -0.2299, -0.5264, -0.8504}, + {0, -0.3073, -0.2879, -1.3150} + }; + + + /** + * Indices: + * [0] None [1] Occasionally just noticeable [2] Constant faint hum [3] Sometimes Disturbing [4] Frequently disturbing + * [0] average + * [1] low inc + * [2] high inc + */ + static double[][] trafficNoiseUtil = { + {0, -0.1694, -0.7165, -0.5348, -1.35}, + {0, -0.2758, -0.8354, -0.6934, -1.0250}, + {0, -0.3192, -0.9886, -1.0180, -1.8230} + }; + + //---------------------------------------------------------------------- + + //---------------------------------------------------------------------- + + final static double[] rentUtilPer100Increase = {-0.8033, -1.2260, -0.6665}; + + final static double[] travelTimeUtilPer10minIncreaseAvg = {-0.1890, -0.1170, -0.3613}; + + final static double[] travelTimeTransitUtilPer10minIncreaseAvg = {-0.0974, -0.1253, -0.1246}; + + private final TravelTimes travelTimes; + private final JobDataManager jobDataManager; + private final RealEstateDataManager realEstateDataManager; + + //use delegate for regional decisions + private final HousingStrategy delegate; + + public HuntNoiseSensitiveDwellingUtilityStrategy(TravelTimes travelTimes, + JobDataManager jobDataManager, + RealEstateDataManager realEstateDataManager, HousingStrategy delegate) { + this.travelTimes = travelTimes; + this.jobDataManager = jobDataManager; + this.realEstateDataManager = realEstateDataManager; + this.delegate = delegate; + } + + @Override + public void setup() { + delegate.setup(); + } + + @Override + public boolean isHouseholdEligibleToLiveHere(Household household, Dwelling dd) { + int numberOfPersons = household.getHhSize(); + int numberOfBedrooms = dd.getBedrooms(); + return (numberOfBedrooms + 1 >= numberOfPersons); + } + + @Override + public double calculateHousingUtility(Household hh, Dwelling dwelling) { + NoiseDwelling oldDwelling = (NoiseDwelling) realEstateDataManager.getDwelling(hh.getDwellingId()); + if(oldDwelling == null || oldDwelling.equals(dwelling)) { + return calculateCurrentUtility(hh, (NoiseDwelling) dwelling); + } else { + return calculateUtilityAlternative(hh, oldDwelling, (NoiseDwelling) dwelling); + } + } + + @Override + public double calculateSelectDwellingProbability(double util) { + return Math.exp(util); + } + + @Override + public double calculateSelectRegionProbability(double util) { + return delegate.calculateSelectRegionProbability(util); + } + + @Override + public void prepareYear() { + delegate.prepareYear(); + } + + @Override + public double calculateRegionalUtility(Household household, Region region) { + return delegate.calculateRegionalUtility(household, region); + } + + @Override + public HousingStrategy duplicate() { + HuntNoiseSensitiveDwellingUtilityStrategy duplicate = + new HuntNoiseSensitiveDwellingUtilityStrategy(this.travelTimes.duplicate(), + jobDataManager, realEstateDataManager, delegate.duplicate()); + return duplicate; + } + + double calculateUtilityAlternative(Household household, NoiseDwelling oldDwelling, NoiseDwelling newDwelling) { + final double oldPrice = getNoiseAdjustedPrice(oldDwelling); + final double newPrice = getNoiseAdjustedPrice(newDwelling); + + + double oldCarTravelTime = 0; + double oldPtTravelTime = 0; + for (Person pp : household.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); + oldCarTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); + oldPtTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + break; + } + } + + double newCarTravelTime = 0; + double newPtTravelTime = 0; + for (Person pp : household.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); + newCarTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); + newPtTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + break; + } + } + + final double util = calculateUtilityForAlternative(household, newDwelling, newPrice-oldPrice, newCarTravelTime-oldCarTravelTime, newPtTravelTime-oldPtTravelTime); + return util; + } + + private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { + double price = dwelling.getPrice(); + final double noiseImmission = dwelling.getNoiseImmission(); + if (noiseImmission > 55) { + if (noiseImmission > 65) { + price *= (1 - LOUD_NOISE_DISCOUNT); + } else { + price *= (1 - MEDIUM_NOISE_DISCOUNT); + } + } + return price; + } + + double calculateCurrentUtility(Household household, NoiseDwelling dwelling) { + + double price = dwelling.getPrice(); + final double noiseImmission = dwelling.getNoiseImmission(); + if (noiseImmission > 55) { + if (noiseImmission > 65) { + price *= (1 - LOUD_NOISE_DISCOUNT); + } else { + price *= (1 - MEDIUM_NOISE_DISCOUNT); + } + } + + double carTravelTime = 0; + double ptTravelTime = 0; + for (Person pp : household.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); + carTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); + ptTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + break; + } + } + + final double util = calculateUtilityForAlternative(household, dwelling, price, carTravelTime, ptTravelTime); + return util; + } + + private double calculateUtilityForAlternative(Household household, NoiseDwelling dwelling, + double priceDiff, double carTravelTimeDiff, double ptTravelTimeDiff) { + int hhType = translateHouseholdType(household); + int ddType = translateDwellingType(dwelling); + int noiseCat = translateLdenToNoiseCategory(dwelling.getNoiseImmission()); + + double dwellingUtil = dwellingTypeUtil[hhType][ddType]; + double noiseUtil = trafficNoiseUtil[hhType][noiseCat]; + double priceUtil = (priceDiff / 100.) * rentUtilPer100Increase[hhType]; + double carTravelTimeUtil = travelTimeUtilPer10minIncreaseAvg[hhType] * (carTravelTimeDiff / 10.); + double ptTravelTimeUtil = travelTimeTransitUtilPer10minIncreaseAvg[hhType] * (ptTravelTimeDiff / 10.); + final double airQualityUtil = 0; + return dwellingUtil + airQualityUtil + noiseUtil + priceUtil + carTravelTimeUtil + ptTravelTimeUtil; + } + + private int translateDwellingType(Dwelling dwelling) { + final DwellingType type = dwelling.getType(); + + if(type.equals(DefaultDwellingTypeImpl.SFD)) { + return 0; + } else if( type.equals(DefaultDwellingTypeImpl.SFA)) { + return 1; + } else if(type.equals(DefaultDwellingTypeImpl.MF234)) { + return 2; + } else if(type.equals(DefaultDwellingTypeImpl.MF5plus)) { + return 4; + } else { + //can only happen for mobile home which shouldn't exist in muc + return 4; + } + } + + + private int translateLdenToNoiseCategory(double lden) { + if (lden < 30) { + return 0; + } else if (lden < 45) { + return 1; + } else if (lden < 55) { + return 2; + } else if (lden < 65) { + return 3; + } else { + return 4; + } + } + + private int translateHouseholdType(Household household) { + final int annualHhIncome = HouseholdUtil.getAnnualHhIncome(household); + if (annualHhIncome < 20000) { + return 1; + } else if (annualHhIncome < 100000) { + return 0; + } else { + return 2; + } + } +} + diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveMovesStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveMovesStrategy.java new file mode 100644 index 000000000..9fc0f351e --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveMovesStrategy.java @@ -0,0 +1,10 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.models.relocation.moves.MovesStrategy; + +public class HuntNoiseSensitiveMovesStrategy implements MovesStrategy { + @Override + public double getMovingProbability(double avgSatisfaction, double currentUtil) { + return 1 - 1/(1+0.03 * Math.exp(0.5*(avgSatisfaction - currentUtil))); + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java index 402b8c539..51bd28555 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -55,10 +55,7 @@ import de.tum.bgu.msm.models.relocation.InOutMigrationMuc; import de.tum.bgu.msm.models.relocation.RegionUtilityStrategyMucImpl; import de.tum.bgu.msm.models.relocation.migration.InOutMigration; -import de.tum.bgu.msm.models.relocation.moves.DefaultDwellingProbabilityStrategy; -import de.tum.bgu.msm.models.relocation.moves.DefaultMovesStrategy; -import de.tum.bgu.msm.models.relocation.moves.MovesModelImpl; -import de.tum.bgu.msm.models.relocation.moves.RegionProbabilityStrategyImpl; +import de.tum.bgu.msm.models.relocation.moves.*; import de.tum.bgu.msm.models.transportModel.TransportModel; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.schools.DataContainerWithSchools; @@ -82,13 +79,21 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data final NoiseModel noiseModel = new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom()); + HousingStrategy housingStrategyDelegate + = new HousingStrategyMuc(dataContainer, properties, + dataContainer.getTravelTimes(), new DefaultDwellingProbabilityStrategy(), + new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), + new RegionProbabilityStrategyImpl()); + + HuntNoiseSensitiveDwellingUtilityStrategy housingStrategy + = new HuntNoiseSensitiveDwellingUtilityStrategy(dataContainer.getTravelTimes(), + dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), + housingStrategyDelegate); + MovesModelImpl movesModel = new MovesModelImpl( dataContainer, properties, - new DefaultMovesStrategy(), - new HousingStrategyNoise(dataContainer, - properties, - dataContainer.getTravelTimes(), new DefaultDwellingProbabilityStrategy(), - new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), new RegionProbabilityStrategyImpl(), noiseModel), SiloUtil.provideNewRandom()); + new HuntNoiseSensitiveMovesStrategy(), + housingStrategy, SiloUtil.provideNewRandom()); CreateCarOwnershipModel carOwnershipModel = new CreateCarOwnershipModelMuc(dataContainer); @@ -132,13 +137,13 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data switch (properties.transportModel.transportModelIdentifier) { case MITO_MATSIM: MatsimScenarioAssembler delegate = new MitoMatsimScenarioAssembler(dataContainer, properties, new MitoDataConverterMuc()); - scenarioAssembler= new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); + scenarioAssembler = new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); transportModel = new MatsimTransportModel(dataContainer, config, properties, null, ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, scenarioAssembler); break; case MATSIM: delegate = new SimpleMatsimScenarioAssembler(dataContainer, properties); - scenarioAssembler= new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); + scenarioAssembler = new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); transportModel = new MatsimTransportModel(dataContainer, config, properties, null, ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, scenarioAssembler); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java index 60ef0c77e..3b078a26d 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java @@ -76,7 +76,7 @@ public void setup() { public void prepareYear(int year) { delegate.prepareYear(year); noiseDataManager.setup(); - if (properties.transportModel.transportModelYears.contains(year)) { + if (properties.transportModel.transportModelYears.contains(year) || properties.main.startYear == year) { writeDwellingsWithNoise(year); } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java deleted file mode 100644 index 227129479..000000000 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseSensitiveDwellingUtilityStrategy.java +++ /dev/null @@ -1,14 +0,0 @@ -package de.tum.bgu.msm.scenarios.noise; - -/** - * This relocation model is based on a stated preference study by J.D. Hunt - * - * Hunt J.D. (2010) Stated Preference Examination of Factors Influencing Residential Attraction. - * In: Pagliara F., Preston J., Simmonds D. (eds) Residential Location Choice. - * Advances in Spatial Science (The Regional Science Series). - * Springer, Berlin, Heidelberg - */ -public class NoiseSensitiveDwellingUtilityStrategy { - - -} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java index d5fc876aa..9c8accb5b 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java @@ -28,7 +28,8 @@ public static void main(String[] args) { logger.info("Started SILO land use model for the Munich Metropolitan Area"); NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); DataBuilderNoise.read(properties, dataContainer); - ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, config); + ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); +// modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); SiloModel model = new SiloModel(properties, dataContainer, modelContainer, resultsMonitor); model.runModel(); diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java index a23e9df3e..412f50a4f 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java @@ -47,7 +47,6 @@ public class SiloMatsimMucTest { private static final Logger log = Logger.getLogger(SiloMatsimMucTest.class); @Test - @Ignore public final void testMain() { String path = "./test/muc/siloMatsimMucTest.properties"; From d1289457231253e0ae793b5a8f80755614bb8f20 Mon Sep 17 00:00:00 2001 From: Nico Date: Mon, 11 Nov 2019 14:58:58 +0100 Subject: [PATCH 06/24] updates on noise feedback --- .../de/tum/bgu/msm/matsim/MatsimData.java | 6 +- .../bgu/msm/matsim/MatsimTransportModel.java | 7 +- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 61 +++++++++++++-- .../matsim/noise/NoiseScenarioAssembler.java | 78 ++++++++++--------- ...NoiseSensitiveDwellingUtilityStrategy.java | 4 +- .../scenarios/noise/ModelBuilderMucNoise.java | 19 ++--- .../bgu/msm/scenarios/noise/SiloMucNoise.java | 3 +- .../transportModel/matsim/SiloNoiseTest.java | 4 +- .../test/muc/siloMatsimMucTest.properties | 2 +- 9 files changed, 116 insertions(+), 68 deletions(-) diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index d067e821e..5e4d7a77a 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -74,11 +74,11 @@ ZoneConnectorManager getZoneConnectorManager() { return zoneConnectorManager; } - Network getCarNetwork() { + public Network getCarNetwork() { return carNetwork; } - Network getPtNetwork() { + public Network getPtNetwork() { return ptNetwork; } @@ -177,4 +177,6 @@ RaptorParameters getRaptorParameters() { return raptorParameters; } + + } diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java index 85a7df807..d87573ffa 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java @@ -159,9 +159,6 @@ private void runTransportModel(int year) { if (accessibility != null) { setupAccessibility(assembledScenario, controler); } - if(assembledScenario.getScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS) != null) { - controler.addOverridingModule(new NoiseModule()); - } controler.run(); logger.warn("Running MATSim transport model for year " + year + " finished."); @@ -273,4 +270,8 @@ private void updateTravelTimes(TravelTime travelTime, TravelDisutility disutilit dataContainer.getGeoData().getZones().values()); } } + + public MatsimData getMatsimData() { + return matsimData; + } } \ No newline at end of file diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 987c0c8a9..1f83b292e 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -1,13 +1,21 @@ package de.tum.bgu.msm.matsim.noise; import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.matsim.MatsimData; import de.tum.bgu.msm.models.AbstractModel; import de.tum.bgu.msm.models.ModelUpdateListener; import de.tum.bgu.msm.properties.Properties; import org.apache.log4j.Logger; import org.matsim.api.core.v01.Id; +import org.matsim.contrib.noise.NoiseConfigGroup; +import org.matsim.contrib.noise.NoiseOfflineCalculation; import org.matsim.contrib.noise.NoiseReceiverPoints; import org.matsim.contrib.noise.ReceiverPoint; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; +import org.matsim.core.population.io.PopulationReader; +import org.matsim.core.scenario.MutableScenario; +import org.matsim.core.scenario.ScenarioUtils; import java.util.Random; @@ -15,27 +23,28 @@ public class NoiseModel extends AbstractModel implements ModelUpdateListener { private static final Logger logger = Logger.getLogger(NoiseModel.class); private final NoiseDataManager noiseDataManager; + private final MatsimData matsimData; - public NoiseModel(NoiseDataContainer data, Properties properties, Random random) { + public NoiseModel(NoiseDataContainer data, Properties properties, Random random, MatsimData matsimData) { super(data, properties, random); this.noiseDataManager = data.getNoiseData(); + this.matsimData = matsimData; } @Override public void setup() { - updateNoiseImmissions(); + updateNoiseImmissions(properties.main.baseYear); } @Override public void prepareYear(int year) { - if (properties.transportModel.transportModelYears.contains(year)) { - updateNoiseImmissions(); - } + } - private void updateNoiseImmissions() { - logger.info("Updating noise immisisons."); + private void updateNoiseImmissions(int year) { + logger.info("Updating noise immisisons for year " + year + "."); //Transport model ran at end of last year + calculateNoiseOffline(year); final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); int counter65 = 0; int counter55 = 0; @@ -62,9 +71,47 @@ private void updateNoiseImmissions() { @Override public void endYear(int year) { + if (properties.transportModel.transportModelYears.contains(year + 1)) { + updateNoiseImmissions(year+1); + } } @Override public void endSimulation() { } + + + private void calculateNoiseOffline(int year) { + final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" + + properties.main.scenarioName + "/matsim/" + year +"/"; + + String populationPath = outputDirectoryRoot +year+".output_plans.xml.gz"; + + Config config = ConfigUtils.createConfig(); + config.controler().setOutputDirectory(outputDirectoryRoot); + config.controler().setRunId(String.valueOf(year)); + final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); + + new PopulationReader(scenario).readFile(populationPath); + + scenario.setNetwork(matsimData.getCarNetwork()); + + NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); + scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); + + NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); + noiseParameters.setInternalizeNoiseDamages(false); + noiseParameters.setComputeCausingAgents(false); + noiseParameters.setComputeNoiseDamages(false); + noiseParameters.setComputePopulationUnits(false); + noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); + noiseParameters.setThrowNoiseEventsCaused(false); + noiseParameters.setThrowNoiseEventsAffected(false); + noiseParameters.setWriteOutputIteration(0); + noiseParameters.setScaleFactor(20); + config.qsim().setEndTime(24*60*60); + + NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, outputDirectoryRoot); + noiseOfflineCalculation.run(); + } } diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java index c95128bed..1c88f824c 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseScenarioAssembler.java @@ -1,38 +1,40 @@ -package de.tum.bgu.msm.matsim.noise; - -import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; -import org.matsim.api.core.v01.Scenario; -import org.matsim.contrib.noise.NoiseConfigGroup; -import org.matsim.contrib.noise.NoiseReceiverPoints; -import org.matsim.core.config.Config; -import org.matsim.core.config.ConfigUtils; -import org.matsim.core.config.groups.ControlerConfigGroup; - -public final class NoiseScenarioAssembler implements MatsimScenarioAssembler { - - private final MatsimScenarioAssembler delegate; - private final NoiseDataManager noiseDataManager; - - public NoiseScenarioAssembler(MatsimScenarioAssembler delegate, NoiseDataManager noiseDataManager) { - this.delegate = delegate; - this.noiseDataManager = noiseDataManager; - } - - @Override - public Scenario assembleScenario(Config initialMatsimConfig, int year) { - Scenario scenario = delegate.assembleScenario(initialMatsimConfig, year); - final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); - scenario.getConfig().controler().setRoutingAlgorithmType(ControlerConfigGroup.RoutingAlgorithmType.FastDijkstra); - scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); - NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); - noiseParameters.setInternalizeNoiseDamages(false); - noiseParameters.setComputeCausingAgents(false); - noiseParameters.setComputeNoiseDamages(false); - noiseParameters.setComputePopulationUnits(false); - noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); - noiseParameters.setWriteOutputIteration(0); - scenario.getConfig().qsim().setEndTime(24*60*60); - - return scenario; - } -} +//package de.tum.bgu.msm.matsim.noise; +// +//import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; +//import org.matsim.api.core.v01.Scenario; +//import org.matsim.contrib.noise.NoiseConfigGroup; +//import org.matsim.contrib.noise.NoiseReceiverPoints; +//import org.matsim.core.config.Config; +//import org.matsim.core.config.ConfigUtils; +//import org.matsim.core.config.groups.ControlerConfigGroup; +// +//public final class NoiseScenarioAssembler implements MatsimScenarioAssembler { +// +// private final MatsimScenarioAssembler delegate; +// private final NoiseDataManager noiseDataManager; +// +// public NoiseScenarioAssembler(MatsimScenarioAssembler delegate, NoiseDataManager noiseDataManager) { +// this.delegate = delegate; +// this.noiseDataManager = noiseDataManager; +// } +// +// @Override +// public Scenario assembleScenario(Config initialMatsimConfig, int year) { +// Scenario scenario = delegate.assembleScenario(initialMatsimConfig, year); +// final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); +// scenario.getConfig().controler().setRoutingAlgorithmType(ControlerConfigGroup.RoutingAlgorithmType.FastDijkstra); +// scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); +// NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); +// noiseParameters.setInternalizeNoiseDamages(false); +// noiseParameters.setComputeCausingAgents(false); +// noiseParameters.setComputeNoiseDamages(false); +// noiseParameters.setComputePopulationUnits(false); +// noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); +// noiseParameters.setThrowNoiseEventsCaused(false); +// noiseParameters.setThrowNoiseEventsAffected(false); +// noiseParameters.setWriteOutputIteration(0); +// scenario.getConfig().qsim().setEndTime(24*60*60); +// +// return scenario; +// } +//} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java index 4bcd5a99b..3e3b0aeeb 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -92,7 +92,7 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg private final JobDataManager jobDataManager; private final RealEstateDataManager realEstateDataManager; - //use delegate for regional decisions + //use delegate for regional and current satisfaction decisions private final HousingStrategy delegate; public HuntNoiseSensitiveDwellingUtilityStrategy(TravelTimes travelTimes, @@ -120,7 +120,7 @@ public boolean isHouseholdEligibleToLiveHere(Household household, Dwelling dd) { public double calculateHousingUtility(Household hh, Dwelling dwelling) { NoiseDwelling oldDwelling = (NoiseDwelling) realEstateDataManager.getDwelling(hh.getDwellingId()); if(oldDwelling == null || oldDwelling.equals(dwelling)) { - return calculateCurrentUtility(hh, (NoiseDwelling) dwelling); + return delegate.calculateHousingUtility(hh, dwelling); } else { return calculateUtilityAlternative(hh, oldDwelling, (NoiseDwelling) dwelling); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java index 51bd28555..ef1172cd5 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -10,7 +10,6 @@ import de.tum.bgu.msm.matsim.SimpleMatsimScenarioAssembler; import de.tum.bgu.msm.matsim.ZoneConnectorManager; import de.tum.bgu.msm.matsim.noise.NoiseModel; -import de.tum.bgu.msm.matsim.noise.NoiseScenarioAssembler; import de.tum.bgu.msm.mito.MitoMatsimScenarioAssembler; import de.tum.bgu.msm.models.EducationModelMuc; import de.tum.bgu.msm.models.MarriageModelMuc; @@ -56,9 +55,7 @@ import de.tum.bgu.msm.models.relocation.RegionUtilityStrategyMucImpl; import de.tum.bgu.msm.models.relocation.migration.InOutMigration; import de.tum.bgu.msm.models.relocation.moves.*; -import de.tum.bgu.msm.models.transportModel.TransportModel; import de.tum.bgu.msm.properties.Properties; -import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.utils.SiloUtil; import org.matsim.core.config.Config; @@ -76,8 +73,6 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data DeathModel deathModel = new DeathModelImpl(dataContainer, properties, new DefaultDeathStrategy(), SiloUtil.provideNewRandom()); - final NoiseModel noiseModel = new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom()); - HousingStrategy housingStrategyDelegate = new HousingStrategyMuc(dataContainer, properties, @@ -92,7 +87,7 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data MovesModelImpl movesModel = new MovesModelImpl( dataContainer, properties, - new HuntNoiseSensitiveMovesStrategy(), + new DefaultMovesStrategy(), housingStrategy, SiloUtil.provideNewRandom()); CreateCarOwnershipModel carOwnershipModel = new CreateCarOwnershipModelMuc(dataContainer); @@ -132,26 +127,26 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data carOwnershipModel, hhFactory, properties, new DefaultMarriageStrategy(), SiloUtil.provideNewRandom()); - TransportModel transportModel; - MatsimScenarioAssembler scenarioAssembler; + MatsimTransportModel transportModel; switch (properties.transportModel.transportModelIdentifier) { case MITO_MATSIM: MatsimScenarioAssembler delegate = new MitoMatsimScenarioAssembler(dataContainer, properties, new MitoDataConverterMuc()); - scenarioAssembler = new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); transportModel = new MatsimTransportModel(dataContainer, config, properties, null, - ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, scenarioAssembler); + ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, delegate); break; case MATSIM: delegate = new SimpleMatsimScenarioAssembler(dataContainer, properties); - scenarioAssembler = new NoiseScenarioAssembler(delegate, ((NoiseDataContainerImpl) dataContainer).getNoiseData()); transportModel = new MatsimTransportModel(dataContainer, config, properties, null, - ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, scenarioAssembler); + ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, delegate); break; case NONE: default: transportModel = null; } + NoiseModel noiseModel = new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom(), transportModel.getMatsimData()); + + final ModelContainer modelContainer = new ModelContainer( birthModel, birthdayModel, diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java index 9c8accb5b..694604cd2 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java @@ -31,7 +31,8 @@ public static void main(String[] args) { ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); // modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); - SiloModel model = new SiloModel(properties, dataContainer, modelContainer, resultsMonitor); + SiloModel model = new SiloModel(properties, dataContainer, modelContainer); + model.addResultMonitor(resultsMonitor); model.runModel(); logger.info("Finished SILO."); } diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java index bcdeb16d7..3a474647f 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -49,9 +49,9 @@ public final void testMain() { NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); DataBuilderNoise.read(properties, dataContainer); ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); - modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); - SiloModel model = new SiloModel(properties, dataContainer, modelContainer, resultsMonitor); + SiloModel model = new SiloModel(properties, dataContainer, modelContainer); + model.addResultMonitor(resultsMonitor); model.runModel(); } } diff --git a/useCases/munich/test/muc/siloMatsimMucTest.properties b/useCases/munich/test/muc/siloMatsimMucTest.properties index 63e3d1642..e3d94cbae 100644 --- a/useCases/munich/test/muc/siloMatsimMucTest.properties +++ b/useCases/munich/test/muc/siloMatsimMucTest.properties @@ -9,7 +9,7 @@ random.seed = 1 transport.model = mito_matsim travel.time = matsim #transport.model = {mito, matsim} or empty if no transport model is used -transport.model.years = 2013 +transport.model.years = 2012,2013 auto.peak.sov.skim.2011 = skimsAllIntrazonal.omx auto.peak.sov.skim.matrix.name = timeByTime From 93f92651a5fee9db07a3f35427d280443ea2ede0 Mon Sep 17 00:00:00 2001 From: Nico Date: Tue, 12 Nov 2019 12:34:25 +0100 Subject: [PATCH 07/24] translate income groups to EUR, use constants instead of magic numbers --- ...NoiseSensitiveDwellingUtilityStrategy.java | 48 +++++++++++++------ 1 file changed, 33 insertions(+), 15 deletions(-) diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java index 3e3b0aeeb..98797d7a7 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -33,6 +33,21 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg private static final double MEDIUM_NOISE_DISCOUNT = 0.056; private static final double LOUD_NOISE_DISCOUNT = 0.096; + private static final int LOW_INCOME = 1; + private static final int HIGH_INCOME = 2; + private static final int AVERAGE_INCOME = 0; + + private static final int NO_NOISE = 0; + private static final int OCCASIONALLY_NOTICEABLE_NOISE = 1; + private static final int CONSTANT_HUM_NOISE = 2; + private static final int SOMETIMES_DISTURBING_NOISE = 3; + private static final int FREQUENTLY_DISTURBING_NOISE = 4; + + private static final int SINGLE_FAMILY = 0; + private static final int DUPLEX = 1; + private static final int TOWNHOUSE = 2; + private static final int HIGHRISE = 4; + //---------------------------------------------------------------------- /** @@ -244,42 +259,45 @@ private int translateDwellingType(Dwelling dwelling) { final DwellingType type = dwelling.getType(); if(type.equals(DefaultDwellingTypeImpl.SFD)) { - return 0; + return SINGLE_FAMILY; } else if( type.equals(DefaultDwellingTypeImpl.SFA)) { - return 1; + return DUPLEX; } else if(type.equals(DefaultDwellingTypeImpl.MF234)) { - return 2; + return TOWNHOUSE; } else if(type.equals(DefaultDwellingTypeImpl.MF5plus)) { - return 4; + return HIGHRISE; } else { //can only happen for mobile home which shouldn't exist in muc - return 4; + return HIGHRISE; } } private int translateLdenToNoiseCategory(double lden) { if (lden < 30) { - return 0; + return NO_NOISE; } else if (lden < 45) { - return 1; + return OCCASIONALLY_NOTICEABLE_NOISE; } else if (lden < 55) { - return 2; + return CONSTANT_HUM_NOISE; } else if (lden < 65) { - return 3; + return SOMETIMES_DISTURBING_NOISE; } else { - return 4; + return FREQUENTLY_DISTURBING_NOISE; } } + /** + * Adjusted to euro (1CAD ~ 0.68€) + */ private int translateHouseholdType(Household household) { final int annualHhIncome = HouseholdUtil.getAnnualHhIncome(household); - if (annualHhIncome < 20000) { - return 1; - } else if (annualHhIncome < 100000) { - return 0; + if (annualHhIncome < 15000) { + return LOW_INCOME; + } else if (annualHhIncome < 68500) { + return AVERAGE_INCOME; } else { - return 2; + return HIGH_INCOME; } } } From 7f515676d4110a6180d40d271e8ea0c9590cf7c2 Mon Sep 17 00:00:00 2001 From: Nico Date: Tue, 26 Nov 2019 17:35:18 +0100 Subject: [PATCH 08/24] updates on noise feedback (also calculate noise for newly created dwellings) --- .../msm/matsim/noise/NoiseDataContainer.java | 8 -- .../msm/matsim/noise/NoiseDataManager.java | 58 ------------- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 85 +++++++++++++------ .../msm/scenarios/noise/DataBuilderNoise.java | 3 +- ...NoiseSensitiveDwellingUtilityStrategy.java | 14 +-- .../scenarios/noise/ModelBuilderMucNoise.java | 3 +- .../noise/NoiseDataContainerImpl.java | 32 ++++--- .../scenarios/noise/NoiseDwellingWriter.java | 4 - ...eSensitiveDwellingUtilityStrategyTest.java | 40 +++++++++ 9 files changed, 125 insertions(+), 122 deletions(-) delete mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java delete mode 100644 extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java create mode 100644 useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java deleted file mode 100644 index 00e776eaf..000000000 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataContainer.java +++ /dev/null @@ -1,8 +0,0 @@ -package de.tum.bgu.msm.matsim.noise; - -import de.tum.bgu.msm.container.DataContainer; - -public interface NoiseDataContainer extends DataContainer { - - NoiseDataManager getNoiseData(); -} diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java deleted file mode 100644 index cf1aab1a1..000000000 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseDataManager.java +++ /dev/null @@ -1,58 +0,0 @@ -package de.tum.bgu.msm.matsim.noise; - -import de.tum.bgu.msm.data.dwelling.Dwelling; -import de.tum.bgu.msm.data.dwelling.DwellingData; -import de.tum.bgu.msm.properties.Properties; -import de.tum.bgu.msm.simulator.UpdateListener; -import org.matsim.api.core.v01.Id; -import org.matsim.contrib.noise.NoiseReceiverPoint; -import org.matsim.contrib.noise.NoiseReceiverPoints; -import org.matsim.contrib.noise.ReceiverPoint; -import org.matsim.core.utils.geometry.CoordUtils; - -public class NoiseDataManager implements UpdateListener { - - private final NoiseReceiverPoints noiseReceiverPoints; - private final DwellingData dwellingData; - private final Properties properties; - - public NoiseDataManager(DwellingData dwellingData, Properties properties) { - this.dwellingData = dwellingData; - this.properties = properties; - this.noiseReceiverPoints = new NoiseReceiverPoints(); - } - - @Override - public void setup() { - - } - - @Override - public void prepareYear(int year) { - } - - @Override - public void endYear(int year) { - } - - @Override - public void endSimulation() { - noiseReceiverPoints.clear(); - } - - public NoiseReceiverPoints getNoiseReceiverPoints() { - NoiseReceiverPoints newNoiseReceiverPoints = new NoiseReceiverPoints(); - for(Dwelling dwelling: dwellingData.getDwellings()) { - Id id = Id.create(dwelling.getId(), ReceiverPoint.class); - final NoiseReceiverPoint existing = noiseReceiverPoints.remove(id); - if(existing == null) { - newNoiseReceiverPoints.put(id, new NoiseReceiverPoint(id, CoordUtils.createCoord(dwelling.getCoordinate()))); - } else { - newNoiseReceiverPoints.put(id, existing); - } - } - this.noiseReceiverPoints.clear(); - this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); - return noiseReceiverPoints; - } -} diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 1f83b292e..604e6b547 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -1,39 +1,44 @@ package de.tum.bgu.msm.matsim.noise; +import de.tum.bgu.msm.container.DataContainer; import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; import de.tum.bgu.msm.matsim.MatsimData; import de.tum.bgu.msm.models.AbstractModel; import de.tum.bgu.msm.models.ModelUpdateListener; import de.tum.bgu.msm.properties.Properties; import org.apache.log4j.Logger; import org.matsim.api.core.v01.Id; -import org.matsim.contrib.noise.NoiseConfigGroup; -import org.matsim.contrib.noise.NoiseOfflineCalculation; -import org.matsim.contrib.noise.NoiseReceiverPoints; -import org.matsim.contrib.noise.ReceiverPoint; +import org.matsim.contrib.noise.*; import org.matsim.core.config.Config; import org.matsim.core.config.ConfigUtils; import org.matsim.core.population.io.PopulationReader; import org.matsim.core.scenario.MutableScenario; import org.matsim.core.scenario.ScenarioUtils; +import org.matsim.core.utils.geometry.CoordUtils; import java.util.Random; public class NoiseModel extends AbstractModel implements ModelUpdateListener { private static final Logger logger = Logger.getLogger(NoiseModel.class); - private final NoiseDataManager noiseDataManager; + private final RealEstateDataManager realEstateDataManager; private final MatsimData matsimData; + private int latestMatsimYear = -1; - public NoiseModel(NoiseDataContainer data, Properties properties, Random random, MatsimData matsimData) { + private final NoiseReceiverPoints noiseReceiverPoints; + + + public NoiseModel(DataContainer data, Properties properties, Random random, MatsimData matsimData) { super(data, properties, random); - this.noiseDataManager = data.getNoiseData(); + this.realEstateDataManager = data.getRealEstateDataManager(); this.matsimData = matsimData; + this.noiseReceiverPoints = new NoiseReceiverPoints(); } @Override public void setup() { - updateNoiseImmissions(properties.main.baseYear); + updateImmissions(properties.main.baseYear); } @Override @@ -41,11 +46,47 @@ public void prepareYear(int year) { } - private void updateNoiseImmissions(int year) { + @Override + public void endYear(int year) { + updateImmissions(year); + } + + @Override + public void endSimulation() { + } + + private void updateImmissions(int year) { logger.info("Updating noise immisisons for year " + year + "."); - //Transport model ran at end of last year - calculateNoiseOffline(year); - final NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); + + NoiseReceiverPoints newNoiseReceiverPoints = new NoiseReceiverPoints(); + NoiseReceiverPoints existingNoiseReceiverPoints = new NoiseReceiverPoints(); + + for(Dwelling dwelling: realEstateDataManager.getDwellings()) { + Id id = Id.create(dwelling.getId(), ReceiverPoint.class); + final NoiseReceiverPoint existing = noiseReceiverPoints.remove(id); + if(existing == null) { + newNoiseReceiverPoints.put(id, new NoiseReceiverPoint(id, CoordUtils.createCoord(dwelling.getCoordinate()))); + } else { + existingNoiseReceiverPoints.put(id, existing); + } + } + + this.noiseReceiverPoints.clear(); + this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); + this.noiseReceiverPoints.putAll(existingNoiseReceiverPoints); + + if (properties.transportModel.transportModelYears.contains(year + 1) || properties.main.startYear == year) { + if (properties.transportModel.transportModelYears.contains(year + 1)) { + latestMatsimYear = year + 1; + } else { + latestMatsimYear = year; + } + calculateNoiseOffline(noiseReceiverPoints); + } else if(latestMatsimYear > 0) { + calculateNoiseOffline(newNoiseReceiverPoints); + this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); + } + int counter65 = 0; int counter55 = 0; for (Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { @@ -69,34 +110,22 @@ private void updateNoiseImmissions(int year) { logger.info("Dwellings >65dB(A) : " + counter65 + " (" + ((double) counter65) / total + "%)"); } - @Override - public void endYear(int year) { - if (properties.transportModel.transportModelYears.contains(year + 1)) { - updateNoiseImmissions(year+1); - } - } - - @Override - public void endSimulation() { - } - - private void calculateNoiseOffline(int year) { + private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" - + properties.main.scenarioName + "/matsim/" + year +"/"; + + properties.main.scenarioName + "/matsim/" + latestMatsimYear +"/"; - String populationPath = outputDirectoryRoot +year+".output_plans.xml.gz"; + String populationPath = outputDirectoryRoot + latestMatsimYear +".output_plans.xml.gz"; Config config = ConfigUtils.createConfig(); config.controler().setOutputDirectory(outputDirectoryRoot); - config.controler().setRunId(String.valueOf(year)); + config.controler().setRunId(String.valueOf(latestMatsimYear)); final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); new PopulationReader(scenario).readFile(populationPath); scenario.setNetwork(matsimData.getCarNetwork()); - NoiseReceiverPoints noiseReceiverPoints = noiseDataManager.getNoiseReceiverPoints(); scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java index 822691b74..f2feb4c00 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java @@ -14,7 +14,6 @@ import de.tum.bgu.msm.io.*; import de.tum.bgu.msm.io.input.*; import de.tum.bgu.msm.matsim.MatsimTravelTimes; -import de.tum.bgu.msm.matsim.noise.NoiseDataManager; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.schools.*; import org.matsim.core.config.Config; @@ -74,7 +73,7 @@ householdData, dwellingData, new PersonFactoryMuc(), DataContainerWithSchools delegate = new DataContainerWithSchoolsImpl(geoData, realEstateDataManager, jobDataManager, householdDataManager, travelTimes, accessibility, commutingTimeProbability, schoolData, properties); - return new NoiseDataContainerImpl(delegate, new NoiseDataManager(dwellingData, properties), properties); + return new NoiseDataContainerImpl(delegate, properties); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java index 98797d7a7..20edef153 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -57,7 +57,7 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg * [1] low inc * [2] high inc */ - static double[][] dwellingTypeUtil = { + private static double[][] dwellingTypeUtil = { {0, -1.0570, -1.1130, -1.6340, -1.7940}, {0, -0.8783, -0.9566, -0.9895, -0.9514}, {0, -1.0570, -1.1130, -1.6340, -1.7940} @@ -73,7 +73,7 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg * [1] low inc * [2] high inc */ - static double[][] airQualityUtilAvg = { + private static double[][] airQualityUtilAvg = { {0, -0.2446, -0.5092, -0.9796}, {0, -0.2299, -0.5264, -0.8504}, {0, -0.3073, -0.2879, -1.3150} @@ -87,7 +87,7 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg * [1] low inc * [2] high inc */ - static double[][] trafficNoiseUtil = { + private static double[][] trafficNoiseUtil = { {0, -0.1694, -0.7165, -0.5348, -1.35}, {0, -0.2758, -0.8354, -0.6934, -1.0250}, {0, -0.3192, -0.9886, -1.0180, -1.8230} @@ -97,11 +97,11 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg //---------------------------------------------------------------------- - final static double[] rentUtilPer100Increase = {-0.8033, -1.2260, -0.6665}; + private final static double[] rentUtilPer100Increase = {-0.8033, -1.2260, -0.6665}; - final static double[] travelTimeUtilPer10minIncreaseAvg = {-0.1890, -0.1170, -0.3613}; + private final static double[] travelTimeUtilPer10minIncreaseAvg = {-0.1890, -0.1170, -0.3613}; - final static double[] travelTimeTransitUtilPer10minIncreaseAvg = {-0.0974, -0.1253, -0.1246}; + private final static double[] travelTimeTransitUtilPer10minIncreaseAvg = {-0.0974, -0.1253, -0.1246}; private final TravelTimes travelTimes; private final JobDataManager jobDataManager; @@ -169,7 +169,7 @@ public HousingStrategy duplicate() { return duplicate; } - double calculateUtilityAlternative(Household household, NoiseDwelling oldDwelling, NoiseDwelling newDwelling) { + private double calculateUtilityAlternative(Household household, NoiseDwelling oldDwelling, NoiseDwelling newDwelling) { final double oldPrice = getNoiseAdjustedPrice(oldDwelling); final double newPrice = getNoiseAdjustedPrice(newDwelling); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java index ef1172cd5..b2aeb7b8e 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -16,6 +16,7 @@ import de.tum.bgu.msm.models.autoOwnership.CreateCarOwnershipModel; import de.tum.bgu.msm.models.carOwnership.CreateCarOwnershipModelMuc; import de.tum.bgu.msm.models.carOwnership.UpdateCarOwnershipModelMuc; +import de.tum.bgu.msm.models.construction.ConstructionDemandStrategyMuc; import de.tum.bgu.msm.models.demography.birth.BirthModelImpl; import de.tum.bgu.msm.models.demography.birth.DefaultBirthStrategy; import de.tum.bgu.msm.models.demography.birthday.BirthdayModel; @@ -108,7 +109,7 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data JobMarketUpdate jobMarketUpdateModel = new JobMarketUpdateImpl(dataContainer, properties, SiloUtil.provideNewRandom()); ConstructionModel construction = new ConstructionModelImpl(dataContainer, ddFactory, - properties, new DefaultConstructionLocationStrategy(), new DefaultConstructionDemandStrategy(), SiloUtil.provideNewRandom()); + properties, new DefaultConstructionLocationStrategy(), new ConstructionDemandStrategyMuc(), SiloUtil.provideNewRandom()); PricingModel pricing = new PricingModelImpl(dataContainer, properties, new DefaultPricingStrategy(), SiloUtil.provideNewRandom()); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java index 3b078a26d..6717fe4b9 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java @@ -7,22 +7,20 @@ import de.tum.bgu.msm.data.household.HouseholdDataManager; import de.tum.bgu.msm.data.job.JobDataManager; import de.tum.bgu.msm.data.travelTimes.TravelTimes; -import de.tum.bgu.msm.matsim.noise.NoiseDataManager; +import de.tum.bgu.msm.io.PersonWriterMuc; +import de.tum.bgu.msm.io.output.DefaultHouseholdWriter; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.schools.SchoolData; -public class NoiseDataContainerImpl implements de.tum.bgu.msm.matsim.noise.NoiseDataContainer, DataContainerWithSchools { +public class NoiseDataContainerImpl implements DataContainerWithSchools { private final DataContainerWithSchools delegate; - private final NoiseDataManager noiseDataManager; private final Properties properties; public NoiseDataContainerImpl(DataContainerWithSchools delegate, - NoiseDataManager noiseDataManager, Properties properties) { this.delegate = delegate; - this.noiseDataManager = noiseDataManager; this.properties = properties; } @@ -69,13 +67,11 @@ public CommutingTimeProbability getCommutingTimeProbability() { @Override public void setup() { delegate.setup(); - noiseDataManager.setup(); } @Override public void prepareYear(int year) { delegate.prepareYear(year); - noiseDataManager.setup(); if (properties.transportModel.transportModelYears.contains(year) || properties.main.startYear == year) { writeDwellingsWithNoise(year); } @@ -88,24 +84,32 @@ private void writeDwellingsWithNoise(int year) { + "Noise_" + year + ".csv"; - new NoiseDwellingWriter(this).writeDwellings(filedd); + new NoiseDwellingWriter(delegate.getRealEstateDataManager()).writeDwellings(filedd); + String fileHh = outputDirectory + + properties.householdData.householdFinalFileName + + "_" + + year + + ".csv"; + new DefaultHouseholdWriter(delegate.getHouseholdDataManager()).writeHouseholds(fileHh); + + String filePp = outputDirectory + + properties.householdData.personFinalFileName + + "_" + + year + + ".csv"; + new PersonWriterMuc(delegate.getHouseholdDataManager()).writePersons(filePp); + } @Override public void endYear(int year) { delegate.endYear(year); - noiseDataManager.setup(); } @Override public void endSimulation() { delegate.endSimulation(); - noiseDataManager.endSimulation(); writeDwellingsWithNoise(properties.main.endYear); } - @Override - public NoiseDataManager getNoiseData() { - return noiseDataManager; - } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java index 01572eb02..f2da3844f 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingWriter.java @@ -4,7 +4,6 @@ import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; import de.tum.bgu.msm.io.output.DefaultDwellingWriter; import de.tum.bgu.msm.io.output.DwellingWriter; -import de.tum.bgu.msm.matsim.noise.NoiseDataContainer; import de.tum.bgu.msm.matsim.noise.NoiseDwelling; import de.tum.bgu.msm.utils.SiloUtil; import org.apache.log4j.Logger; @@ -13,9 +12,6 @@ public class NoiseDwellingWriter implements DwellingWriter { - public NoiseDwellingWriter(NoiseDataContainer noiseDataContainer) { - this.realEstateDataManager = noiseDataContainer.getRealEstateDataManager(); - } private final static Logger logger = Logger.getLogger(DefaultDwellingWriter.class); private final RealEstateDataManager realEstateDataManager; diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java new file mode 100644 index 000000000..0b8908051 --- /dev/null +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java @@ -0,0 +1,40 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingFactoryImpl; +import de.tum.bgu.msm.data.dwelling.DwellingImpl; +import de.tum.bgu.msm.data.household.Household; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.utils.SiloUtil; +import org.junit.Test; +import org.locationtech.jts.geom.Coordinate; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; + +import java.io.File; + +public class HuntNoiseSensitiveDwellingUtilityStrategyTest { + + @Test + public void test() { + String path = "./test/muc/siloMatsimMucTest.properties"; + Config config = ConfigUtils.loadConfig("./test/muc/matsim_input/config.xml"); + + File dir = new File("./test/muc/scenOutput/test/"); + + + Properties properties = SiloUtil.siloInitialization(path); + + NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); + DataBuilderNoise.read(properties, dataContainer); + HuntNoiseSensitiveDwellingUtilityStrategy strategy = new HuntNoiseSensitiveDwellingUtilityStrategy(dataContainer.getTravelTimes(), + dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); + int hhid = 1249939; + final Household household = dataContainer.getHouseholdDataManager().getHouseholdFromId(hhid); + Dwelling dwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 1000, 1990)); + strategy.calculateHousingUtility(household, dwelling); + + + } +} From 161434104a9c99d2be11d5ce48e00a188d89893d Mon Sep 17 00:00:00 2001 From: Nico Date: Mon, 16 Dec 2019 10:52:34 +0100 Subject: [PATCH 09/24] updates on noise feedback --- .../de/tum/bgu/msm/matsim/MatsimData.java | 9 +- .../bgu/msm/matsim/MatsimTransportModel.java | 1 + .../accessibility/AccessibilityModule.java | 4 +- .../accessibility/MatsimAccessibility.java | 4 +- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 109 ++++++- .../TransportModelPropertiesModule.java | 7 + .../bgu/msm/io/PersonReaderMucDisability.java | 3 +- .../bgu/msm/io/PersonWriterMucDisability.java | 2 +- .../msm/models/disability/DisabilityImpl.java | 2 +- .../disabilities/DataBuilderDisability.java | 110 +++++++ .../PersonFactoryMucDisability.java | 40 +++ .../disabilities/PersonMucDisability.java | 146 +++++++++ .../disabilities/SiloMucDisability.java | 94 ++++++ ...iseInsensitiveDwellingUtilityStrategy.java | 286 ++++++++++++++++++ ...NoiseSensitiveDwellingUtilityStrategy.java | 71 +++-- .../scenarios/noise/ModelBuilderMucNoise.java | 26 +- .../ModelBuilderMucNoiseInsensitive.java | 168 ++++++++++ .../noise/SiloMucNoiseInsensitive.java | 37 +++ ...eSensitiveDwellingUtilityStrategyTest.java | 18 +- .../transportModel/matsim/SiloNoiseTest.java | 110 ++++++- 20 files changed, 1171 insertions(+), 76 deletions(-) create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonFactoryMucDisability.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index f7c4fb611..850720693 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -5,9 +5,11 @@ import de.tum.bgu.msm.container.DataContainer; import de.tum.bgu.msm.data.Zone; import de.tum.bgu.msm.properties.Properties; +import org.matsim.api.core.v01.Scenario; import org.matsim.api.core.v01.TransportMode; import org.matsim.api.core.v01.network.Network; import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; import org.matsim.core.network.NetworkUtils; import org.matsim.core.network.algorithms.TransportModeNetworkFilter; import org.matsim.core.population.PopulationUtils; @@ -17,6 +19,7 @@ import org.matsim.core.router.util.LeastCostPathCalculatorFactory; import org.matsim.core.router.util.TravelDisutility; import org.matsim.core.router.util.TravelTime; +import org.matsim.core.scenario.MutableScenario; import org.matsim.core.scenario.ScenarioUtils; import org.matsim.pt.transitSchedule.api.TransitSchedule; @@ -137,8 +140,10 @@ TripRouter createTripRouter() { final RoutingModule ptRoutingModule; if (schedule != null && config.transit().isUseTransit()) { + final MutableScenario scenario = ScenarioUtils.createMutableScenario(ConfigUtils.createConfig()); + scenario.setNetwork(carNetwork); final RoutingModule teleportationRoutingModule = DefaultRoutingModules.createTeleportationRouter( - TransportMode.walk, PopulationUtils.getFactory(), config.plansCalcRoute().getOrCreateModeRoutingParams(TransportMode.walk)); + TransportMode.walk, scenario, config.plansCalcRoute().getOrCreateModeRoutingParams(TransportMode.walk)); final SwissRailRaptor swissRailRaptor = createSwissRailRaptor(RaptorStaticConfig.RaptorOptimization.OneToOneRouting); ptRoutingModule = new SwissRailRaptorRoutingModule(swissRailRaptor, schedule, ptNetwork, teleportationRoutingModule); } else { @@ -169,7 +174,7 @@ LeastCostPathCalculator createLeastCostPathCalculator() { RoutingModule getTeleportationRouter(String mode) { return DefaultRoutingModules.createTeleportationRouter( - mode, PopulationUtils.getFactory(), config.plansCalcRoute().getOrCreateModeRoutingParams(mode)); + mode, ScenarioUtils.createScenario(ConfigUtils.createConfig()), config.plansCalcRoute().getOrCreateModeRoutingParams(mode)); } SwissRailRaptorData getRaptorData(RaptorStaticConfig.RaptorOptimization optimization) { diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java index 8341bdda5..cfe413138 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java @@ -150,6 +150,7 @@ private void finalizeConfig(Config config, int year) { * @param eventsFile */ private void replayFromEvents(String eventsFile) { + logger.warn("Setting up MATSim with initial events file: " + eventsFile); Scenario scenario = ScenarioUtils.loadScenario(initialMatsimConfig); TravelTime travelTime = TravelTimeUtils.createTravelTimesFromEvents(scenario, eventsFile); TravelDisutility travelDisutility = ControlerDefaults.createDefaultTravelDisutilityFactory(scenario).createTravelDisutility(travelTime); diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java index d33d120ab..55bef965d 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java @@ -15,7 +15,7 @@ import org.matsim.api.core.v01.network.Node; import org.matsim.contrib.accessibility.AccessibilityAttributes; import org.matsim.contrib.accessibility.AccessibilityConfigGroup; -import org.matsim.contrib.accessibility.interfaces.FacilityDataExchangeInterface; +//import org.matsim.contrib.accessibility.interfaces.FacilityDataExchangeInterface; import org.matsim.core.config.ConfigUtils; import org.matsim.core.config.groups.FacilitiesConfigGroup; import org.matsim.core.controler.Controler; @@ -108,7 +108,7 @@ public void prepareAccessibility(Scenario scenario, Controler controler) { // Accessibility module org.matsim.contrib.accessibility.AccessibilityModule module = new org.matsim.contrib.accessibility.AccessibilityModule(); - module.addFacilityDataExchangeListener((FacilityDataExchangeInterface) dataContainer.getAccessibility()); +// module.addFacilityDataExchangeListener((FacilityDataExchangeInterface) dataContainer.getAccessibility()); controler.addOverridingModule(module); // End accessibility module } diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/MatsimAccessibility.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/MatsimAccessibility.java index dc6da1c8c..76af747b1 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/MatsimAccessibility.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/MatsimAccessibility.java @@ -23,7 +23,7 @@ /** * @author dziemke **/ -public class MatsimAccessibility implements Accessibility, FacilityDataExchangeInterface { +public class MatsimAccessibility implements Accessibility { private static final Logger logger = Logger.getLogger(MatsimAccessibility.class); private final GeoData geoData; @@ -46,7 +46,7 @@ public void setFacilityAccessibilities(ActivityFacility measurePoint, Double tim } } - @Override + public void finish() { } // Accessibility interface methods diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 604e6b547..8f2917dfd 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -17,6 +17,9 @@ import org.matsim.core.scenario.ScenarioUtils; import org.matsim.core.utils.geometry.CoordUtils; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; import java.util.Random; public class NoiseModel extends AbstractModel implements ModelUpdateListener { @@ -61,10 +64,10 @@ private void updateImmissions(int year) { NoiseReceiverPoints newNoiseReceiverPoints = new NoiseReceiverPoints(); NoiseReceiverPoints existingNoiseReceiverPoints = new NoiseReceiverPoints(); - for(Dwelling dwelling: realEstateDataManager.getDwellings()) { + for (Dwelling dwelling : realEstateDataManager.getDwellings()) { Id id = Id.create(dwelling.getId(), ReceiverPoint.class); final NoiseReceiverPoint existing = noiseReceiverPoints.remove(id); - if(existing == null) { + if (existing == null) { newNoiseReceiverPoints.put(id, new NoiseReceiverPoint(id, CoordUtils.createCoord(dwelling.getCoordinate()))); } else { existingNoiseReceiverPoints.put(id, existing); @@ -75,27 +78,50 @@ private void updateImmissions(int year) { this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); this.noiseReceiverPoints.putAll(existingNoiseReceiverPoints); - if (properties.transportModel.transportModelYears.contains(year + 1) || properties.main.startYear == year) { - if (properties.transportModel.transportModelYears.contains(year + 1)) { - latestMatsimYear = year + 1; + //First year + if(properties.main.startYear == year) { + if(properties.transportModel.matsimInitialPlansFile != null + && properties.transportModel.matsimInitialEventsFile != null) { + //initial files provided -> replay + if(existingNoiseReceiverPoints.isEmpty()) { + replayFromEvents(noiseReceiverPoints); + } else { + replayFromEvents(newNoiseReceiverPoints); + } } else { + //matsim transport model must have run at this stage for the start year latestMatsimYear = year; + calculateNoiseOffline(noiseReceiverPoints); + } + } else if(latestMatsimYear == -1) { + //not the first year and no matsim run has happened yet... + if(properties.transportModel.transportModelYears.contains(year + 1)) { + //...this means that matsim either has to run and update all receiver points for the next year... + latestMatsimYear = year + 1; + calculateNoiseOffline(noiseReceiverPoints); + } else if(properties.transportModel.matsimInitialPlansFile != null + && properties.transportModel.matsimInitialEventsFile != null) { + //...or the initial files are available. update new receiver points. + replayFromEvents(newNoiseReceiverPoints); + } else { + //one of the above options have to be true. + throw new RuntimeException("Should not happen!"); } - calculateNoiseOffline(noiseReceiverPoints); - } else if(latestMatsimYear > 0) { + } else { + //matsim has run before. update new receiver points. calculateNoiseOffline(newNoiseReceiverPoints); - this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); } + int counter65 = 0; int counter55 = 0; - for (Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { + for (Dwelling dwelling : dataContainer.getRealEstateDataManager().getDwellings()) { final Id id = Id.create(dwelling.getId(), ReceiverPoint.class); - if(noiseReceiverPoints.containsKey(id)) { + if (noiseReceiverPoints.containsKey(id)) { double lden = noiseReceiverPoints.get(id).getLden(); ((NoiseDwelling) dwelling).setNoiseImmision(lden); - if(lden > 55) { - if(lden > 65) { + if (lden > 55) { + if (lden > 65) { counter65++; } else { counter55++; @@ -113,9 +139,9 @@ private void updateImmissions(int year) { private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" - + properties.main.scenarioName + "/matsim/" + latestMatsimYear +"/"; + + properties.main.scenarioName + "/matsim/" + latestMatsimYear + "/"; - String populationPath = outputDirectoryRoot + latestMatsimYear +".output_plans.xml.gz"; + String populationPath = outputDirectoryRoot + latestMatsimYear + ".output_plans.xml.gz"; Config config = ConfigUtils.createConfig(); config.controler().setOutputDirectory(outputDirectoryRoot); @@ -138,9 +164,62 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setThrowNoiseEventsAffected(false); noiseParameters.setWriteOutputIteration(0); noiseParameters.setScaleFactor(20); - config.qsim().setEndTime(24*60*60); + config.qsim().setEndTime(24 * 60 * 60); NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, outputDirectoryRoot); noiseOfflineCalculation.run(); } + + + private void replayFromEvents(NoiseReceiverPoints noiseReceiverPoints) { + + final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" + properties.main.scenarioName; + String outputDirectory = outputDirectoryRoot + "/matsim/" + properties.main.startYear +"_warm" + "/"; + + try { + final Path events = Paths.get(outputDirectory + "/"+ Paths.get(properties.transportModel.matsimInitialEventsFile).getFileName()); + final Path plans = Paths.get(outputDirectory + "/" + Paths.get(properties.transportModel.matsimInitialPlansFile).getFileName()); + + Files.createDirectories(events.getParent()); + Files.createDirectories(plans.getParent()); + + Files.copy(Paths.get(properties.main.baseDirectory + properties.transportModel.matsimInitialEventsFile), events); + Files.copy(Paths.get(properties.main.baseDirectory + properties.transportModel.matsimInitialPlansFile), plans); + + } catch (Exception e) { + logger.error(e); + } + + + String eventsFile = properties.main.baseDirectory + properties.transportModel.matsimInitialEventsFile; + final Path path = Paths.get(eventsFile); + + String plansFile = properties.main.baseDirectory + properties.transportModel.matsimInitialPlansFile; + + + Config config = ConfigUtils.createConfig(); + config.controler().setOutputDirectory(outputDirectory); + String runId = eventsFile.substring(eventsFile.lastIndexOf("/") + 1, eventsFile.indexOf(".output_events")); + config.controler().setRunId(runId); + final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); + new PopulationReader(scenario).readFile(plansFile); + + scenario.setNetwork(matsimData.getCarNetwork()); + scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); + + NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); + noiseParameters.setInternalizeNoiseDamages(false); + noiseParameters.setComputeCausingAgents(false); + noiseParameters.setComputeNoiseDamages(false); + noiseParameters.setComputePopulationUnits(false); + noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); + noiseParameters.setThrowNoiseEventsCaused(false); + noiseParameters.setThrowNoiseEventsAffected(false); + noiseParameters.setWriteOutputIteration(0); + noiseParameters.setScaleFactor(20); + config.qsim().setEndTime(24 * 60 * 60); + + NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, path.getParent().toString()); + noiseOfflineCalculation.run(); + } } diff --git a/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/TransportModelPropertiesModule.java b/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/TransportModelPropertiesModule.java index 3e6e80649..ba0acc01c 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/TransportModelPropertiesModule.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/TransportModelPropertiesModule.java @@ -39,6 +39,11 @@ public class TransportModelPropertiesModule { */ public final String matsimInitialEventsFile; + /** + * PLans file at the base year for warm start of travel times based on MATSim. + */ + public final String matsimInitialPlansFile; + /** * Scale factor for MATSim transport model. */ @@ -76,6 +81,8 @@ public TransportModelPropertiesModule(ResourceBundle bundle) { PropertiesUtil.newPropertySubmodule("Transport - silo-matsim"); matsimInitialEventsFile = PropertiesUtil.getStringProperty(bundle, "matsim.initial.events", null); + matsimInitialPlansFile = PropertiesUtil.getStringProperty(bundle, "matsim.initial.plans", null); + matsimScaleFactor = PropertiesUtil.getDoubleProperty(bundle, "matsim.scale.factor", 0.01); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonReaderMucDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonReaderMucDisability.java index e2b2676cf..7f6692f1f 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonReaderMucDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonReaderMucDisability.java @@ -3,9 +3,10 @@ import de.tum.bgu.msm.data.household.Household; import de.tum.bgu.msm.data.household.HouseholdDataManager; import de.tum.bgu.msm.data.person.*; -import de.tum.bgu.msm.events.DisabilityEvent; import de.tum.bgu.msm.io.input.PersonReader; import de.tum.bgu.msm.models.disability.DefaultDisabilityStrategy; +import de.tum.bgu.msm.scenarios.disabilities.PersonFactoryMucDisability; +import de.tum.bgu.msm.scenarios.disabilities.PersonMucDisability; import de.tum.bgu.msm.utils.SiloUtil; import org.apache.log4j.Logger; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonWriterMucDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonWriterMucDisability.java index 58fc11d7f..e6f5e4782 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonWriterMucDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/io/PersonWriterMucDisability.java @@ -2,7 +2,7 @@ import de.tum.bgu.msm.data.household.HouseholdDataManager; import de.tum.bgu.msm.data.person.Person; -import de.tum.bgu.msm.data.person.PersonMucDisability; +import de.tum.bgu.msm.scenarios.disabilities.PersonMucDisability; import de.tum.bgu.msm.io.output.PersonWriter; import de.tum.bgu.msm.utils.SiloUtil; import org.apache.log4j.Logger; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/models/disability/DisabilityImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/models/disability/DisabilityImpl.java index 53f4502a7..b17614409 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/models/disability/DisabilityImpl.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/models/disability/DisabilityImpl.java @@ -3,7 +3,7 @@ import de.tum.bgu.msm.container.DataContainer; import de.tum.bgu.msm.data.person.Disability; import de.tum.bgu.msm.data.person.Person; -import de.tum.bgu.msm.data.person.PersonMucDisability; +import de.tum.bgu.msm.scenarios.disabilities.PersonMucDisability; import de.tum.bgu.msm.events.DisabilityEvent; import de.tum.bgu.msm.models.AbstractModel; import de.tum.bgu.msm.properties.Properties; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java index e69de29bb..2f34641f3 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java @@ -0,0 +1,110 @@ +package de.tum.bgu.msm.scenarios.disabilities; + +import de.tum.bgu.msm.data.accessibility.Accessibility; +import de.tum.bgu.msm.data.accessibility.AccessibilityImpl; +import de.tum.bgu.msm.data.accessibility.CommutingTimeProbability; +import de.tum.bgu.msm.data.dwelling.*; +import de.tum.bgu.msm.data.geo.DefaultGeoData; +import de.tum.bgu.msm.data.geo.GeoData; +import de.tum.bgu.msm.data.household.*; +import de.tum.bgu.msm.data.job.*; +import de.tum.bgu.msm.data.travelTimes.SkimTravelTimes; +import de.tum.bgu.msm.data.travelTimes.TravelTimes; +import de.tum.bgu.msm.io.*; +import de.tum.bgu.msm.io.input.*; +import de.tum.bgu.msm.matsim.MatsimTravelTimes; +import de.tum.bgu.msm.models.disability.DefaultDisabilityStrategy; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.schools.*; +import org.matsim.core.config.Config; + +public class DataBuilderDisability { + + private DataBuilderDisability() { + } + + public static DataContainerWithSchoolsImpl getModelDataForMuc(Properties properties, Config config) { + + HouseholdData householdData = new HouseholdDataImpl(); + JobData jobData = new JobDataImpl(); + DwellingData dwellingData = new DwellingDataImpl(); + + GeoData geoData = new DefaultGeoData(); + + + TravelTimes travelTimes = null; + Accessibility accessibility = null; + + switch (properties.transportModel.travelTimeImplIdentifier) { + case SKIM: + travelTimes = new SkimTravelTimes(); + accessibility = new AccessibilityImpl(geoData, travelTimes, properties, dwellingData, jobData); + break; + case MATSIM: + travelTimes = new MatsimTravelTimes(config); +// accessibility = new MatsimAccessibility(geoData); + accessibility = new AccessibilityImpl(geoData, travelTimes, properties, dwellingData, jobData); + break; + default: + break; + } + + CommutingTimeProbability commutingTimeProbability = new CommutingTimeProbability(properties); + + //TODO: revise this! + new JobType(properties.jobData.jobTypes); + + + JobFactoryMuc jobFactory = new JobFactoryMuc(); + jobFactory.readWorkingTimeDistributions(properties); + + RealEstateDataManager realEstateDataManager = new RealEstateDataManagerImpl( + DefaultDwellingTypeImpl.values(), dwellingData, householdData, geoData, new DwellingFactoryImpl(), properties); + + JobDataManager jobDataManager = new JobDataManagerImpl( + properties, jobFactory, jobData, geoData, travelTimes, commutingTimeProbability); + + final HouseholdFactoryMuc hhFactory = new HouseholdFactoryMuc(); + HouseholdDataManager householdDataManager = new HouseholdDataManagerImpl( + householdData, dwellingData, new PersonFactoryMucDisability(), + hhFactory, properties, realEstateDataManager); + + SchoolData schoolData = new SchoolDataImpl(geoData, dwellingData, properties); + + return new DataContainerWithSchoolsImpl(geoData, realEstateDataManager, jobDataManager, householdDataManager, travelTimes, accessibility, + commutingTimeProbability, schoolData, properties); + } + + static public void read(Properties properties, DataContainerWithSchoolsImpl dataContainer){ + + GeoDataReader reader = new GeoDataReaderMuc(dataContainer.getGeoData()); + String pathShp = properties.main.baseDirectory + properties.geo.zoneShapeFile; + String fileName = properties.main.baseDirectory + properties.geo.zonalDataFile; + reader.readZoneCsv(fileName); + reader.readZoneShapefile(pathShp); + + int year = properties.main.startYear; + String householdFile = properties.main.baseDirectory + properties.householdData.householdFileName; + householdFile += "_" + year + ".csv"; + HouseholdReader hhReader = new HouseholdReaderMuc(dataContainer.getHouseholdDataManager(), (HouseholdFactoryMuc) dataContainer.getHouseholdDataManager().getHouseholdFactory()); + hhReader.readData(householdFile); + + String personFile = properties.main.baseDirectory + properties.householdData.personFileName; + personFile += "_" + year + ".csv"; + PersonReader personReader = new PersonReaderMucDisability(dataContainer.getHouseholdDataManager(), new DefaultDisabilityStrategy()); + personReader.readData(personFile); + + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager(), new DwellingFactoryImpl()); + String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; + ddReader.readData(dwellingsFile); + + new JobType(properties.jobData.jobTypes); + JobReader jjReader = new JobReaderMuc(dataContainer.getJobDataManager(), (JobFactoryMuc) dataContainer.getJobDataManager().getFactory()); + String jobsFile = properties.main.baseDirectory + properties.jobData.jobsFileName + "_" + year + ".csv"; + jjReader.readData(jobsFile); + + SchoolReader ssReader = new SchoolReaderImpl(dataContainer.getSchoolData()); + String schoolsFile = properties.main.baseDirectory + properties.schoolData.schoolsFileName + "_" + year + ".csv"; + ssReader.readData(schoolsFile); + } +} \ No newline at end of file diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonFactoryMucDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonFactoryMucDisability.java new file mode 100644 index 000000000..6ed2b700e --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonFactoryMucDisability.java @@ -0,0 +1,40 @@ +package de.tum.bgu.msm.scenarios.disabilities; + +import de.tum.bgu.msm.data.person.*; + +public class PersonFactoryMucDisability implements PersonFactory { + + @Override + public PersonMucDisability createPerson(int id, int age, + Gender gender, Occupation occupation, + PersonRole role, int workplace, + int income) { + return new PersonMucDisability(id, age, gender, + occupation, role, workplace, + income); + } + + @Override + public Person giveBirth(Person parent, int id, Gender gender) { + PersonMucDisability pp = new PersonMucDisability(id, 0, gender, Occupation.TODDLER, PersonRole.CHILD, 0, 0); + pp.setNationality(((PersonMucDisability) parent).getNationality()); + pp.setDisability(((PersonMucDisability) parent).getDisability()); + return pp; + } + + //TODO duplicate as well school attributes + @Override + public PersonMucDisability duplicate(Person originalPerson, int id) { + PersonMucDisability duplicate = new PersonMucDisability(id, + originalPerson.getAge(), + originalPerson.getGender(), + originalPerson.getOccupation(), + originalPerson.getRole(), + -1, + originalPerson.getAnnualIncome()); + duplicate.setDriverLicense(originalPerson.hasDriverLicense()); + duplicate.setNationality(((PersonMucDisability)originalPerson).getNationality()); + duplicate.setDisability(((PersonMucDisability) originalPerson).getDisability()); + return duplicate; + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java new file mode 100644 index 000000000..17c209de6 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java @@ -0,0 +1,146 @@ +package de.tum.bgu.msm.scenarios.disabilities; + +import de.tum.bgu.msm.data.household.Household; +import de.tum.bgu.msm.data.person.*; +import de.tum.bgu.msm.schools.PersonWithSchool; + +public class PersonMucDisability implements PersonWithSchool { + + private final PersonMuc delegate; + + private Disability disability; + + PersonMucDisability(int id, int age, + Gender gender, Occupation occupation, + PersonRole role, int jobId, + int income) { + delegate = new PersonMuc(id, age, gender, occupation, role, jobId, income); + } + + @Override + public void setSchoolType(int schoolType) {delegate.setSchoolType(schoolType);} + + @Override + public int getSchoolType() {return delegate.getSchoolType();} + + @Override + public void setSchoolPlace(int schoolPlace) { + delegate.setSchoolPlace(schoolPlace); + } + + @Override + public int getSchoolPlace() {return delegate.getSchoolPlace();} + + @Override + public int getSchoolId() { + return delegate.getSchoolId(); + } + + @Override + public void setSchoolId(int schoolId) { + delegate.setSchoolId(schoolId); + } + + public void setNationality(Nationality nationality) { + delegate.setNationality(nationality); + } + + public Nationality getNationality() { + return delegate.getNationality(); + } + + + public Disability getDisability() { + return disability; + } + + public void setDisability(Disability disability) { + this.disability = disability; + } + + + @Override + public void setHousehold(Household householdId) { + delegate.setHousehold(householdId); + } + + @Override + public Household getHousehold() { + return delegate.getHousehold(); + } + + @Override + public void setRole(PersonRole pr) { + delegate.setRole(pr); + } + + @Override + public void birthday() { + delegate.birthday(); + } + + @Override + public void setIncome(int newIncome) { + delegate.setIncome(newIncome); + } + + @Override + public void setWorkplace(int newWorkplace) { + delegate.setWorkplace(newWorkplace); + } + + @Override + public void setOccupation(Occupation newOccupation) { + delegate.setOccupation(newOccupation); + } + + @Override + public int getId() { + return delegate.getId(); + } + + @Override + public int getAge() { + return delegate.getAge(); + } + + @Override + public Gender getGender() { + return delegate.getGender(); + } + + @Override + public Occupation getOccupation() { + return delegate.getOccupation(); + } + + @Override + public int getAnnualIncome() { + return delegate.getAnnualIncome(); + } + + @Override + public PersonType getType() { + return delegate.getType(); + } + + @Override + public PersonRole getRole() { + return delegate.getRole(); + } + + @Override + public int getJobId() { + return delegate.getJobId(); + } + + @Override + public void setDriverLicense(boolean driverLicense) { + delegate.setDriverLicense(driverLicense); + } + + @Override + public boolean hasDriverLicense() { + return delegate.hasDriverLicense(); + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/SiloMucDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/SiloMucDisability.java index e69de29bb..cc7299f1f 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/SiloMucDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/SiloMucDisability.java @@ -0,0 +1,94 @@ +package de.tum.bgu.msm.scenarios.disabilities; + +import de.tum.bgu.msm.ModelBuilderMuc; +import de.tum.bgu.msm.SiloModel; +import de.tum.bgu.msm.container.ModelContainer; +import de.tum.bgu.msm.schools.DataContainerWithSchoolsImpl; +import de.tum.bgu.msm.events.DisabilityEvent; +import de.tum.bgu.msm.io.*; +import de.tum.bgu.msm.io.output.*; +import de.tum.bgu.msm.models.disability.DefaultDisabilityStrategy; +import de.tum.bgu.msm.models.disability.DisabilityImpl; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.schools.SchoolsWriter; +import de.tum.bgu.msm.utils.SiloUtil; +import org.apache.log4j.Logger; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; + +/** + * Implements SILO for the Munich Metropolitan Area + * + * @author Rolf Moeckel and Ana Moreno + * Created on May 12, 2016 in Munich, Germany + */ +public class SiloMucDisability { + + private final static Logger logger = Logger.getLogger(SiloMucDisability.class); + + public static void main(String[] args) { + + Properties properties = SiloUtil.siloInitialization(args[0]); + + Config config = null; + if (args.length > 1 && args[1] != null) { + config = ConfigUtils.loadConfig(args[1]); + } + logger.info("Starting SILO land use model for the Munich Metropolitan Area"); + DataContainerWithSchoolsImpl dataContainer = DataBuilderDisability.getModelDataForMuc(properties, config); + DataBuilderDisability.read(properties, dataContainer); + //summarizeData(dataContainer, properties); + ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, config); + modelContainer.registerEventModel(DisabilityEvent.class, new DisabilityImpl(dataContainer, properties,new DefaultDisabilityStrategy(), SiloUtil.provideNewRandom())); + ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); + SiloModel model = new SiloModel(properties, dataContainer, modelContainer); + model.addResultMonitor(resultsMonitor); + model.runModel(); + logger.info("Finished SILO."); + } + + private static void summarizeData(DataContainerWithSchoolsImpl dataContainer, Properties properties){ + + String filehh = properties.main.baseDirectory + + properties.householdData.householdFileName + + "_" + + properties.main.baseYear + + "d.csv"; + HouseholdWriter hhwriter = new HouseholdWriterMucDisability(dataContainer.getHouseholdDataManager(),dataContainer.getRealEstateDataManager()); + hhwriter.writeHouseholds(filehh); + + String filepp = properties.main.baseDirectory + + properties.householdData.personFileName + + "_" + + properties.main.baseYear + + "d.csv"; + PersonWriter ppwriter = new PersonWriterMucDisability(dataContainer.getHouseholdDataManager()); + ppwriter.writePersons(filepp); + + String filedd = properties.main.baseDirectory + + properties.realEstate.dwellingsFileName + + "_" + + properties.main.baseYear + + "d.csv"; + DwellingWriter ddwriter = new DefaultDwellingWriter(dataContainer.getRealEstateDataManager()); + ddwriter.writeDwellings(filedd); + + String filejj = properties.main.baseDirectory + + properties.jobData.jobsFileName + + "_" + + properties.main.baseYear + + "d.csv"; + JobWriter jjwriter = new JobWriterMuc(dataContainer.getJobDataManager()); + jjwriter.writeJobs(filejj); + + + String fileee = properties.main.baseDirectory + + "ee" + + "_" + + properties.main.baseYear + + "d.csv"; + SchoolsWriter eewriter = new SchoolsWriter(dataContainer.getSchoolData()); + eewriter.writeSchools(fileee); + + } +} \ No newline at end of file diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java new file mode 100644 index 000000000..4bb0114a3 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java @@ -0,0 +1,286 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.Region; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingType; +import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; +import de.tum.bgu.msm.data.household.Household; +import de.tum.bgu.msm.data.household.HouseholdUtil; +import de.tum.bgu.msm.data.job.JobDataManager; +import de.tum.bgu.msm.data.job.JobMuc; +import de.tum.bgu.msm.data.person.Occupation; +import de.tum.bgu.msm.data.person.Person; +import de.tum.bgu.msm.data.travelTimes.TravelTimes; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; +import de.tum.bgu.msm.models.relocation.moves.HousingStrategy; +import org.matsim.api.core.v01.TransportMode; + +import java.util.Objects; + +/** + * This relocation model is based on a stated preference study by J.D. Hunt + *

+ * Hunt J.D. (2010) Stated Preference Examination of Factors Influencing Residential Attraction. + * In: Pagliara F., Preston J., Simmonds D. (eds) Residential Location Choice. + * Advances in Spatial Science (The Regional Science Series). + * Springer, Berlin, Heidelberg + * + * @author Nico + */ +public class HuntNoiseInsensitiveDwellingUtilityStrategy implements HousingStrategy { + + private static final double MEDIUM_NOISE_DISCOUNT = 0.056; + private static final double LOUD_NOISE_DISCOUNT = 0.096; + + private static final int LOW_INCOME = 1; + private static final int HIGH_INCOME = 2; + private static final int AVERAGE_INCOME = 0; + + private static final int NO_NOISE = 0; + private static final int OCCASIONALLY_NOTICEABLE_NOISE = 1; + private static final int CONSTANT_HUM_NOISE = 2; + private static final int SOMETIMES_DISTURBING_NOISE = 3; + private static final int FREQUENTLY_DISTURBING_NOISE = 4; + + private static final int SINGLE_FAMILY = 0; + private static final int DUPLEX = 1; + private static final int TOWNHOUSE = 2; + private static final int HIGHRISE = 4; + + //---------------------------------------------------------------------- + + /** + * Indices: + * [0] Single Family [1] Duplex [2] Townhouse [3] Walkup [4] Highrise + * [0] average + * [1] low inc + * [2] high inc + */ + private static double[][] dwellingTypeUtil = { + {0, -1.0570, -1.1130, -1.6340, -1.7940}, + {0, -0.8783, -0.9566, -0.9895, -0.9514}, + {0, -1.0570, -1.1130, -1.6340, -1.7940} + }; + + + //---------------------------------------------------------------------- + + /** + * Indices: + * [0] Never bad [1] Bad 1 day per year [2] Bad 1 day per month [3] Bad 1 day per week + * [0] average + * [1] low inc + * [2] high inc + */ + private static double[][] airQualityUtilAvg = { + {0, -0.2446, -0.5092, -0.9796}, + {0, -0.2299, -0.5264, -0.8504}, + {0, -0.3073, -0.2879, -1.3150} + }; + + + /** + * Indices: + * [0] None [1] Occasionally just noticeable [2] Constant faint hum [3] Sometimes Disturbing [4] Frequently disturbing + * [0] average + * [1] low inc + * [2] high inc + */ + private static double[][] trafficNoiseUtil = { + {0, -0.1694, -0.7165, -0.5348, -1.35}, + {0, -0.2758, -0.8354, -0.6934, -1.0250}, + {0, -0.3192, -0.9886, -1.0180, -1.8230} + }; + + //---------------------------------------------------------------------- + + //---------------------------------------------------------------------- + + private final static double[] rentUtilPer100Increase = {-0.8033, -1.2260, -0.6665}; + + private final static double[] travelTimeUtilPer10minIncreaseAvg = {-0.1890, -0.1170, -0.3613}; + + private final static double[] travelTimeTransitUtilPer10minIncreaseAvg = {-0.0974, -0.1253, -0.1246}; + + private final TravelTimes travelTimes; + private final JobDataManager jobDataManager; + private final RealEstateDataManager realEstateDataManager; + + //use delegate for regional and current satisfaction decisions + private final HousingStrategy delegate; + + public HuntNoiseInsensitiveDwellingUtilityStrategy(TravelTimes travelTimes, + JobDataManager jobDataManager, + RealEstateDataManager realEstateDataManager, HousingStrategy delegate) { + this.travelTimes = travelTimes; + this.jobDataManager = jobDataManager; + this.realEstateDataManager = realEstateDataManager; + this.delegate = delegate; + } + + @Override + public void setup() { + delegate.setup(); + } + + @Override + public boolean isHouseholdEligibleToLiveHere(Household household, Dwelling dd) { + int numberOfPersons = household.getHhSize(); + int numberOfBedrooms = dd.getBedrooms(); + return (numberOfBedrooms + 1 >= numberOfPersons); + } + + @Override + public double calculateHousingUtility(Household hh, Dwelling dwelling) { + NoiseDwelling oldDwelling = (NoiseDwelling) realEstateDataManager.getDwelling(hh.getDwellingId()); + if(oldDwelling == null || oldDwelling.equals(dwelling)) { + return delegate.calculateHousingUtility(hh, dwelling); + } else { + return calculateUtilityAlternative(hh, oldDwelling, (NoiseDwelling) dwelling); + } + } + + @Override + public double calculateSelectDwellingProbability(double util) { + return Math.exp(util); + } + + @Override + public double calculateSelectRegionProbability(double util) { + return delegate.calculateSelectRegionProbability(util); + } + + @Override + public void prepareYear() { + delegate.prepareYear(); + } + + @Override + public double calculateRegionalUtility(Household household, Region region) { + return delegate.calculateRegionalUtility(household, region); + } + + @Override + public HousingStrategy duplicate() { + HuntNoiseInsensitiveDwellingUtilityStrategy duplicate = + new HuntNoiseInsensitiveDwellingUtilityStrategy(this.travelTimes.duplicate(), + jobDataManager, realEstateDataManager, delegate.duplicate()); + return duplicate; + } + + private double calculateUtilityAlternative(Household household, NoiseDwelling oldDwelling, NoiseDwelling newDwelling) { + final double oldPrice = getNoiseAdjustedPrice(oldDwelling); + final double newPrice = getNoiseAdjustedPrice(newDwelling); + + + double oldCarTravelTime = 0; + double oldPtTravelTime = 0; + for (Person pp : household.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); + oldCarTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.car); + oldPtTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.pt); + break; + } + } + + double newCarTravelTime = 0; + double newPtTravelTime = 0; + for (Person pp : household.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); + newCarTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.car); + newPtTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.pt); + break; + } + } + + final double util = calculateUtilityForAlternative(household, newDwelling, newPrice-oldPrice, newCarTravelTime-oldCarTravelTime, newPtTravelTime-oldPtTravelTime); + return util; + } + + private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { + double price = dwelling.getPrice(); + return price; + } + + double calculateCurrentUtility(Household household, NoiseDwelling dwelling) { + + double price = dwelling.getPrice(); + final double noiseImmission = dwelling.getNoiseImmission(); + if (noiseImmission > 55) { + if (noiseImmission > 65) { + price *= (1 - LOUD_NOISE_DISCOUNT); + } else { + price *= (1 - MEDIUM_NOISE_DISCOUNT); + } + } + + double carTravelTime = 0; + double ptTravelTime = 0; + for (Person pp : household.getPersons().values()) { + if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { + JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); + carTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.car); + ptTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.pt); + break; + } + } + + final double util = calculateUtilityForAlternative(household, dwelling, price, carTravelTime, ptTravelTime); + return util; + } + + private double calculateUtilityForAlternative(Household household, NoiseDwelling dwelling, + double priceDiff, double carTravelTimeDiff, double ptTravelTimeDiff) { + int hhType = translateHouseholdType(household); + int ddType = translateDwellingType(dwelling); + int noiseCat = translateLdenToNoiseCategory(dwelling.getNoiseImmission()); + + double dwellingUtil = dwellingTypeUtil[hhType][ddType]; + double noiseUtil = trafficNoiseUtil[hhType][noiseCat]; + double priceUtil = (priceDiff / 100.) * rentUtilPer100Increase[hhType]; + double carTravelTimeUtil = travelTimeUtilPer10minIncreaseAvg[hhType] * (carTravelTimeDiff / 10.); + double ptTravelTimeUtil = travelTimeTransitUtilPer10minIncreaseAvg[hhType] * (ptTravelTimeDiff / 10.); + final double airQualityUtil = 0; + return dwellingUtil + airQualityUtil + noiseUtil + priceUtil + carTravelTimeUtil + ptTravelTimeUtil; + } + + private int translateDwellingType(Dwelling dwelling) { + final DwellingType type = dwelling.getType(); + + if(type.equals(DefaultDwellingTypeImpl.SFD)) { + return SINGLE_FAMILY; + } else if( type.equals(DefaultDwellingTypeImpl.SFA)) { + return DUPLEX; + } else if(type.equals(DefaultDwellingTypeImpl.MF234)) { + return TOWNHOUSE; + } else if(type.equals(DefaultDwellingTypeImpl.MF5plus)) { + return HIGHRISE; + } else { + //can only happen for mobile home which shouldn't exist in muc + return HIGHRISE; + } + } + + + private int translateLdenToNoiseCategory(double lden) { + return NO_NOISE; + } + + /** + * Adjusted to euro (1CAD ~ 0.68€) + */ + private int translateHouseholdType(Household household) { + final int annualHhIncome = HouseholdUtil.getAnnualHhIncome(household); + if (annualHhIncome < 15000) { + return LOW_INCOME; + } else if (annualHhIncome < 68500) { + return AVERAGE_INCOME; + } else { + return HIGH_INCOME; + } + } +} + diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java index 20edef153..fd875055f 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -18,6 +18,8 @@ import java.util.Objects; +import static de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl.MF234; + /** * This relocation model is based on a stated preference study by J.D. Hunt *

@@ -60,7 +62,7 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg private static double[][] dwellingTypeUtil = { {0, -1.0570, -1.1130, -1.6340, -1.7940}, {0, -0.8783, -0.9566, -0.9895, -0.9514}, - {0, -1.0570, -1.1130, -1.6340, -1.7940} + {0, -1.922, -2.035, -2.841, -2.729} }; @@ -126,9 +128,10 @@ public void setup() { @Override public boolean isHouseholdEligibleToLiveHere(Household household, Dwelling dd) { - int numberOfPersons = household.getHhSize(); - int numberOfBedrooms = dd.getBedrooms(); - return (numberOfBedrooms + 1 >= numberOfPersons); +// int numberOfPersons = household.getHhSize(); +//// int numberOfBedrooms = dd.getBedrooms(); +//// return (numberOfBedrooms + 1 >= numberOfPersons); + return true; } @Override @@ -179,8 +182,8 @@ private double calculateUtilityAlternative(Household household, NoiseDwelling ol for (Person pp : household.getPersons().values()) { if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); - oldCarTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); - oldPtTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + oldCarTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.car); + oldPtTravelTime = (int) travelTimes.getTravelTime(oldDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.pt); break; } } @@ -190,8 +193,8 @@ private double calculateUtilityAlternative(Household household, NoiseDwelling ol for (Person pp : household.getPersons().values()) { if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); - newCarTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); - newPtTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + newCarTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.car); + newPtTravelTime = (int) travelTimes.getTravelTime(newDwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.pt); break; } } @@ -201,14 +204,17 @@ private double calculateUtilityAlternative(Household household, NoiseDwelling ol } private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { - double price = dwelling.getPrice(); + double price = dwelling.getPrice() / 0.68; final double noiseImmission = dwelling.getNoiseImmission(); - if (noiseImmission > 55) { - if (noiseImmission > 65) { - price *= (1 - LOUD_NOISE_DISCOUNT); - } else { - price *= (1 - MEDIUM_NOISE_DISCOUNT); - } +// if (noiseImmission > 55) { +// if (noiseImmission > 65) { +// price *= (1 - LOUD_NOISE_DISCOUNT); +// } else { +// price *= (1 - MEDIUM_NOISE_DISCOUNT); +// } +// } + if(noiseImmission > 50) { + price -= price * ((noiseImmission - 50) * 0.004); } return price; } @@ -217,12 +223,13 @@ private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { double price = dwelling.getPrice(); final double noiseImmission = dwelling.getNoiseImmission(); - if (noiseImmission > 55) { - if (noiseImmission > 65) { - price *= (1 - LOUD_NOISE_DISCOUNT); - } else { - price *= (1 - MEDIUM_NOISE_DISCOUNT); - } + if (noiseImmission > 50) { + price -= price * ((noiseImmission - 50) * 0.004); +// if (noiseImmission > 65) { +// price *= (1 - LOUD_NOISE_DISCOUNT); +// } else { +// price *= (1 - MEDIUM_NOISE_DISCOUNT); +// } } double carTravelTime = 0; @@ -230,8 +237,8 @@ private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { for (Person pp : household.getPersons().values()) { if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); - carTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.car); - ptTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds(), TransportMode.pt); + carTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.car); + ptTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.pt); break; } } @@ -256,13 +263,15 @@ private double calculateUtilityForAlternative(Household household, NoiseDwelling } private int translateDwellingType(Dwelling dwelling) { - final DwellingType type = dwelling.getType(); +// final DwellingType type = dwelling.getType(); + final DwellingType type = MF234; + if(type.equals(DefaultDwellingTypeImpl.SFD)) { return SINGLE_FAMILY; } else if( type.equals(DefaultDwellingTypeImpl.SFA)) { return DUPLEX; - } else if(type.equals(DefaultDwellingTypeImpl.MF234)) { + } else if(type.equals(MF234)) { return TOWNHOUSE; } else if(type.equals(DefaultDwellingTypeImpl.MF5plus)) { return HIGHRISE; @@ -276,13 +285,15 @@ private int translateDwellingType(Dwelling dwelling) { private int translateLdenToNoiseCategory(double lden) { if (lden < 30) { return NO_NOISE; - } else if (lden < 45) { + } else if (lden < 50) { return OCCASIONALLY_NOTICEABLE_NOISE; - } else if (lden < 55) { + } else if (lden < 60) { return CONSTANT_HUM_NOISE; - } else if (lden < 65) { - return SOMETIMES_DISTURBING_NOISE; - } else { + } +// else if (lden < 65) { +// return SOMETIMES_DISTURBING_NOISE; +// } + else { return FREQUENTLY_DISTURBING_NOISE; } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java index b2aeb7b8e..4763c2f09 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -5,10 +5,7 @@ import de.tum.bgu.msm.data.household.HouseholdFactory; import de.tum.bgu.msm.data.mito.MitoDataConverterMuc; import de.tum.bgu.msm.data.person.PersonFactory; -import de.tum.bgu.msm.matsim.MatsimScenarioAssembler; -import de.tum.bgu.msm.matsim.MatsimTransportModel; -import de.tum.bgu.msm.matsim.SimpleMatsimScenarioAssembler; -import de.tum.bgu.msm.matsim.ZoneConnectorManager; +import de.tum.bgu.msm.matsim.*; import de.tum.bgu.msm.matsim.noise.NoiseModel; import de.tum.bgu.msm.mito.MitoMatsimScenarioAssembler; import de.tum.bgu.msm.models.EducationModelMuc; @@ -58,7 +55,9 @@ import de.tum.bgu.msm.models.relocation.moves.*; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.utils.SiloUtil; +import org.matsim.api.core.v01.Scenario; import org.matsim.core.config.Config; +import org.matsim.core.scenario.ScenarioUtils; public class ModelBuilderMucNoise { @@ -112,11 +111,11 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data properties, new DefaultConstructionLocationStrategy(), new ConstructionDemandStrategyMuc(), SiloUtil.provideNewRandom()); - PricingModel pricing = new PricingModelImpl(dataContainer, properties, new DefaultPricingStrategy(), SiloUtil.provideNewRandom()); +// PricingModel pricing = new PricingModelImpl(dataContainer, properties, new DefaultPricingStrategy(), SiloUtil.provideNewRandom()); RenovationModel renovation = new RenovationModelImpl(dataContainer, properties, new DefaultRenovationStrategy(), SiloUtil.provideNewRandom()); - ConstructionOverwrite constructionOverwrite = new ConstructionOverwriteImpl(dataContainer, ddFactory, properties, SiloUtil.provideNewRandom()); +// ConstructionOverwrite constructionOverwrite = new ConstructionOverwriteImpl(dataContainer, ddFactory, properties, SiloUtil.provideNewRandom()); InOutMigration inOutMigration = new InOutMigrationMuc(dataContainer, employmentModel, movesModel, carOwnershipModel, driversLicenseModel, properties); @@ -129,17 +128,20 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data MatsimTransportModel transportModel; + MatsimData matsimData = null; + if (config != null) { + final Scenario scenario = ScenarioUtils.loadScenario(config); + matsimData = new MatsimData(config, properties, ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, dataContainer, scenario.getNetwork(), scenario.getTransitSchedule()); + } switch (properties.transportModel.transportModelIdentifier) { case MITO_MATSIM: MatsimScenarioAssembler delegate = new MitoMatsimScenarioAssembler(dataContainer, properties, new MitoDataConverterMuc()); - transportModel = new MatsimTransportModel(dataContainer, config, properties, null, - ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, delegate); + transportModel = new MatsimTransportModel(dataContainer, config, properties, delegate, matsimData); break; case MATSIM: delegate = new SimpleMatsimScenarioAssembler(dataContainer, properties); - transportModel = new MatsimTransportModel(dataContainer, config, properties, null, - ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, delegate); + transportModel = new MatsimTransportModel(dataContainer, config, properties, delegate, matsimData); break; case NONE: default: @@ -155,8 +157,8 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data divorceModel, driversLicenseModel, educationModel, employmentModel, leaveParentsModel, jobMarketUpdateModel, - construction, demolition, pricing, renovation, - constructionOverwrite, inOutMigration, movesModel, transportModel); + construction, demolition, null, renovation, + null, inOutMigration, movesModel, transportModel); modelContainer.registerModelUpdateListener(new UpdateCarOwnershipModelMuc(dataContainer, properties, SiloUtil.provideNewRandom())); modelContainer.registerModelUpdateListener(noiseModel); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java new file mode 100644 index 000000000..371c000ca --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java @@ -0,0 +1,168 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.container.ModelContainer; +import de.tum.bgu.msm.data.dwelling.DwellingFactory; +import de.tum.bgu.msm.data.household.HouseholdFactory; +import de.tum.bgu.msm.data.mito.MitoDataConverterMuc; +import de.tum.bgu.msm.data.person.PersonFactory; +import de.tum.bgu.msm.matsim.*; +import de.tum.bgu.msm.matsim.noise.NoiseModel; +import de.tum.bgu.msm.mito.MitoMatsimScenarioAssembler; +import de.tum.bgu.msm.models.EducationModelMuc; +import de.tum.bgu.msm.models.MarriageModelMuc; +import de.tum.bgu.msm.models.autoOwnership.CreateCarOwnershipModel; +import de.tum.bgu.msm.models.carOwnership.CreateCarOwnershipModelMuc; +import de.tum.bgu.msm.models.carOwnership.UpdateCarOwnershipModelMuc; +import de.tum.bgu.msm.models.construction.ConstructionDemandStrategyMuc; +import de.tum.bgu.msm.models.demography.birth.BirthModelImpl; +import de.tum.bgu.msm.models.demography.birth.DefaultBirthStrategy; +import de.tum.bgu.msm.models.demography.birthday.BirthdayModel; +import de.tum.bgu.msm.models.demography.birthday.BirthdayModelImpl; +import de.tum.bgu.msm.models.demography.death.DeathModel; +import de.tum.bgu.msm.models.demography.death.DeathModelImpl; +import de.tum.bgu.msm.models.demography.death.DefaultDeathStrategy; +import de.tum.bgu.msm.models.demography.divorce.DefaultDivorceStrategy; +import de.tum.bgu.msm.models.demography.divorce.DivorceModel; +import de.tum.bgu.msm.models.demography.divorce.DivorceModelImpl; +import de.tum.bgu.msm.models.demography.driversLicense.DefaultDriversLicenseStrategy; +import de.tum.bgu.msm.models.demography.driversLicense.DriversLicenseModel; +import de.tum.bgu.msm.models.demography.driversLicense.DriversLicenseModelImpl; +import de.tum.bgu.msm.models.demography.education.EducationModel; +import de.tum.bgu.msm.models.demography.employment.EmploymentModel; +import de.tum.bgu.msm.models.demography.employment.EmploymentModelImpl; +import de.tum.bgu.msm.models.demography.leaveParentalHousehold.DefaultLeaveParentalHouseholdStrategy; +import de.tum.bgu.msm.models.demography.leaveParentalHousehold.LeaveParentHhModel; +import de.tum.bgu.msm.models.demography.leaveParentalHousehold.LeaveParentHhModelImpl; +import de.tum.bgu.msm.models.demography.marriage.DefaultMarriageStrategy; +import de.tum.bgu.msm.models.demography.marriage.MarriageModel; +import de.tum.bgu.msm.models.jobmography.JobMarketUpdate; +import de.tum.bgu.msm.models.jobmography.JobMarketUpdateImpl; +import de.tum.bgu.msm.models.realEstate.construction.*; +import de.tum.bgu.msm.models.realEstate.demolition.DefaultDemolitionStrategy; +import de.tum.bgu.msm.models.realEstate.demolition.DemolitionModel; +import de.tum.bgu.msm.models.realEstate.demolition.DemolitionModelImpl; +import de.tum.bgu.msm.models.realEstate.pricing.DefaultPricingStrategy; +import de.tum.bgu.msm.models.realEstate.pricing.PricingModel; +import de.tum.bgu.msm.models.realEstate.pricing.PricingModelImpl; +import de.tum.bgu.msm.models.realEstate.renovation.DefaultRenovationStrategy; +import de.tum.bgu.msm.models.realEstate.renovation.RenovationModel; +import de.tum.bgu.msm.models.realEstate.renovation.RenovationModelImpl; +import de.tum.bgu.msm.models.relocation.DwellingUtilityStrategyImpl; +import de.tum.bgu.msm.models.relocation.HousingStrategyMuc; +import de.tum.bgu.msm.models.relocation.InOutMigrationMuc; +import de.tum.bgu.msm.models.relocation.RegionUtilityStrategyMucImpl; +import de.tum.bgu.msm.models.relocation.migration.InOutMigration; +import de.tum.bgu.msm.models.relocation.moves.*; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.utils.SiloUtil; +import org.matsim.api.core.v01.Scenario; +import org.matsim.core.config.Config; +import org.matsim.core.scenario.ScenarioUtils; + +public class ModelBuilderMucNoiseInsensitive { + + public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl dataContainer, Properties properties, Config config) { + + PersonFactory ppFactory = dataContainer.getHouseholdDataManager().getPersonFactory(); + HouseholdFactory hhFactory = dataContainer.getHouseholdDataManager().getHouseholdFactory(); + DwellingFactory ddFactory = dataContainer.getRealEstateDataManager().getDwellingFactory(); + + final BirthModelImpl birthModel = new BirthModelImpl(dataContainer, ppFactory, properties, new DefaultBirthStrategy(), SiloUtil.provideNewRandom()); + + BirthdayModel birthdayModel = new BirthdayModelImpl(dataContainer, properties, SiloUtil.provideNewRandom()); + + DeathModel deathModel = new DeathModelImpl(dataContainer, properties, new DefaultDeathStrategy(), SiloUtil.provideNewRandom()); + + + HousingStrategy housingStrategyDelegate + = new HousingStrategyMuc(dataContainer, properties, + dataContainer.getTravelTimes(), new DefaultDwellingProbabilityStrategy(), + new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), + new RegionProbabilityStrategyImpl()); + + HuntNoiseInsensitiveDwellingUtilityStrategy housingStrategy + = new HuntNoiseInsensitiveDwellingUtilityStrategy(dataContainer.getTravelTimes(), + dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), + housingStrategyDelegate); + + MovesModelImpl movesModel = new MovesModelImpl( + dataContainer, properties, + new DefaultMovesStrategy(), + housingStrategy, SiloUtil.provideNewRandom()); + + CreateCarOwnershipModel carOwnershipModel = new CreateCarOwnershipModelMuc(dataContainer); + + DivorceModel divorceModel = new DivorceModelImpl( + dataContainer, movesModel, carOwnershipModel, hhFactory, + properties, new DefaultDivorceStrategy(), SiloUtil.provideNewRandom()); + + DriversLicenseModel driversLicenseModel = new DriversLicenseModelImpl(dataContainer, properties, new DefaultDriversLicenseStrategy(), SiloUtil.provideNewRandom()); + + EducationModel educationModel = new EducationModelMuc(dataContainer, properties, SiloUtil.provideNewRandom()); + + EmploymentModel employmentModel = new EmploymentModelImpl(dataContainer, properties, SiloUtil.provideNewRandom()); + + LeaveParentHhModel leaveParentsModel = new LeaveParentHhModelImpl(dataContainer, movesModel, + carOwnershipModel, hhFactory, properties, new DefaultLeaveParentalHouseholdStrategy(), SiloUtil.provideNewRandom()); + + JobMarketUpdate jobMarketUpdateModel = new JobMarketUpdateImpl(dataContainer, properties, SiloUtil.provideNewRandom()); + + ConstructionModel construction = new ConstructionModelImpl(dataContainer, ddFactory, + properties, new DefaultConstructionLocationStrategy(), new ConstructionDemandStrategyMuc(), SiloUtil.provideNewRandom()); + + + PricingModel pricing = new PricingModelImpl(dataContainer, properties, new DefaultPricingStrategy(), SiloUtil.provideNewRandom()); + + RenovationModel renovation = new RenovationModelImpl(dataContainer, properties, new DefaultRenovationStrategy(), SiloUtil.provideNewRandom()); + + ConstructionOverwrite constructionOverwrite = new ConstructionOverwriteImpl(dataContainer, ddFactory, properties, SiloUtil.provideNewRandom()); + + InOutMigration inOutMigration = new InOutMigrationMuc(dataContainer, employmentModel, movesModel, + carOwnershipModel, driversLicenseModel, properties); + + DemolitionModel demolition = new DemolitionModelImpl(dataContainer, movesModel, + inOutMigration, properties, new DefaultDemolitionStrategy(), SiloUtil.provideNewRandom()); + + MarriageModel marriageModel = new MarriageModelMuc(dataContainer, movesModel, inOutMigration, + carOwnershipModel, hhFactory, properties, new DefaultMarriageStrategy(), SiloUtil.provideNewRandom()); + + + MatsimTransportModel transportModel; + MatsimData matsimData = null; + if (config != null) { + final Scenario scenario = ScenarioUtils.loadScenario(config); + matsimData = new MatsimData(config, properties, ZoneConnectorManager.ZoneConnectorMethod.WEIGHTED_BY_POPULATION, dataContainer, scenario.getNetwork(), scenario.getTransitSchedule()); + } + switch (properties.transportModel.transportModelIdentifier) { + case MITO_MATSIM: + MatsimScenarioAssembler delegate = new MitoMatsimScenarioAssembler(dataContainer, properties, new MitoDataConverterMuc()); + transportModel = new MatsimTransportModel(dataContainer, config, properties, delegate, matsimData); + break; + case MATSIM: + delegate = new SimpleMatsimScenarioAssembler(dataContainer, properties); + + transportModel = new MatsimTransportModel(dataContainer, config, properties, delegate, matsimData); + break; + case NONE: + default: + transportModel = null; + } + NoiseModel noiseModel = new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom(), transportModel.getMatsimData()); + + + + final ModelContainer modelContainer = new ModelContainer( + birthModel, birthdayModel, + deathModel, marriageModel, + divorceModel, driversLicenseModel, + educationModel, employmentModel, + leaveParentsModel, jobMarketUpdateModel, + construction, demolition, pricing, renovation, + constructionOverwrite, inOutMigration, movesModel, transportModel); + + modelContainer.registerModelUpdateListener(new UpdateCarOwnershipModelMuc(dataContainer, properties, SiloUtil.provideNewRandom())); + modelContainer.registerModelUpdateListener(noiseModel); + + return modelContainer; + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java new file mode 100644 index 000000000..16a9fc80d --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java @@ -0,0 +1,37 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.SiloModel; +import de.tum.bgu.msm.SiloMuc; +import de.tum.bgu.msm.container.ModelContainer; +import de.tum.bgu.msm.io.ResultsMonitorMuc; +import de.tum.bgu.msm.io.output.ResultsMonitor; +import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.utils.SiloUtil; +import org.apache.log4j.Logger; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; + +public class SiloMucNoiseInsensitive { + + private final static Logger logger = Logger.getLogger(SiloMuc.class); + + public static void main(String[] args) { + + Properties properties = SiloUtil.siloInitialization(args[0]); + + Config config = null; + if (args.length > 1 && args[1] != null) { + config = ConfigUtils.loadConfig(args[1]); + } + logger.info("Started SILO land use model for the Munich Metropolitan Area"); + NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); + DataBuilderNoise.read(properties, dataContainer); + ModelContainer modelContainer = ModelBuilderMucNoiseInsensitive.getModelContainerForMuc(dataContainer, properties, config); +// modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); + ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); + SiloModel model = new SiloModel(properties, dataContainer, modelContainer); + model.addResultMonitor(resultsMonitor); + model.runModel(); + logger.info("Finished SILO."); + } +} diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java index 0b8908051..05d1627f8 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java @@ -5,6 +5,8 @@ import de.tum.bgu.msm.data.dwelling.DwellingFactoryImpl; import de.tum.bgu.msm.data.dwelling.DwellingImpl; import de.tum.bgu.msm.data.household.Household; +import de.tum.bgu.msm.data.person.Person; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.utils.SiloUtil; import org.junit.Test; @@ -32,8 +34,20 @@ public void test() { dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); int hhid = 1249939; final Household household = dataContainer.getHouseholdDataManager().getHouseholdFromId(hhid); - Dwelling dwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 1000, 1990)); - strategy.calculateHousingUtility(household, dwelling); + for(Person p: household.getPersons().values()) { + p.setIncome(p.getAnnualIncome()+50000); + } + NoiseDwelling quietDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); + quietDwelling.setNoiseImmision(40); + final double v = strategy.calculateHousingUtility(household, quietDwelling); + + NoiseDwelling noiseDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); + noiseDwelling.setNoiseImmision(60); + final double v1 = strategy.calculateHousingUtility(household, noiseDwelling); + + NoiseDwelling noiseDwelling2 = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); + noiseDwelling2.setNoiseImmision(66); + final double v2 = strategy.calculateHousingUtility(household, noiseDwelling2); } diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java index 3a474647f..9bc2ee8a1 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -2,13 +2,28 @@ import de.tum.bgu.msm.SiloModel; import de.tum.bgu.msm.container.ModelContainer; +import de.tum.bgu.msm.data.Location; +import de.tum.bgu.msm.data.Region; +import de.tum.bgu.msm.data.Zone; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingFactoryImpl; +import de.tum.bgu.msm.data.dwelling.DwellingImpl; +import de.tum.bgu.msm.data.household.Household; +import de.tum.bgu.msm.data.household.HouseholdMuc; +import de.tum.bgu.msm.data.person.Gender; +import de.tum.bgu.msm.data.person.Occupation; +import de.tum.bgu.msm.data.person.PersonMuc; +import de.tum.bgu.msm.data.person.PersonRole; +import de.tum.bgu.msm.data.travelTimes.TravelTimes; import de.tum.bgu.msm.io.ResultsMonitorMuc; import de.tum.bgu.msm.io.output.ResultsMonitor; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; import de.tum.bgu.msm.matsim.noise.NoiseModel; +import de.tum.bgu.msm.models.ModelUpdateListener; import de.tum.bgu.msm.properties.Properties; -import de.tum.bgu.msm.scenarios.noise.DataBuilderNoise; -import de.tum.bgu.msm.scenarios.noise.ModelBuilderMucNoise; -import de.tum.bgu.msm.scenarios.noise.NoiseDataContainerImpl; +import de.tum.bgu.msm.scenarios.noise.*; +import de.tum.bgu.msm.util.matrices.IndexedDoubleMatrix2D; import de.tum.bgu.msm.utils.SiloUtil; import org.apache.log4j.Logger; import org.junit.Rule; @@ -17,7 +32,9 @@ import org.matsim.core.config.ConfigUtils; import org.matsim.testcases.MatsimTestUtils; -import java.io.File; +import java.io.*; +import java.util.List; +import java.util.Random; public class SiloNoiseTest { @@ -27,7 +44,7 @@ public class SiloNoiseTest { private static final Logger log = Logger.getLogger(SiloMatsimMucTest.class); @Test - public final void testMain() { + public final void testMain() throws IOException { String path = "./test/muc/siloMatsimMucTest.properties"; Config config = ConfigUtils.loadConfig("./test/muc/matsim_input/config.xml") ; @@ -50,8 +67,85 @@ public final void testMain() { DataBuilderNoise.read(properties, dataContainer); ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); - SiloModel model = new SiloModel(properties, dataContainer, modelContainer); - model.addResultMonitor(resultsMonitor); - model.runModel(); + + final List modelUpdateListeners = modelContainer.getModelUpdateListeners(); + for(ModelUpdateListener listenr: modelUpdateListeners) { + if(listenr instanceof NoiseModel) { + listenr.endYear(2011); + } + } + + NoiseDwelling refDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(1, 20, null, -1, DefaultDwellingTypeImpl.MF234, 1, 1, 1000, 1980)); + refDwelling.setNoiseImmision(45); + + Household poor = new HouseholdMuc(1, 1, 2); + poor.addPerson(new PersonMuc(1, 23, Gender.MALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 6000)); + poor.addPerson(new PersonMuc(2, 23, Gender.FEMALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 6000)); + + + Household rich = new HouseholdMuc(2, 1, 2); + rich.addPerson(new PersonMuc(1, 23, Gender.MALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 35000)); + rich.addPerson(new PersonMuc(2, 23, Gender.FEMALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 35000)); + + Household avg = new HouseholdMuc(3, 1, 2); + avg.addPerson(new PersonMuc(1, 23, Gender.MALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 15000)); + avg.addPerson(new PersonMuc(2, 23, Gender.FEMALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 15000)); + + HuntNoiseSensitiveDwellingUtilityStrategy strategy = new HuntNoiseSensitiveDwellingUtilityStrategy(new TravelTimes() { + @Override + public double getTravelTime(Location location, Location location1, double v, String s) { + return 10; + } + + @Override + public double getTravelTimeFromRegion(Region region, Zone zone, double v, String s) { + return 10; + } + + @Override + public double getTravelTimeToRegion(Zone zone, Region region, double v, String s) { + return 10; + } + + @Override + public IndexedDoubleMatrix2D getPeakSkim(String s) { + return null; + } + + @Override + public TravelTimes duplicate() { + return null; + } + }, dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); + + BufferedWriter writer = new BufferedWriter(new FileWriter("C:/users/nico/desktop/noiseutil6.csv")); + writer.write("noise,price,type,poorUitl,mediumUtil,richUtil"); + writer.newLine(); + + Random random = new Random(42); + + dataContainer.getRealEstateDataManager().addDwelling(refDwelling); + for(Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { + ((NoiseDwelling)dwelling).setNoiseImmision(((NoiseDwelling) dwelling).getNoiseImmission()+random.nextInt(25)); + if(dwelling == refDwelling) { + continue; + } + dwelling.setPrice(1000); + + final double v = strategy.calculateHousingUtility(poor, dwelling); + final double v2 = strategy.calculateHousingUtility(avg, dwelling); + final double v3 = strategy.calculateHousingUtility(rich, dwelling); + writer.write(((NoiseDwelling)dwelling).getNoiseImmission()+","+dwelling.getPrice() + +","+dwelling.getType()+","+v+","+v2+","+v3); + writer.newLine(); + } + writer.flush(); + writer.close(); + + + +// SiloModel model = new SiloModel(properties, dataContainer, modelContainer); +// model.addResultMonitor(resultsMonitor); +// model.runModel(); } } From 4b0a425733a13449e110a329313dd31e839f5242 Mon Sep 17 00:00:00 2001 From: Nico Date: Tue, 7 Jan 2020 12:47:54 +0100 Subject: [PATCH 10/24] updates to noise model --- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 11 +++ ...iseInsensitiveDwellingUtilityStrategy.java | 89 ++----------------- ...NoiseSensitiveDwellingUtilityStrategy.java | 31 ++----- .../transportModel/matsim/SiloNoiseTest.java | 17 ++-- 4 files changed, 38 insertions(+), 110 deletions(-) diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 8f2917dfd..0bdbd44bf 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -166,6 +166,11 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setScaleFactor(20); config.qsim().setEndTime(24 * 60 * 60); + noiseParameters.setConsiderNoiseBarriers(true); + noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); + noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); + config.global().setCoordinateSystem("EPSG:31468"); + NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, outputDirectoryRoot); noiseOfflineCalculation.run(); } @@ -219,6 +224,12 @@ private void replayFromEvents(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setScaleFactor(20); config.qsim().setEndTime(24 * 60 * 60); + noiseParameters.setConsiderNoiseBarriers(true); + noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); + noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); + config.global().setCoordinateSystem("EPSG:31468"); + + NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, path.getParent().toString()); noiseOfflineCalculation.run(); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java index 4bb0114a3..859c91fe1 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java @@ -30,19 +30,10 @@ */ public class HuntNoiseInsensitiveDwellingUtilityStrategy implements HousingStrategy { - private static final double MEDIUM_NOISE_DISCOUNT = 0.056; - private static final double LOUD_NOISE_DISCOUNT = 0.096; - private static final int LOW_INCOME = 1; private static final int HIGH_INCOME = 2; private static final int AVERAGE_INCOME = 0; - private static final int NO_NOISE = 0; - private static final int OCCASIONALLY_NOTICEABLE_NOISE = 1; - private static final int CONSTANT_HUM_NOISE = 2; - private static final int SOMETIMES_DISTURBING_NOISE = 3; - private static final int FREQUENTLY_DISTURBING_NOISE = 4; - private static final int SINGLE_FAMILY = 0; private static final int DUPLEX = 1; private static final int TOWNHOUSE = 2; @@ -60,41 +51,10 @@ public class HuntNoiseInsensitiveDwellingUtilityStrategy implements HousingStrat private static double[][] dwellingTypeUtil = { {0, -1.0570, -1.1130, -1.6340, -1.7940}, {0, -0.8783, -0.9566, -0.9895, -0.9514}, - {0, -1.0570, -1.1130, -1.6340, -1.7940} + {0, -1.922, -2.035, -2.841, -2.729} }; - //---------------------------------------------------------------------- - - /** - * Indices: - * [0] Never bad [1] Bad 1 day per year [2] Bad 1 day per month [3] Bad 1 day per week - * [0] average - * [1] low inc - * [2] high inc - */ - private static double[][] airQualityUtilAvg = { - {0, -0.2446, -0.5092, -0.9796}, - {0, -0.2299, -0.5264, -0.8504}, - {0, -0.3073, -0.2879, -1.3150} - }; - - - /** - * Indices: - * [0] None [1] Occasionally just noticeable [2] Constant faint hum [3] Sometimes Disturbing [4] Frequently disturbing - * [0] average - * [1] low inc - * [2] high inc - */ - private static double[][] trafficNoiseUtil = { - {0, -0.1694, -0.7165, -0.5348, -1.35}, - {0, -0.2758, -0.8354, -0.6934, -1.0250}, - {0, -0.3192, -0.9886, -1.0180, -1.8230} - }; - - //---------------------------------------------------------------------- - //---------------------------------------------------------------------- private final static double[] rentUtilPer100Increase = {-0.8033, -1.2260, -0.6665}; @@ -126,9 +86,7 @@ public void setup() { @Override public boolean isHouseholdEligibleToLiveHere(Household household, Dwelling dd) { - int numberOfPersons = household.getHhSize(); - int numberOfBedrooms = dd.getBedrooms(); - return (numberOfBedrooms + 1 >= numberOfPersons); + return true; } @Override @@ -201,54 +159,26 @@ private double calculateUtilityAlternative(Household household, NoiseDwelling ol } private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { - double price = dwelling.getPrice(); - return price; - } - - double calculateCurrentUtility(Household household, NoiseDwelling dwelling) { - - double price = dwelling.getPrice(); - final double noiseImmission = dwelling.getNoiseImmission(); - if (noiseImmission > 55) { - if (noiseImmission > 65) { - price *= (1 - LOUD_NOISE_DISCOUNT); - } else { - price *= (1 - MEDIUM_NOISE_DISCOUNT); - } - } - - double carTravelTime = 0; - double ptTravelTime = 0; - for (Person pp : household.getPersons().values()) { - if (pp.getOccupation() == Occupation.EMPLOYED && pp.getJobId() != -2) { - JobMuc workLocation = Objects.requireNonNull((JobMuc) jobDataManager.getJobFromId(pp.getJobId())); - carTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.car); - ptTravelTime = (int) travelTimes.getTravelTime(dwelling, workLocation, workLocation.getStartTimeInSeconds().get(), TransportMode.pt); - break; - } - } - - final double util = calculateUtilityForAlternative(household, dwelling, price, carTravelTime, ptTravelTime); - return util; + return dwelling.getPrice() /0.68; } private double calculateUtilityForAlternative(Household household, NoiseDwelling dwelling, double priceDiff, double carTravelTimeDiff, double ptTravelTimeDiff) { int hhType = translateHouseholdType(household); int ddType = translateDwellingType(dwelling); - int noiseCat = translateLdenToNoiseCategory(dwelling.getNoiseImmission()); double dwellingUtil = dwellingTypeUtil[hhType][ddType]; - double noiseUtil = trafficNoiseUtil[hhType][noiseCat]; + double noiseUtil = 0; double priceUtil = (priceDiff / 100.) * rentUtilPer100Increase[hhType]; double carTravelTimeUtil = travelTimeUtilPer10minIncreaseAvg[hhType] * (carTravelTimeDiff / 10.); double ptTravelTimeUtil = travelTimeTransitUtilPer10minIncreaseAvg[hhType] * (ptTravelTimeDiff / 10.); - final double airQualityUtil = 0; - return dwellingUtil + airQualityUtil + noiseUtil + priceUtil + carTravelTimeUtil + ptTravelTimeUtil; + return dwellingUtil + noiseUtil + priceUtil + carTravelTimeUtil + ptTravelTimeUtil; } private int translateDwellingType(Dwelling dwelling) { final DwellingType type = dwelling.getType(); +// final DwellingType type = MF234; + if(type.equals(DefaultDwellingTypeImpl.SFD)) { return SINGLE_FAMILY; @@ -264,11 +194,6 @@ private int translateDwellingType(Dwelling dwelling) { } } - - private int translateLdenToNoiseCategory(double lden) { - return NO_NOISE; - } - /** * Adjusted to euro (1CAD ~ 0.68€) */ diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java index fd875055f..e30819dd6 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -68,18 +68,6 @@ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrateg //---------------------------------------------------------------------- - /** - * Indices: - * [0] Never bad [1] Bad 1 day per year [2] Bad 1 day per month [3] Bad 1 day per week - * [0] average - * [1] low inc - * [2] high inc - */ - private static double[][] airQualityUtilAvg = { - {0, -0.2446, -0.5092, -0.9796}, - {0, -0.2299, -0.5264, -0.8504}, - {0, -0.3073, -0.2879, -1.3150} - }; /** @@ -206,15 +194,12 @@ private double calculateUtilityAlternative(Household household, NoiseDwelling ol private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { double price = dwelling.getPrice() / 0.68; final double noiseImmission = dwelling.getNoiseImmission(); -// if (noiseImmission > 55) { -// if (noiseImmission > 65) { -// price *= (1 - LOUD_NOISE_DISCOUNT); -// } else { -// price *= (1 - MEDIUM_NOISE_DISCOUNT); -// } -// } - if(noiseImmission > 50) { - price -= price * ((noiseImmission - 50) * 0.004); + if (noiseImmission > 55) { + if (noiseImmission > 65) { + price *= (1 - LOUD_NOISE_DISCOUNT); + } else { + price *= (1 - MEDIUM_NOISE_DISCOUNT); + } } return price; } @@ -263,8 +248,8 @@ private double calculateUtilityForAlternative(Household household, NoiseDwelling } private int translateDwellingType(Dwelling dwelling) { -// final DwellingType type = dwelling.getType(); - final DwellingType type = MF234; + final DwellingType type = dwelling.getType(); +// final DwellingType type = MF234; if(type.equals(DefaultDwellingTypeImpl.SFD)) { diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java index 9bc2ee8a1..489c50058 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -91,7 +91,7 @@ public final void testMain() throws IOException { avg.addPerson(new PersonMuc(1, 23, Gender.MALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 15000)); avg.addPerson(new PersonMuc(2, 23, Gender.FEMALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 15000)); - HuntNoiseSensitiveDwellingUtilityStrategy strategy = new HuntNoiseSensitiveDwellingUtilityStrategy(new TravelTimes() { + final TravelTimes travelTimes = new TravelTimes() { @Override public double getTravelTime(Location location, Location location1, double v, String s) { return 10; @@ -116,10 +116,13 @@ public IndexedDoubleMatrix2D getPeakSkim(String s) { public TravelTimes duplicate() { return null; } - }, dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); + }; - BufferedWriter writer = new BufferedWriter(new FileWriter("C:/users/nico/desktop/noiseutil6.csv")); - writer.write("noise,price,type,poorUitl,mediumUtil,richUtil"); + HuntNoiseSensitiveDwellingUtilityStrategy strategy = new HuntNoiseSensitiveDwellingUtilityStrategy(travelTimes, dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); + HuntNoiseInsensitiveDwellingUtilityStrategy strategyIns = new HuntNoiseInsensitiveDwellingUtilityStrategy(travelTimes, dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); + + BufferedWriter writer = new BufferedWriter(new FileWriter("C:/users/nico/desktop/noiseutil9.csv")); + writer.write("noise,price,type,poorUitl,mediumUtil,richUtil,poorUitlIn,mediumUtilIn,richUtilIn"); writer.newLine(); Random random = new Random(42); @@ -135,8 +138,12 @@ public TravelTimes duplicate() { final double v = strategy.calculateHousingUtility(poor, dwelling); final double v2 = strategy.calculateHousingUtility(avg, dwelling); final double v3 = strategy.calculateHousingUtility(rich, dwelling); + + final double v4 = strategyIns.calculateHousingUtility(poor, dwelling); + final double v5 = strategyIns.calculateHousingUtility(avg, dwelling); + final double v6 = strategyIns.calculateHousingUtility(rich, dwelling); writer.write(((NoiseDwelling)dwelling).getNoiseImmission()+","+dwelling.getPrice() - +","+dwelling.getType()+","+v+","+v2+","+v3); + +","+dwelling.getType()+","+v+","+v2+","+v3+","+v4+","+v5+","+v6); writer.newLine(); } writer.flush(); From 95de370f6b2b4d34621c77e4cd65314ba7c106de Mon Sep 17 00:00:00 2001 From: dziemke Date: Thu, 23 Jan 2020 12:38:16 +0100 Subject: [PATCH 11/24] switch to weekly release --- siloCore/pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/siloCore/pom.xml b/siloCore/pom.xml index 5f8019200..d0f6bcb71 100644 --- a/siloCore/pom.xml +++ b/siloCore/pom.xml @@ -411,7 +411,7 @@ ${buildNumber} false - 12.0-SNAPSHOT + 12.0-2020w02-SNAPSHOT 1.8 1.8 1.8 From 0c030909881c7ea52eb8d82d346cd8e07f85be16 Mon Sep 17 00:00:00 2001 From: Nico Date: Thu, 27 Feb 2020 14:32:12 +0100 Subject: [PATCH 12/24] put noise toll code in noiseModel --- .../src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 0bdbd44bf..96f8413a9 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -173,6 +173,10 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, outputDirectoryRoot); noiseOfflineCalculation.run(); + + NoiseContext noiseContext = noiseOfflineCalculation.getNoiseContext(); + NoiseTollCalculator tollCalculator = new NoiseTollCalculator(noiseContext); + tollCalculator.calculateExpectedTollDisutility(Id.createLinkId(123), 28800, null); } From 5798bdf67e318d1a7618154c9c4c15781f9c34df Mon Sep 17 00:00:00 2001 From: kainagel Date: Thu, 27 Feb 2020 15:40:54 +0100 Subject: [PATCH 13/24] react to changes in matsim --- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 346 +++++++++--------- 1 file changed, 179 insertions(+), 167 deletions(-) diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 96f8413a9..abde42201 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -1,5 +1,7 @@ package de.tum.bgu.msm.matsim.noise; +import com.google.inject.Key; +import com.google.inject.TypeLiteral; import de.tum.bgu.msm.container.DataContainer; import de.tum.bgu.msm.data.dwelling.Dwelling; import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; @@ -9,232 +11,242 @@ import de.tum.bgu.msm.properties.Properties; import org.apache.log4j.Logger; import org.matsim.api.core.v01.Id; +import org.matsim.api.core.v01.TransportMode; import org.matsim.contrib.noise.*; import org.matsim.core.config.Config; import org.matsim.core.config.ConfigUtils; +import org.matsim.core.controler.AbstractModule; +import org.matsim.core.controler.Injector; +import org.matsim.core.events.EventsManagerModule; import org.matsim.core.population.io.PopulationReader; +import org.matsim.core.router.costcalculators.RandomizingTimeDistanceTravelDisutilityFactory; +import org.matsim.core.router.costcalculators.TravelDisutilityFactory; +import org.matsim.core.router.util.TravelDisutility; import org.matsim.core.scenario.MutableScenario; +import org.matsim.core.scenario.ScenarioByInstanceModule; import org.matsim.core.scenario.ScenarioUtils; import org.matsim.core.utils.geometry.CoordUtils; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; +import java.util.Map; import java.util.Random; public class NoiseModel extends AbstractModel implements ModelUpdateListener { - private static final Logger logger = Logger.getLogger(NoiseModel.class); - private final RealEstateDataManager realEstateDataManager; - private final MatsimData matsimData; - private int latestMatsimYear = -1; + private static final Logger logger = Logger.getLogger(NoiseModel.class); + private final RealEstateDataManager realEstateDataManager; + private final MatsimData matsimData; + private int latestMatsimYear = -1; - private final NoiseReceiverPoints noiseReceiverPoints; + private final NoiseReceiverPoints noiseReceiverPoints; - public NoiseModel(DataContainer data, Properties properties, Random random, MatsimData matsimData) { - super(data, properties, random); - this.realEstateDataManager = data.getRealEstateDataManager(); - this.matsimData = matsimData; - this.noiseReceiverPoints = new NoiseReceiverPoints(); - } + public NoiseModel(DataContainer data, Properties properties, Random random, MatsimData matsimData) { + super(data, properties, random); + this.realEstateDataManager = data.getRealEstateDataManager(); + this.matsimData = matsimData; + this.noiseReceiverPoints = new NoiseReceiverPoints(); + } - @Override - public void setup() { - updateImmissions(properties.main.baseYear); - } + @Override + public void setup() { + updateImmissions(properties.main.baseYear); + } - @Override - public void prepareYear(int year) { + @Override + public void prepareYear(int year) { - } + } - @Override - public void endYear(int year) { - updateImmissions(year); - } + @Override + public void endYear(int year) { + updateImmissions(year); + } - @Override - public void endSimulation() { - } + @Override + public void endSimulation() { + } - private void updateImmissions(int year) { - logger.info("Updating noise immisisons for year " + year + "."); + private void updateImmissions(int year) { + logger.info("Updating noise immisisons for year " + year + "."); - NoiseReceiverPoints newNoiseReceiverPoints = new NoiseReceiverPoints(); - NoiseReceiverPoints existingNoiseReceiverPoints = new NoiseReceiverPoints(); + NoiseReceiverPoints newNoiseReceiverPoints = new NoiseReceiverPoints(); + NoiseReceiverPoints existingNoiseReceiverPoints = new NoiseReceiverPoints(); - for (Dwelling dwelling : realEstateDataManager.getDwellings()) { - Id id = Id.create(dwelling.getId(), ReceiverPoint.class); - final NoiseReceiverPoint existing = noiseReceiverPoints.remove(id); - if (existing == null) { - newNoiseReceiverPoints.put(id, new NoiseReceiverPoint(id, CoordUtils.createCoord(dwelling.getCoordinate()))); - } else { - existingNoiseReceiverPoints.put(id, existing); - } - } + for (Dwelling dwelling : realEstateDataManager.getDwellings()) { + Id id = Id.create(dwelling.getId(), ReceiverPoint.class); + final NoiseReceiverPoint existing = noiseReceiverPoints.remove(id); + if (existing == null) { + newNoiseReceiverPoints.put(id, new NoiseReceiverPoint(id, CoordUtils.createCoord(dwelling.getCoordinate()))); + } else { + existingNoiseReceiverPoints.put(id, existing); + } + } - this.noiseReceiverPoints.clear(); - this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); - this.noiseReceiverPoints.putAll(existingNoiseReceiverPoints); - - //First year - if(properties.main.startYear == year) { - if(properties.transportModel.matsimInitialPlansFile != null - && properties.transportModel.matsimInitialEventsFile != null) { - //initial files provided -> replay - if(existingNoiseReceiverPoints.isEmpty()) { - replayFromEvents(noiseReceiverPoints); + this.noiseReceiverPoints.clear(); + this.noiseReceiverPoints.putAll(newNoiseReceiverPoints); + this.noiseReceiverPoints.putAll(existingNoiseReceiverPoints); + + //First year + if(properties.main.startYear == year) { + if(properties.transportModel.matsimInitialPlansFile != null + && properties.transportModel.matsimInitialEventsFile != null) { + //initial files provided -> replay + if(existingNoiseReceiverPoints.isEmpty()) { + replayFromEvents(noiseReceiverPoints); + } else { + replayFromEvents(newNoiseReceiverPoints); + } + } else { + //matsim transport model must have run at this stage for the start year + latestMatsimYear = year; + calculateNoiseOffline(noiseReceiverPoints); + } + } else if(latestMatsimYear == -1) { + //not the first year and no matsim run has happened yet... + if(properties.transportModel.transportModelYears.contains(year + 1)) { + //...this means that matsim either has to run and update all receiver points for the next year... + latestMatsimYear = year + 1; + calculateNoiseOffline(noiseReceiverPoints); + } else if(properties.transportModel.matsimInitialPlansFile != null + && properties.transportModel.matsimInitialEventsFile != null) { + //...or the initial files are available. update new receiver points. + replayFromEvents(newNoiseReceiverPoints); + } else { + //one of the above options have to be true. + throw new RuntimeException("Should not happen!"); + } } else { - replayFromEvents(newNoiseReceiverPoints); + //matsim has run before. update new receiver points. + calculateNoiseOffline(newNoiseReceiverPoints); } - } else { - //matsim transport model must have run at this stage for the start year - latestMatsimYear = year; - calculateNoiseOffline(noiseReceiverPoints); - } - } else if(latestMatsimYear == -1) { - //not the first year and no matsim run has happened yet... - if(properties.transportModel.transportModelYears.contains(year + 1)) { - //...this means that matsim either has to run and update all receiver points for the next year... - latestMatsimYear = year + 1; - calculateNoiseOffline(noiseReceiverPoints); - } else if(properties.transportModel.matsimInitialPlansFile != null - && properties.transportModel.matsimInitialEventsFile != null) { - //...or the initial files are available. update new receiver points. - replayFromEvents(newNoiseReceiverPoints); - } else { - //one of the above options have to be true. - throw new RuntimeException("Should not happen!"); - } - } else { - //matsim has run before. update new receiver points. - calculateNoiseOffline(newNoiseReceiverPoints); - } - int counter65 = 0; - int counter55 = 0; - for (Dwelling dwelling : dataContainer.getRealEstateDataManager().getDwellings()) { - final Id id = Id.create(dwelling.getId(), ReceiverPoint.class); - if (noiseReceiverPoints.containsKey(id)) { - double lden = noiseReceiverPoints.get(id).getLden(); - ((NoiseDwelling) dwelling).setNoiseImmision(lden); - if (lden > 55) { - if (lden > 65) { - counter65++; - } else { - counter55++; - } + int counter65 = 0; + int counter55 = 0; + for (Dwelling dwelling : dataContainer.getRealEstateDataManager().getDwellings()) { + final Id id = Id.create(dwelling.getId(), ReceiverPoint.class); + if (noiseReceiverPoints.containsKey(id)) { + double lden = noiseReceiverPoints.get(id).getLden(); + ((NoiseDwelling) dwelling).setNoiseImmision(lden); + if (lden > 55) { + if (lden > 65) { + counter65++; + } else { + counter55++; + } + } + } } - } + int total = dataContainer.getRealEstateDataManager().getDwellings().size(); + int quiet = total - counter55 - counter65; + logger.info("Dwellings <55dB(A) : " + quiet + " (" + ((double) quiet) / total + "%)"); + logger.info("Dwellings 55dB(A)-65dB(A) : " + counter55 + " (" + ((double) counter55) / total + "%)"); + logger.info("Dwellings >65dB(A) : " + counter65 + " (" + ((double) counter65) / total + "%)"); } - int total = dataContainer.getRealEstateDataManager().getDwellings().size(); - int quiet = total - counter55 - counter65; - logger.info("Dwellings <55dB(A) : " + quiet + " (" + ((double) quiet) / total + "%)"); - logger.info("Dwellings 55dB(A)-65dB(A) : " + counter55 + " (" + ((double) counter55) / total + "%)"); - logger.info("Dwellings >65dB(A) : " + counter65 + " (" + ((double) counter65) / total + "%)"); - } - private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { - final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" - + properties.main.scenarioName + "/matsim/" + latestMatsimYear + "/"; + private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { + final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" + + properties.main.scenarioName + "/matsim/" + latestMatsimYear + "/"; - String populationPath = outputDirectoryRoot + latestMatsimYear + ".output_plans.xml.gz"; + String populationPath = outputDirectoryRoot + latestMatsimYear + ".output_plans.xml.gz"; - Config config = ConfigUtils.createConfig(); - config.controler().setOutputDirectory(outputDirectoryRoot); - config.controler().setRunId(String.valueOf(latestMatsimYear)); - final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); + Config config = ConfigUtils.createConfig(); + config.controler().setOutputDirectory(outputDirectoryRoot); + config.controler().setRunId(String.valueOf(latestMatsimYear)); + final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); - new PopulationReader(scenario).readFile(populationPath); + new PopulationReader(scenario).readFile(populationPath); - scenario.setNetwork(matsimData.getCarNetwork()); + scenario.setNetwork(matsimData.getCarNetwork()); - scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); + scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); - NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); - noiseParameters.setInternalizeNoiseDamages(false); - noiseParameters.setComputeCausingAgents(false); - noiseParameters.setComputeNoiseDamages(false); - noiseParameters.setComputePopulationUnits(false); - noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); - noiseParameters.setThrowNoiseEventsCaused(false); - noiseParameters.setThrowNoiseEventsAffected(false); - noiseParameters.setWriteOutputIteration(0); - noiseParameters.setScaleFactor(20); - config.qsim().setEndTime(24 * 60 * 60); + NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); + noiseParameters.setInternalizeNoiseDamages(false); + noiseParameters.setComputeCausingAgents(false); + noiseParameters.setComputeNoiseDamages(false); + noiseParameters.setComputePopulationUnits(false); + noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); + noiseParameters.setThrowNoiseEventsCaused(false); + noiseParameters.setThrowNoiseEventsAffected(false); + noiseParameters.setWriteOutputIteration(0); + noiseParameters.setScaleFactor(20); + config.qsim().setEndTime(24 * 60 * 60); - noiseParameters.setConsiderNoiseBarriers(true); - noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); - noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); - config.global().setCoordinateSystem("EPSG:31468"); + noiseParameters.setConsiderNoiseBarriers(true); + noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); + noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); + config.global().setCoordinateSystem("EPSG:31468"); - NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, outputDirectoryRoot); - noiseOfflineCalculation.run(); + NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, outputDirectoryRoot); + noiseOfflineCalculation.run(); - NoiseContext noiseContext = noiseOfflineCalculation.getNoiseContext(); - NoiseTollCalculator tollCalculator = new NoiseTollCalculator(noiseContext); - tollCalculator.calculateExpectedTollDisutility(Id.createLinkId(123), 28800, null); - } + TravelDisutility result = noiseOfflineCalculation.getTollDisutility(); + result.getLinkTravelDisutility( Id.createLinkId(123 ), 28800, null, null ); - private void replayFromEvents(NoiseReceiverPoints noiseReceiverPoints) { + } - final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" + properties.main.scenarioName; - String outputDirectory = outputDirectoryRoot + "/matsim/" + properties.main.startYear +"_warm" + "/"; - try { - final Path events = Paths.get(outputDirectory + "/"+ Paths.get(properties.transportModel.matsimInitialEventsFile).getFileName()); - final Path plans = Paths.get(outputDirectory + "/" + Paths.get(properties.transportModel.matsimInitialPlansFile).getFileName()); + private void replayFromEvents(NoiseReceiverPoints noiseReceiverPoints) { - Files.createDirectories(events.getParent()); - Files.createDirectories(plans.getParent()); + final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" + properties.main.scenarioName; + String outputDirectory = outputDirectoryRoot + "/matsim/" + properties.main.startYear +"_warm" + "/"; - Files.copy(Paths.get(properties.main.baseDirectory + properties.transportModel.matsimInitialEventsFile), events); - Files.copy(Paths.get(properties.main.baseDirectory + properties.transportModel.matsimInitialPlansFile), plans); + try { + final Path events = Paths.get(outputDirectory + "/"+ Paths.get(properties.transportModel.matsimInitialEventsFile).getFileName()); + final Path plans = Paths.get(outputDirectory + "/" + Paths.get(properties.transportModel.matsimInitialPlansFile).getFileName()); - } catch (Exception e) { - logger.error(e); - } + Files.createDirectories(events.getParent()); + Files.createDirectories(plans.getParent()); + Files.copy(Paths.get(properties.main.baseDirectory + properties.transportModel.matsimInitialEventsFile), events); + Files.copy(Paths.get(properties.main.baseDirectory + properties.transportModel.matsimInitialPlansFile), plans); - String eventsFile = properties.main.baseDirectory + properties.transportModel.matsimInitialEventsFile; - final Path path = Paths.get(eventsFile); + } catch (Exception e) { + logger.error(e); + } - String plansFile = properties.main.baseDirectory + properties.transportModel.matsimInitialPlansFile; + String eventsFile = properties.main.baseDirectory + properties.transportModel.matsimInitialEventsFile; + final Path path = Paths.get(eventsFile); - Config config = ConfigUtils.createConfig(); - config.controler().setOutputDirectory(outputDirectory); - String runId = eventsFile.substring(eventsFile.lastIndexOf("/") + 1, eventsFile.indexOf(".output_events")); - config.controler().setRunId(runId); - final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); - new PopulationReader(scenario).readFile(plansFile); + String plansFile = properties.main.baseDirectory + properties.transportModel.matsimInitialPlansFile; - scenario.setNetwork(matsimData.getCarNetwork()); - scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); - NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); - noiseParameters.setInternalizeNoiseDamages(false); - noiseParameters.setComputeCausingAgents(false); - noiseParameters.setComputeNoiseDamages(false); - noiseParameters.setComputePopulationUnits(false); - noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); - noiseParameters.setThrowNoiseEventsCaused(false); - noiseParameters.setThrowNoiseEventsAffected(false); - noiseParameters.setWriteOutputIteration(0); - noiseParameters.setScaleFactor(20); - config.qsim().setEndTime(24 * 60 * 60); + Config config = ConfigUtils.createConfig(); + config.controler().setOutputDirectory(outputDirectory); + String runId = eventsFile.substring(eventsFile.lastIndexOf("/") + 1, eventsFile.indexOf(".output_events")); + config.controler().setRunId(runId); + final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); + new PopulationReader(scenario).readFile(plansFile); - noiseParameters.setConsiderNoiseBarriers(true); - noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); - noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); - config.global().setCoordinateSystem("EPSG:31468"); + scenario.setNetwork(matsimData.getCarNetwork()); + scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); + NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); + noiseParameters.setInternalizeNoiseDamages(false); + noiseParameters.setComputeCausingAgents(false); + noiseParameters.setComputeNoiseDamages(false); + noiseParameters.setComputePopulationUnits(false); + noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); + noiseParameters.setThrowNoiseEventsCaused(false); + noiseParameters.setThrowNoiseEventsAffected(false); + noiseParameters.setWriteOutputIteration(0); + noiseParameters.setScaleFactor(20); + config.qsim().setEndTime(24 * 60 * 60); - NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, path.getParent().toString()); - noiseOfflineCalculation.run(); - } + noiseParameters.setConsiderNoiseBarriers(true); + noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); + noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); + config.global().setCoordinateSystem("EPSG:31468"); + + + NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, path.getParent().toString()); + noiseOfflineCalculation.run(); + } } From 8031f4a5105b32d0282f29f3e0b2ebae3343b30d Mon Sep 17 00:00:00 2001 From: Nico Date: Mon, 27 Jul 2020 10:09:38 +0200 Subject: [PATCH 14/24] updates to noise feedback --- analysis/pom.xml | 2 +- extensions/matsim2silo/pom.xml | 2 +- .../de/tum/bgu/msm/matsim/MatsimData.java | 2 +- .../tum/bgu/msm/matsim/MatsimSkimCreator.java | 2 +- .../bgu/msm/matsim/MatsimTransportModel.java | 1 + .../tum/bgu/msm/matsim/MatsimTravelTimes.java | 2 +- .../accessibility/AccessibilityModule.java | 3 +- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 36 +-- .../msm/mito/MitoMatsimScenarioAssembler.java | 3 + siloCore/pom.xml | 32 +-- .../DefaultDriversLicenseStrategy.java | 169 +++++++++++- .../DriversLicenseModelImpl.java | 1 - .../java/de/tum/bgu/msm/utils/SiloUtil.java | 9 +- .../de/tum/bgu/msm/models/SelectDwellingCalc | 2 +- .../de/tum/bgu/msm/models/SelectRegionCalc | 2 +- synthetic-population/pom.xml | 2 +- .../msm/data/mito/MitoDataConverterMuc.java | 13 +- .../msm/transportModel/matsim/SBBTest.java | 261 +++++++++--------- .../matsim/SiloMatsimMucTest.java | 9 +- .../transportModel/matsim/SiloMucTest.java | 7 +- useCases/pom.xml | 2 +- 21 files changed, 337 insertions(+), 225 deletions(-) diff --git a/analysis/pom.xml b/analysis/pom.xml index 6b1babd01..5b8bde481 100644 --- a/analysis/pom.xml +++ b/analysis/pom.xml @@ -209,7 +209,7 @@ ${buildNumber} 13.0 false - 0.10.0-SNAPSHOT + 13.0-SNAPSHOT 2.9.5 \ No newline at end of file diff --git a/extensions/matsim2silo/pom.xml b/extensions/matsim2silo/pom.xml index a236e673b..5d33a5f4f 100644 --- a/extensions/matsim2silo/pom.xml +++ b/extensions/matsim2silo/pom.xml @@ -23,6 +23,6 @@ - 12.0-SNAPSHOT + 13.0-SNAPSHOT \ No newline at end of file diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index 850720693..c75dc5580 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -77,7 +77,7 @@ public MatsimData(Config config, Properties properties, TransportModeNetworkFilter filter = new TransportModeNetworkFilter(network); Set car = Sets.newHashSet(TransportMode.car); - Set pt = Sets.newHashSet(TransportMode.pt); + Set pt = Sets.newHashSet(TransportMode.pt, "artificial", "bus", "rail", "tram", "subway"); Network carNetwork = NetworkUtils.createNetwork(); filter.filter(carNetwork, car); diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimSkimCreator.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimSkimCreator.java index 27af1ba90..1d0697296 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimSkimCreator.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimSkimCreator.java @@ -186,7 +186,7 @@ public IndexedDoubleMatrix2D createTeleportedSkim(Collection zones, String if (!planElements.isEmpty()) { final Leg lastLeg = (Leg) planElements.get(planElements.size() - 1); - arrivalTime = lastLeg.getDepartureTime() + lastLeg.getTravelTime(); + arrivalTime = lastLeg.getDepartureTime().seconds() + lastLeg.getTravelTime().seconds(); } double time = arrivalTime - peakHour_s; diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java index cfe413138..4581c2718 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java @@ -80,6 +80,7 @@ public MatsimTransportModel(DataContainer dataContainer, Config matsimConfig, @Override public void setup() { + initialMatsimConfig.plansCalcRoute().setRoutingRandomness(0); internalTravelTimes.initialize(dataContainer.getGeoData(), matsimData); if (properties.transportModel.matsimInitialEventsFile == null) { diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimes.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimes.java index 95c5108ee..b4bb0d7b2 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimes.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimes.java @@ -154,7 +154,7 @@ public double getTravelTime(Location origin, Location destination, double timeOf if (!planElements.isEmpty()) { final Leg lastLeg = (Leg) planElements.get(planElements.size() - 1); - arrivalTime = lastLeg.getDepartureTime() + lastLeg.getTravelTime(); + arrivalTime = lastLeg.getDepartureTime().seconds() + lastLeg.getTravelTime().seconds(); } double time = arrivalTime - timeOfDay_s; diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java index 55bef965d..32d401227 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/accessibility/AccessibilityModule.java @@ -13,7 +13,6 @@ import org.matsim.api.core.v01.Scenario; import org.matsim.api.core.v01.network.Network; import org.matsim.api.core.v01.network.Node; -import org.matsim.contrib.accessibility.AccessibilityAttributes; import org.matsim.contrib.accessibility.AccessibilityConfigGroup; //import org.matsim.contrib.accessibility.interfaces.FacilityDataExchangeInterface; import org.matsim.core.config.ConfigUtils; @@ -68,7 +67,7 @@ public void prepareAccessibility(Scenario scenario, Controler controler) { final ActivityFacilities opportunities = scenario.getActivityFacilities(); int i = 0; for (ActivityFacility activityFacility : zoneRepresentativeCoords.getFacilities().values()) { - activityFacility.getAttributes().putAttribute(AccessibilityAttributes.WEIGHT, zonePopulationMap.get(activityFacility.getId())); +// activityFacility.getAttributes().putAttribute(AccessibilityAttributes.WEIGHT, zonePopulationMap.get(activityFacility.getId())); opportunities.addActivityFacility(activityFacility); i++; } diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index abde42201..c42466529 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -93,37 +93,25 @@ private void updateImmissions(int year) { if(properties.main.startYear == year) { if(properties.transportModel.matsimInitialPlansFile != null && properties.transportModel.matsimInitialEventsFile != null) { - //initial files provided -> replay - if(existingNoiseReceiverPoints.isEmpty()) { replayFromEvents(noiseReceiverPoints); - } else { - replayFromEvents(newNoiseReceiverPoints); - } } else { //matsim transport model must have run at this stage for the start year latestMatsimYear = year; calculateNoiseOffline(noiseReceiverPoints); } - } else if(latestMatsimYear == -1) { - //not the first year and no matsim run has happened yet... - if(properties.transportModel.transportModelYears.contains(year + 1)) { - //...this means that matsim either has to run and update all receiver points for the next year... - latestMatsimYear = year + 1; - calculateNoiseOffline(noiseReceiverPoints); - } else if(properties.transportModel.matsimInitialPlansFile != null - && properties.transportModel.matsimInitialEventsFile != null) { - //...or the initial files are available. update new receiver points. - replayFromEvents(newNoiseReceiverPoints); - } else { - //one of the above options have to be true. - throw new RuntimeException("Should not happen!"); - } + } else if (properties.transportModel.transportModelYears.contains(year + 1)) { + //matsim either has to run and update all receiver points for the next year... + latestMatsimYear = year + 1; + calculateNoiseOffline(noiseReceiverPoints); + } else if(latestMatsimYear == -1 && properties.transportModel.matsimInitialPlansFile != null + && properties.transportModel.matsimInitialEventsFile != null) { + //...or the initial files are available and still valid for this year. update new receiver points. + replayFromEvents(newNoiseReceiverPoints); } else { //matsim has run before. update new receiver points. calculateNoiseOffline(newNoiseReceiverPoints); } - int counter65 = 0; int counter55 = 0; for (Dwelling dwelling : dataContainer.getRealEstateDataManager().getDwellings()) { @@ -174,7 +162,7 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setThrowNoiseEventsCaused(false); noiseParameters.setThrowNoiseEventsAffected(false); noiseParameters.setWriteOutputIteration(0); - noiseParameters.setScaleFactor(20); + noiseParameters.setScaleFactor(10); config.qsim().setEndTime(24 * 60 * 60); noiseParameters.setConsiderNoiseBarriers(true); @@ -185,10 +173,6 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { NoiseOfflineCalculation noiseOfflineCalculation = new NoiseOfflineCalculation(scenario, outputDirectoryRoot); noiseOfflineCalculation.run(); - TravelDisutility result = noiseOfflineCalculation.getTollDisutility(); - - result.getLinkTravelDisutility( Id.createLinkId(123 ), 28800, null, null ); - } @@ -237,7 +221,7 @@ private void replayFromEvents(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setThrowNoiseEventsCaused(false); noiseParameters.setThrowNoiseEventsAffected(false); noiseParameters.setWriteOutputIteration(0); - noiseParameters.setScaleFactor(20); + noiseParameters.setScaleFactor(10); config.qsim().setEndTime(24 * 60 * 60); noiseParameters.setConsiderNoiseBarriers(true); diff --git a/extensions/mito2silo/src/main/java/de/tum/bgu/msm/mito/MitoMatsimScenarioAssembler.java b/extensions/mito2silo/src/main/java/de/tum/bgu/msm/mito/MitoMatsimScenarioAssembler.java index 66e133f8f..d24ccf3ff 100644 --- a/extensions/mito2silo/src/main/java/de/tum/bgu/msm/mito/MitoMatsimScenarioAssembler.java +++ b/extensions/mito2silo/src/main/java/de/tum/bgu/msm/mito/MitoMatsimScenarioAssembler.java @@ -58,8 +58,11 @@ public Scenario assembleScenario(Config initialMatsimConfig, int year, TravelTim logger.info(" Receiving demand from MITO"); Population population = mito.getData().getPopulation(); + double factor = initialMatsimConfig.qsim().getFlowCapFactor(); Config config = ConfigUtils.loadConfig(initialMatsimConfig.getContext()); ConfigureMatsim.setDemandSpecificConfigSettings(config); + config.qsim().setStorageCapFactor(factor); + config.qsim().setFlowCapFactor(factor); MutableScenario scenario = (MutableScenario) ScenarioUtils.loadScenario(config); scenario.setPopulation(population); return scenario; diff --git a/siloCore/pom.xml b/siloCore/pom.xml index d0f6bcb71..970717875 100644 --- a/siloCore/pom.xml +++ b/siloCore/pom.xml @@ -180,29 +180,24 @@ + - jitpack.io - https://jitpack.io + maven2-repository.dev.java.net + Java.net repository + http://download.java.net/maven/2 - - osgeo - Geotools repository - http://download.osgeo.org/webdav/geotools + + true + + boundless + Boundless Maven Repository + http://repo.boundlessgeo.com/main matsim http://dl.bintray.com/matsim/matsim - - ojo-snapshots - http://oss.jfrog.org/libs-snapshot - - - bintray-msmobility-maven - bintray - http://dl.bintray.com/msmobility/maven - @@ -382,11 +377,6 @@ - - com.github.SchweizerischeBundesbahnen - matsim-sbb-extensions - 11.2 - commons-io @@ -411,7 +401,7 @@ ${buildNumber} false - 12.0-2020w02-SNAPSHOT + 13.0-SNAPSHOT 1.8 1.8 1.8 diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DefaultDriversLicenseStrategy.java b/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DefaultDriversLicenseStrategy.java index 413e81061..834ec6b77 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DefaultDriversLicenseStrategy.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DefaultDriversLicenseStrategy.java @@ -1,31 +1,170 @@ package de.tum.bgu.msm.models.demography.driversLicense; import de.tum.bgu.msm.data.person.Person; -import de.tum.bgu.msm.models.ScriptInputProvider; -import de.tum.bgu.msm.util.js.JavaScriptCalculator; - -import java.io.InputStreamReader; -import java.io.Reader; +import de.tum.bgu.msm.data.person.PersonType; /** * Created by matthewokrah on 13/11/2017. */ -public class DefaultDriversLicenseStrategy extends JavaScriptCalculator implements DriversLicenseStrategy{ - - private final static Reader reader = new InputStreamReader(ScriptInputProvider.getDriversLicenseProbabilityScriptInput()); - - public DefaultDriversLicenseStrategy() { - super(reader); - } +public class DefaultDriversLicenseStrategy implements DriversLicenseStrategy { + public DefaultDriversLicenseStrategy() {} @Override public double calculateChangeDriversLicenseProbability(Person person) { - return super.calculate("calculateChangeDriversLicenseProbability", person.getType()); + PersonType personType = person.getType(); + if (personType.name() == "MEN_AGE_15_TO_19"){ + return 0.86; + } else if (personType.name() == "MEN_AGE_20_TO_24"){ + return 0.86; + } else if (personType.name() == "MEN_AGE_25_TO_29"){ + return 0.86; + } else if (personType.name() == "MEN_AGE_30_TO_34"){ + return 0.95; + } else if (personType.name() == "MEN_AGE_35_TO_39"){ + return 0.50; + } else if (personType.name() == "MEN_AGE_40_TO_44"){ + return 0.30; + } else if (personType.name() == "MEN_AGE_45_TO_49"){ + return 0.20; + } else if (personType.name() == "MEN_AGE_50_TO_54"){ + return 0.15; + } else if (personType.name() == "MEN_AGE_55_TO_59"){ + return 0.15; + } else if (personType.name() == "MEN_AGE_60_TO_64"){ + return 0.15; + } else if (personType.name() == "MEN_AGE_65_TO_69"){ + return 0.05; + } else if (personType.name() == "MEN_AGE_70_TO_74"){ + return 0.05; + } else if (personType.name() == "MEN_AGE_75_TO_79"){ + return 0.00; + } else if (personType.name() == "MEN_AGE_80_TO_84"){ + return 0.00; + } else if (personType.name() == "MEN_AGE_85_TO_89"){ + return 0.00; + } else if (personType.name() == "MEN_AGE_90_TO_94"){ + return 0.00; + } else if (personType.name() == "MEN_AGE_95_TO_99"){ + return 0.00; + } else if (personType.name() == "MEN_AGE_100plus"){ + return 0.00; + } else if (personType.name() == "WOMEN_AGE_15_TO_19"){ + return 0.87; + } else if (personType.name() == "WOMEN_AGE_20_TO_24"){ + return 0.87; + } else if (personType.name() == "WOMEN_AGE_25_TO_29"){ + return 0.87; + } else if (personType.name() == "WOMEN_AGE_30_TO_34"){ + return 0.94; + } else if (personType.name() == "WOMEN_AGE_35_TO_39"){ + return 0.50; + } else if (personType.name() == "WOMEN_AGE_40_TO_44"){ + return 0.30; + } else if (personType.name() == "WOMEN_AGE_45_TO_49"){ + return 0.20; + } else if (personType.name() == "WOMEN_AGE_50_TO_54"){ + return 0.15; + } else if (personType.name() == "WOMEN_AGE_55_TO_59"){ + return 0.15; + } else if (personType.name() == "WOMEN_AGE_60_TO_64"){ + return 0.15; + } else if (personType.name() == "WOMEN_AGE_65_TO_69"){ + return 0.05; + } else if (personType.name() == "WOMEN_AGE_70_TO_74"){ + return 0.00; + } else if (personType.name() == "WOMEN_AGE_75_TO_79"){ + return 0.00; + } else if (personType.name() == "WOMEN_AGE_80_TO_84"){ + return 0.00; + } else if (personType.name() == "WOMEN_AGE_85_TO_89"){ + return 0.00; + } else if (personType.name() == "WOMEN_AGE_90_TO_94"){ + return 0.00; + } else if (personType.name() == "WOMEN_AGE_95_TO_99"){ + return 0.00; + } else if (personType.name() == "WOMEN_AGE_100_PLUS"){ + return 0.00; + } + return 0; } @Override public double calculateCreateDriversLicenseProbability(Person pp) { - return super.calculate("calculateCreateDriversLicenseProbability", pp.getType()); + PersonType personType = pp.getType(); + if (personType.name() == "MEN_AGE_15_TO_19") { + return 0.86; + } else if (personType.name() == "MEN_AGE_20_TO_24") { + return 0.86; + } else if (personType.name() == "MEN_AGE_25_TO_29") { + return 0.86; + } else if (personType.name() == "MEN_AGE_30_TO_34") { + return 0.95; + } else if (personType.name() == "MEN_AGE_35_TO_39") { + return 0.95; + } else if (personType.name() == "MEN_AGE_40_TO_44") { + return 0.97; + } else if (personType.name() == "MEN_AGE_45_TO_49") { + return 0.97; + } else if (personType.name() == "MEN_AGE_50_TO_54") { + return 0.96; + } else if (personType.name() == "MEN_AGE_55_TO_59") { + return 0.96; + } else if (personType.name() == "MEN_AGE_60_TO_64") { + return 0.95; + } else if (personType.name() == "MEN_AGE_65_TO_69") { + return 0.95; + } else if (personType.name() == "MEN_AGE_70_TO_74") { + return 0.95; + } else if (personType.name() == "MEN_AGE_75_TO_79") { + return 0.88; + } else if (personType.name() == "MEN_AGE_80_TO_84") { + return 0.88; + } else if (personType.name() == "MEN_AGE_85_TO_89") { + return 0.88; + } else if (personType.name() == "MEN_AGE_90_TO_94") { + return 0.88; + } else if (personType.name() == "MEN_AGE_95_TO_99") { + return 0.88; + } else if (personType.name() == "MEN_AGE_100plus") { + return 0.88; + } else if (personType.name() == "WOMEN_AGE_15_TO_19") { + return 0.87; + } else if (personType.name() == "WOMEN_AGE_20_TO_24") { + return 0.87; + } else if (personType.name() == "WOMEN_AGE_25_TO_29") { + return 0.87; + } else if (personType.name() == "WOMEN_AGE_30_TO_34") { + return 0.94; + } else if (personType.name() == "WOMEN_AGE_35_TO_39") { + return 0.94; + } else if (personType.name() == "WOMEN_AGE_40_TO_44") { + return 0.95; + } else if (personType.name() == "WOMEN_AGE_45_TO_49") { + return 0.95; + } else if (personType.name() == "WOMEN_AGE_50_TO_54") { + return 0.89; + } else if (personType.name() == "WOMEN_AGE_55_TO_59") { + return 0.89; + } else if (personType.name() == "WOMEN_AGE_60_TO_64") { + return 0.86; + } else if (personType.name() == "WOMEN_AGE_65_TO_69") { + return 0.71; + } else if (personType.name() == "WOMEN_AGE_70_TO_74") { + return 0.71; + } else if (personType.name() == "WOMEN_AGE_75_TO_79") { + return 0.44; + } else if (personType.name() == "WOMEN_AGE_80_TO_84") { + return 0.44; + } else if (personType.name() == "WOMEN_AGE_85_TO_89") { + return 0.44; + } else if (personType.name() == "WOMEN_AGE_90_TO_94") { + return 0.44; + } else if (personType.name() == "WOMEN_AGE_95_TO_99") { + return 0.44; + } else if (personType.name() == "WOMEN_AGE_100_PLUS") { + return 0.44; + } + return 0; } -} +} \ No newline at end of file diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DriversLicenseModelImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DriversLicenseModelImpl.java index b8dc0e09e..ce9363462 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DriversLicenseModelImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/demography/driversLicense/DriversLicenseModelImpl.java @@ -17,7 +17,6 @@ * Author: Rolf Moeckel, TUM and Ana Moreno, TUM * Created on 13 October 2017 in Cape Town, South Africa **/ - public class DriversLicenseModelImpl extends AbstractModel implements DriversLicenseModel { private final DriversLicenseStrategy strategy; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/utils/SiloUtil.java b/siloCore/src/main/java/de/tum/bgu/msm/utils/SiloUtil.java index 68badf78d..f98d2dd30 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/utils/SiloUtil.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/utils/SiloUtil.java @@ -12,10 +12,7 @@ import omx.OmxMatrix; import omx.hdf5.OmxHdf5Datatype; import org.apache.commons.lang3.SystemUtils; -import org.apache.log4j.Appender; -import org.apache.log4j.FileAppender; -import org.apache.log4j.Level; -import org.apache.log4j.Logger; +import org.apache.log4j.*; import org.matsim.core.controler.Controler; import java.io.*; @@ -72,10 +69,10 @@ public static Properties siloInitialization(String propertiesPath) { */ private static void initLogging(String outputDirectory) throws IOException { Logger root = Logger.getRootLogger(); - FileAppender appender = new FileAppender(Controler.DEFAULTLOG4JLAYOUT, outputDirectory + System.getProperty("file.separator")+ LOG_FILE_NAME, false); + FileAppender appender = new FileAppender(new SimpleLayout(), outputDirectory + System.getProperty("file.separator")+ LOG_FILE_NAME, false); appender.setName(LOG_FILE_NAME); root.addAppender(appender); - FileAppender warnErrorAppender = new FileAppender(Controler.DEFAULTLOG4JLAYOUT, outputDirectory + System.getProperty("file.separator")+ LOG_WARN_FILE_NAME, false); + FileAppender warnErrorAppender = new FileAppender(new SimpleLayout(), outputDirectory + System.getProperty("file.separator")+ LOG_WARN_FILE_NAME, false); warnErrorAppender.setName(LOG_WARN_FILE_NAME); warnErrorAppender.setThreshold(Level.WARN); root.addAppender(warnErrorAppender); diff --git a/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectDwellingCalc b/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectDwellingCalc index f45547ae9..2b43dd692 100644 --- a/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectDwellingCalc +++ b/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectDwellingCalc @@ -1,3 +1,3 @@ var calculateSelectDwellingProbability = function(ddUtility) { - return 1.0 * Math.exp(0.5 * ddUtility); + return 1.0 * Math.exp(ddUtility); } diff --git a/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectRegionCalc b/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectRegionCalc index 2744e1f7b..ae6f4f1bf 100644 --- a/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectRegionCalc +++ b/siloCore/src/main/resources/de/tum/bgu/msm/models/SelectRegionCalc @@ -1,3 +1,3 @@ var calculateSelectRegionProbability = function(regionUtility) { - return Math.exp(0.5 * regionUtility); + return Math.exp(0.8 * regionUtility); } diff --git a/synthetic-population/pom.xml b/synthetic-population/pom.xml index d1e2829db..46e05b34f 100644 --- a/synthetic-population/pom.xml +++ b/synthetic-population/pom.xml @@ -227,7 +227,7 @@ ${buildNumber} 13.0 false - 0.10.0-SNAPSHOT + 13.0-SNAPSHOT 2.9.5 \ No newline at end of file diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java index f4f045ee3..531d3045b 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java @@ -16,8 +16,10 @@ import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.schools.School; import de.tum.bgu.msm.schools.SchoolImpl; +import de.tum.bgu.msm.utils.SiloUtil; import org.apache.log4j.Logger; import org.locationtech.jts.geom.Coordinate; +import org.locationtech.jts.geom.Geometry; import java.util.Map; @@ -38,7 +40,7 @@ public DataSet convertData(DataContainer dataContainer) { private void convertZones(DataSet dataSet, DataContainer dataContainer) { for (Zone siloZone : dataContainer.getGeoData().getZones().values()) { MitoZone zone = new MitoZone(siloZone.getZoneId(), ((MunichZone) siloZone).getAreaTypeSG()); - zone.setShapeFeature(siloZone.getZoneFeature()); + zone.setGeometry((Geometry) siloZone.getZoneFeature().getDefaultGeometry()); dataSet.addZone(zone); } } @@ -51,7 +53,7 @@ private void convertSchools(DataSet dataSet, DataContainer dataContainer) { if (school instanceof SchoolImpl) { coordinate = ((SchoolImpl) school).getCoordinate(); } else { - coordinate = zone.getRandomCoord(); + coordinate = zone.getRandomCoord(SiloUtil.provideNewRandom()); } MitoSchool mitoSchool = new MitoSchool(zones.get(school.getZoneId()), coordinate, school.getId()); //mitoSchool.setStartTime_min((int) (school.getStartTimeInSeconds() / 60.)); @@ -86,7 +88,7 @@ private void convertHhs(DataSet dataSet, DataContainer dataContainer) { coordinate = dwelling.getCoordinate(); } else { randomCoordCounter++; - coordinate = zone.getRandomCoord(); + coordinate = zone.getRandomCoord(SiloUtil.provideNewRandom()); } //todo if there are housholds without adults they cannot be processed @@ -124,11 +126,12 @@ private MitoPerson convertToMitoPp(PersonMuc person, DataSet dataSet, DataContai if (job instanceof MicroLocation) { coordinate = job.getCoordinate(); } else { - coordinate = zone.getRandomCoord(); + coordinate = zone.getRandomCoord(SiloUtil.provideNewRandom()); } mitoOccupation = new MitoJob(zone, coordinate, job.getId()); mitoOccupation.setStartTime_min((int) (job.getStartTimeInSeconds().get() / 60.)); - mitoOccupation.setEndTime_min((int) ((job.getStartTimeInSeconds().get() + job.getWorkingTimeInSeconds().get()) / 60.)); + final int endTime = (int) ((job.getStartTimeInSeconds().get() + job.getWorkingTimeInSeconds().get()) / 60.); + mitoOccupation.setEndTime_min(endTime); } break; case UNEMPLOYED: diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java index f3716f4e9..f17cb5c6d 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java @@ -1,148 +1,139 @@ -//package de.tum.bgu.msm.transportModel.matsim; -// -//import ch.sbb.matsim.routing.pt.raptor.*; -//import com.google.common.collect.Lists; -//import org.junit.Ignore; -//import org.junit.Test; -//import org.matsim.api.core.v01.Coord; -//import org.matsim.api.core.v01.Id; -//import org.matsim.api.core.v01.Scenario; -//import org.matsim.api.core.v01.TransportMode; -//import org.matsim.api.core.v01.population.Activity; -//import org.matsim.api.core.v01.population.Leg; -//import org.matsim.api.core.v01.population.PlanElement; -//import org.matsim.api.core.v01.population.Population; -//import org.matsim.core.config.Config; -//import org.matsim.core.config.ConfigUtils; -//import org.matsim.core.controler.Controler; -//import org.matsim.core.controler.OutputDirectoryHierarchy; -//import org.matsim.core.network.io.MatsimNetworkReader; -//import org.matsim.core.population.PopulationUtils; -//import org.matsim.core.router.*; -//import org.matsim.core.router.util.LeastCostPathCalculator; -//import org.matsim.core.scenario.ScenarioUtils; -//import org.matsim.facilities.ActivityFacilitiesFactory; -//import org.matsim.facilities.ActivityFacilitiesFactoryImpl; -//import org.matsim.facilities.ActivityFacility; -//import org.matsim.facilities.Facility; -//import org.matsim.pt.PtConstants; -//import org.matsim.pt.transitSchedule.api.TransitScheduleReader; -//import org.matsim.pt.transitSchedule.api.TransitStopFacility; -//import org.matsim.vehicles.VehicleReaderV1; -// -//import javax.inject.Provider; -//import java.util.List; -//import java.util.Map; -// -//public class SBBTest { -// -// @Ignore -// @Test -// public void test() { -// Config config = ConfigUtils.createConfig(); -// -// Scenario scenario = ScenarioUtils.createScenario(config); -// -// new MatsimNetworkReader(scenario.getNetwork()).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\network2018.xml"); -// new TransitScheduleReader(scenario).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\schedule2018.xml"); -// -//// Provider provider = () -> -//// new DefaultRaptorStopFinder( -//// null, -//// new DefaultRaptorIntermodalAccessEgress(), -//// null); -//// -//// Population pop = PopulationUtils.createPopulation(config); -//// final SwissRailRaptorFactory swissRailRaptorFactory = new SwissRailRaptorFactory( -//// scenario.getTransitSchedule(), -//// config, -//// scenario.getNetwork(), -//// new DefaultRaptorParametersForPerson(config), -//// new LeastCostRaptorRouteSelector(), -//// provider, -//// config.plans(), -//// pop, -//// null -//// ); -//// -//// TripRouter.Builder bd = new TripRouter.Builder(ConfigUtils.createConfig()); -//// TeleportationRoutingModule teleportationRoutingModule = -//// new TeleportationRoutingModule( -//// TransportMode.transit_walk, -//// PopulationUtils.getFactory(), -//// 1.4, -//// 1.3); -//// RoutingModule routingModule = -//// new SwissRailRaptorRoutingModule( -//// swissRailRaptorFactory.get(), -//// scenario.getTransitSchedule(), -//// scenario.getNetwork(), -//// teleportationRoutingModule); -//// bd.setRoutingModule(TransportMode.pt, routingModule); -//// -// -// Population population = PopulationUtils.createPopulation(config); -// TripRouter.Builder bd = new TripRouter.Builder(config); -// -//// TeleportationRoutingModule teleportationRoutingModule = new TeleportationRoutingModule(TransportMode.pt, PopulationUtils.getFactory(), 10, 1.3); -//// bd.setRoutingModule(TransportMode.pt, teleportationRoutingModule); -// -// +package de.tum.bgu.msm.transportModel.matsim; + +import ch.sbb.matsim.routing.pt.raptor.*; +import org.junit.Ignore; +import org.junit.Test; +import org.matsim.api.core.v01.Coord; +import org.matsim.api.core.v01.Id; +import org.matsim.api.core.v01.Scenario; +import org.matsim.api.core.v01.TransportMode; +import org.matsim.api.core.v01.population.Population; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; +import org.matsim.core.network.io.MatsimNetworkReader; +import org.matsim.core.population.PopulationUtils; +import org.matsim.core.router.RoutingModule; +import org.matsim.core.router.TeleportationRoutingModule; +import org.matsim.core.router.TripRouter; +import org.matsim.core.scenario.ScenarioUtils; +import org.matsim.facilities.ActivityFacilitiesFactory; +import org.matsim.facilities.ActivityFacilitiesFactoryImpl; +import org.matsim.facilities.ActivityFacility; +import org.matsim.facilities.Facility; +import org.matsim.pt.transitSchedule.api.TransitScheduleReader; +import org.matsim.pt.transitSchedule.api.TransitStopFacility; + +import java.util.Map; + +public class SBBTest { + + @Ignore + @Test + public void test() { + Config config = ConfigUtils.createConfig(); + + Scenario scenario = ScenarioUtils.createScenario(config); + + new MatsimNetworkReader(scenario.getNetwork()).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\network2018.xml"); + new TransitScheduleReader(scenario).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\schedule2018.xml"); + +// Provider provider = () -> +// new DefaultRaptorStopFinder( +// null, +// new DefaultRaptorIntermodalAccessEgress(), +// null); +// +// Population pop = PopulationUtils.createPopulation(config); +// final SwissRailRaptorFactory swissRailRaptorFactory = new SwissRailRaptorFactory( +// scenario.getTransitSchedule(), +// config, +// scenario.getNetwork(), +// new DefaultRaptorParametersForPerson(config), +// new LeastCostRaptorRouteSelector(), +// provider, +// config.plans(), +// pop, +// null +// ); +// +// TripRouter.Builder bd = new TripRouter.Builder(ConfigUtils.createConfig()); // TeleportationRoutingModule teleportationRoutingModule = // new TeleportationRoutingModule( // TransportMode.transit_walk, // PopulationUtils.getFactory(), // 1.4, // 1.3); -// -// RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); -// raptorConfig.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); -// SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), raptorConfig, scenario.getNetwork()); -// SwissRailRaptor raptor = new SwissRailRaptor(raptorData, new DefaultRaptorParametersForPerson(config), null, new DefaultRaptorStopFinder( -// null, -// new DefaultRaptorIntermodalAccessEgress(), -// null)); -// // RoutingModule routingModule = // new SwissRailRaptorRoutingModule( -// raptor, +// swissRailRaptorFactory.get(), // scenario.getTransitSchedule(), // scenario.getNetwork(), // teleportationRoutingModule); // bd.setRoutingModule(TransportMode.pt, routingModule); // -// -// final Coord originCoord = new Coord(4436689.657372447, 5368527.815536651); -// ActivityFacilitiesFactoryImpl activityFacilitiesFactory = new ActivityFacilitiesFactoryImpl(); -// Facility fromFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(1, ActivityFacility.class), originCoord); -// -// long time = System.currentTimeMillis(); -// final Map, SwissRailRaptorCore.TravelInfo> idTravelInfoMap = raptor.calcTree(fromFacility, 28800, null); -// -// System.out.println(System.currentTimeMillis() - time); -// -// TripRouter router = bd.build(); -// -//// final Coord destinationCoord = new Coord(4489369.625538794, 5294502.251605561); -//// -//// Facility toFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(2, ActivityFacility.class), destinationCoord); -//// -//// long timeQuery = System.currentTimeMillis(); -//// -//// double time = 0; -//// List planElements = router.calcRoute(TransportMode.pt, fromFacility, toFacility, 28800, null); -//// System.out.println(System.currentTimeMillis()-timeQuery); -//// -//// for (PlanElement e : planElements) { -//// if (e instanceof Leg) { -//// time += ((Leg) e).getTravelTime(); -//// } else if (e instanceof Activity) { -//// if (((Activity) e).getType().equalsIgnoreCase(PtConstants.TRANSIT_ACTIVITY_TYPE)) { -//// time += ((Activity) e).getEndTime() - ((Activity) e).getStartTime(); -//// } -//// } -//// } -// -// -// } -//} + + Population population = PopulationUtils.createPopulation(config); + TripRouter.Builder bd = new TripRouter.Builder(config); + +// TeleportationRoutingModule teleportationRoutingModule = new TeleportationRoutingModule(TransportMode.pt, PopulationUtils.getFactory(), 10, 1.3); +// bd.setRoutingModule(TransportMode.pt, teleportationRoutingModule); + + + TeleportationRoutingModule teleportationRoutingModule = + new TeleportationRoutingModule( + TransportMode.transit_walk, + scenario, + 1.4, + 1.3); + + RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); + raptorConfig.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); + SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), raptorConfig, scenario.getNetwork()); + SwissRailRaptor raptor = new SwissRailRaptor(raptorData, new DefaultRaptorParametersForPerson(config), null, new DefaultRaptorStopFinder( + null, + new DefaultRaptorIntermodalAccessEgress(), + null)); + + RoutingModule routingModule = + new SwissRailRaptorRoutingModule( + raptor, + scenario.getTransitSchedule(), + scenario.getNetwork(), + teleportationRoutingModule); + bd.setRoutingModule(TransportMode.pt, routingModule); + + + final Coord originCoord = new Coord(4436689.657372447, 5368527.815536651); + ActivityFacilitiesFactoryImpl activityFacilitiesFactory = new ActivityFacilitiesFactoryImpl(); + Facility fromFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(1, ActivityFacility.class), originCoord); + + long time = System.currentTimeMillis(); + final Map, SwissRailRaptorCore.TravelInfo> idTravelInfoMap = raptor.calcTree(fromFacility, 28800, null); + + System.out.println(System.currentTimeMillis() - time); + + TripRouter router = bd.build(); + +// final Coord destinationCoord = new Coord(4489369.625538794, 5294502.251605561); +// +// Facility toFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(2, ActivityFacility.class), destinationCoord); +// +// long timeQuery = System.currentTimeMillis(); +// +// double time = 0; +// List planElements = router.calcRoute(TransportMode.pt, fromFacility, toFacility, 28800, null); +// System.out.println(System.currentTimeMillis()-timeQuery); +// +// for (PlanElement e : planElements) { +// if (e instanceof Leg) { +// time += ((Leg) e).getTravelTime(); +// } else if (e instanceof Activity) { +// if (((Activity) e).getType().equalsIgnoreCase(PtConstants.TRANSIT_ACTIVITY_TYPE)) { +// time += ((Activity) e).getEndTime() - ((Activity) e).getStartTime(); +// } +// } +// } + + + } +} diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java index fbd6cb940..e64519011 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java @@ -7,6 +7,9 @@ import de.tum.bgu.msm.io.output.DefaultResultsMonitor; import de.tum.bgu.msm.io.output.ResultsMonitor; import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.scenarios.noise.DataBuilderNoise; +import de.tum.bgu.msm.scenarios.noise.ModelBuilderMucNoise; +import de.tum.bgu.msm.scenarios.noise.NoiseDataContainerImpl; import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.utils.SiloUtil; import junitx.framework.FileAssert; @@ -66,10 +69,10 @@ public final void testMain() { Properties properties = SiloUtil.siloInitialization(path); - DataContainerWithSchools dataContainer = DataBuilder.getModelDataForMuc(properties, config); - DataBuilder.read(properties, dataContainer); + NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); + DataBuilderNoise.read(properties, dataContainer); - ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, config); + ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); ResultsMonitor resultsMonitor = new DefaultResultsMonitor(dataContainer, properties); SiloModel siloModel = new SiloModel(properties, dataContainer, modelContainer); diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java index 98bdb37ea..d291c7a60 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java @@ -7,6 +7,9 @@ import de.tum.bgu.msm.io.output.DefaultResultsMonitor; import de.tum.bgu.msm.io.output.ResultsMonitor; import de.tum.bgu.msm.properties.Properties; +import de.tum.bgu.msm.scenarios.noise.DataBuilderNoise; +import de.tum.bgu.msm.scenarios.noise.ModelBuilderMucNoise; +import de.tum.bgu.msm.scenarios.noise.NoiseDataContainerImpl; import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.utils.SiloUtil; import junitx.framework.FileAssert; @@ -38,10 +41,10 @@ public final void testMain() { String path = "./test/muc/siloMucTest.properties"; Properties properties = SiloUtil.siloInitialization(path); - DataContainerWithSchools dataContainer = DataBuilder.getModelDataForMuc(properties, null); + NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, null); DataBuilder.read(properties, dataContainer); - ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, null); + ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, null); ResultsMonitor resultsMonitor = new DefaultResultsMonitor(dataContainer, properties); SiloModel siloModel = new SiloModel(properties, dataContainer, modelContainer); diff --git a/useCases/pom.xml b/useCases/pom.xml index 52c939ca1..d1c5e9614 100644 --- a/useCases/pom.xml +++ b/useCases/pom.xml @@ -241,6 +241,6 @@ ${buildNumber} false 2.9.5 - 12.0-SNAPSHOT + 13.0-SNAPSHOT From e7ee8c05995a02b1806718875d7554362d6cc6aa Mon Sep 17 00:00:00 2001 From: Nico Date: Sun, 31 Jan 2021 21:27:55 +0100 Subject: [PATCH 15/24] add hedonic pricing model --- .../de/tum/bgu/msm/matsim/MatsimData.java | 22 ++-- .../bgu/msm/matsim/MatsimTransportModel.java | 3 +- .../msm/matsim/MatsimTravelTimesAndCosts.java | 6 +- .../main/java/de/tum/bgu/msm/DataBuilder.java | 2 +- .../disabilities/DataBuilderDisability.java | 2 +- .../disabilities/PersonMucDisability.java | 12 ++ .../msm/scenarios/noise/DataBuilderNoise.java | 11 +- .../noise/HedonicPricingModelImpl.java | 95 ++++++++++++++++ .../noise/HedonicPricingModelPredictor.java | 8 ++ ...iseInsensitiveDwellingUtilityStrategy.java | 10 +- ...NoiseSensitiveDwellingUtilityStrategy.java | 11 +- .../scenarios/noise/ModelBuilderMucNoise.java | 3 +- .../ModelBuilderMucNoiseInsensitive.java | 3 +- .../noise/NKHedonicPricingModelPredictor.java | 106 ++++++++++++++++++ .../noise/NKHedonicPricingModelState.java | 12 ++ .../noise/NoiseDataContainerImpl.java | 2 +- .../msm/scenarios/noise/NoiseDwellingIml.java | 12 ++ ...eSensitiveDwellingUtilityStrategyTest.java | 10 +- .../msm/transportModel/matsim/SBBTest.java | 4 +- .../transportModel/matsim/SiloNoiseTest.java | 11 +- 20 files changed, 298 insertions(+), 47 deletions(-) create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelPredictor.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelState.java diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index 809aae2dc..2f67287a5 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -9,6 +9,7 @@ import org.matsim.api.core.v01.network.Network; import org.matsim.core.config.Config; import org.matsim.core.config.ConfigUtils; +import org.matsim.core.config.groups.PlansCalcRouteConfigGroup; import org.matsim.core.network.NetworkUtils; import org.matsim.core.network.algorithms.TransportModeNetworkFilter; import org.matsim.core.population.PopulationUtils; @@ -18,6 +19,7 @@ import org.matsim.core.router.util.LeastCostPathCalculatorFactory; import org.matsim.core.router.util.TravelDisutility; import org.matsim.core.router.util.TravelTime; +import org.matsim.core.scenario.ScenarioUtils; import org.matsim.pt.transitSchedule.api.TransitSchedule; import java.util.Collection; @@ -125,11 +127,11 @@ public void update(TravelDisutility travelDisutility, TravelTime travelTime) { if (config.transit().isUseTransit() && schedule != null) { RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); - raptorData = SwissRailRaptorData.create(schedule, raptorConfig, ptNetwork); + raptorData = SwissRailRaptorData.create(schedule, null, raptorConfig, ptNetwork, null); RaptorStaticConfig raptorConfigOneToAll = RaptorUtils.createStaticConfig(config); raptorConfigOneToAll.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); - raptorDataOneToAll = SwissRailRaptorData.create(schedule, raptorConfigOneToAll, ptNetwork); + raptorDataOneToAll = SwissRailRaptorData.create(schedule, null, raptorConfigOneToAll, ptNetwork, null); parametersForPerson = new DefaultRaptorParametersForPerson(config); defaultRaptorStopFinder = new DefaultRaptorStopFinder( @@ -150,10 +152,10 @@ MultiNodePathCalculator createFreeSpeedMultiNodePathCalculator() { } TripRouter createTripRouter() { - final RoutingModule carRoutingModule; - if (config.plansCalcRoute().isInsertingAccessEgressWalk()) { - carRoutingModule = DefaultRoutingModules.createAccessEgressNetworkRouter( - TransportMode.car, PopulationUtils.getFactory(), carNetwork, leastCostPathCalculatorFactory.createPathCalculator(carNetwork, travelDisutility, travelTime), config.plansCalcRoute()); + RoutingModule carRoutingModule = null; + if (config.plansCalcRoute().getAccessEgressType().equals(PlansCalcRouteConfigGroup.AccessEgressType.walkConstantTimeToLink)) { +// carRoutingModule = DefaultRoutingModules.createAccessEgressNetworkRouter( +// TransportMode.car, leastCostPathCalculatorFactory.createPathCalculator(carNetwork, travelDisutility, travelTime), ScenarioUtils.createScenario(config), carNetwork , Defau); } else { carRoutingModule = DefaultRoutingModules.createPureNetworkRouter( TransportMode.car, PopulationUtils.getFactory(), carNetwork, leastCostPathCalculatorFactory.createPathCalculator(carNetwork, travelDisutility, travelTime)); @@ -162,7 +164,7 @@ TripRouter createTripRouter() { if (schedule != null && config.transit().isUseTransit()) { final RoutingModule teleportationRoutingModule = DefaultRoutingModules.createTeleportationRouter( - TransportMode.walk, PopulationUtils.getFactory(), config.plansCalcRoute().getOrCreateModeRoutingParams(TransportMode.walk)); + TransportMode.walk, ScenarioUtils.createScenario(config), config.plansCalcRoute().getOrCreateModeRoutingParams(TransportMode.walk)); final SwissRailRaptor swissRailRaptor = createSwissRailRaptor(RaptorStaticConfig.RaptorOptimization.OneToOneRouting); ptRoutingModule = new SwissRailRaptorRoutingModule(swissRailRaptor, schedule, ptNetwork, teleportationRoutingModule); } else { @@ -179,9 +181,9 @@ TripRouter createTripRouter() { SwissRailRaptor createSwissRailRaptor(RaptorStaticConfig.RaptorOptimization optimitzaion) { switch (optimitzaion) { case OneToAllRouting: - return new SwissRailRaptor(raptorDataOneToAll, parametersForPerson, routeSelector, defaultRaptorStopFinder); + return new SwissRailRaptor(raptorDataOneToAll, parametersForPerson, routeSelector, defaultRaptorStopFinder, null, null); case OneToOneRouting: - return new SwissRailRaptor(raptorData, parametersForPerson, routeSelector, defaultRaptorStopFinder); + return new SwissRailRaptor(raptorData, parametersForPerson, routeSelector, defaultRaptorStopFinder, null, null); default: throw new RuntimeException("Unrecognized raptor optimization!"); } @@ -193,7 +195,7 @@ LeastCostPathCalculator createLeastCostPathCalculator() { RoutingModule getTeleportationRouter(String mode) { return DefaultRoutingModules.createTeleportationRouter( - mode, PopulationUtils.getFactory(), config.plansCalcRoute().getOrCreateModeRoutingParams(mode)); + mode, ScenarioUtils.createScenario(config), config.plansCalcRoute().getOrCreateModeRoutingParams(mode)); } SwissRailRaptorData getRaptorData(RaptorStaticConfig.RaptorOptimization optimization) { diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java index 4fb285ae4..1a8b58c25 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java @@ -32,6 +32,7 @@ import org.matsim.contrib.noise.NoiseReceiverPoints; import org.matsim.core.config.Config; import org.matsim.core.config.ConfigUtils; +import org.matsim.core.config.groups.PlansCalcRouteConfigGroup; import org.matsim.core.controler.Controler; import org.matsim.core.controler.ControlerDefaults; import org.matsim.core.controler.OutputDirectoryHierarchy; @@ -145,7 +146,7 @@ private void finalizeConfig(Config config, int year) { config.controler().setWriteEventsInterval(Math.max(config.controler().getLastIteration(), 1)); config.controler().setOverwriteFileSetting(OutputDirectoryHierarchy.OverwriteFileSetting.deleteDirectoryIfExists); if (properties.transportModel.includeAccessEgress) { - config.plansCalcRoute().setInsertingAccessEgressWalk(true); + config.plansCalcRoute().setAccessEgressType(PlansCalcRouteConfigGroup.AccessEgressType.walkConstantTimeToLink); } config.transit().setUsingTransitInMobsim(false); } diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimesAndCosts.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimesAndCosts.java index 223a5aecd..bd57d7498 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimesAndCosts.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTravelTimesAndCosts.java @@ -130,7 +130,7 @@ public double getTravelTime(Location origin, Location destination, double timeOf if (!planElements.isEmpty()) { final Leg lastLeg = (Leg) planElements.get(planElements.size() - 1); - arrivalTime = lastLeg.getDepartureTime() + lastLeg.getTravelTime(); + arrivalTime = lastLeg.getDepartureTime().seconds()+ lastLeg.getTravelTime().seconds(); } double time = arrivalTime - timeOfDay_s; @@ -157,10 +157,10 @@ public double getGeneralizedTravelCosts(Location origin, Location destination, d } else if (routingModule instanceof SwissRailRaptorRoutingModule || routingModule instanceof FreespeedFactorRoutingModule) { for (PlanElement pe : planElements) { if (pe instanceof Leg) { - double time = ((Leg) pe).getTravelTime(); + double time = ((Leg) pe).getTravelTime().seconds(); // overrides individual parameters per person; use default scoring parameters - if (Time.getUndefinedTime() != time) { + if (((Leg) pe).getTravelTime().isDefined()) { utility += time * (cnScoringGroup.getModes().get(mode).getMarginalUtilityOfTraveling() - cnScoringGroup.getPerforming_utils_hr()) / 3600; } Double dist = ((Leg) pe).getRoute().getDistance(); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java b/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java index dff74ebb6..ab52bb8bf 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/DataBuilder.java @@ -96,7 +96,7 @@ static public void read(Properties properties, DataContainerWithSchools dataCont PersonReader personReader = new PersonReaderMuc(dataContainer.getHouseholdDataManager()); personReader.readData(personFile); - DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager(), new DwellingFactoryImpl()); + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager().getDwellingData(), new DwellingFactoryImpl()); String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; ddReader.readData(dwellingsFile); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java index 3097e8629..75993f50b 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/DataBuilderDisability.java @@ -95,7 +95,7 @@ static public void read(Properties properties, DataContainerWithSchoolsImpl data PersonReader personReader = new PersonReaderMucDisability(dataContainer.getHouseholdDataManager(), new DefaultDisabilityStrategy()); personReader.readData(personFile); - DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager(), new DwellingFactoryImpl()); + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager().getDwellingData(), new DwellingFactoryImpl()); String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; ddReader.readData(dwellingsFile); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java index 17c209de6..f0d7292ac 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/disabilities/PersonMucDisability.java @@ -4,6 +4,8 @@ import de.tum.bgu.msm.data.person.*; import de.tum.bgu.msm.schools.PersonWithSchool; +import java.util.Optional; + public class PersonMucDisability implements PersonWithSchool { private final PersonMuc delegate; @@ -143,4 +145,14 @@ public void setDriverLicense(boolean driverLicense) { public boolean hasDriverLicense() { return delegate.hasDriverLicense(); } + + @Override + public Optional getAttribute(String key) { + return Optional.empty(); + } + + @Override + public void setAttribute(String key, Object value) { + + } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java index f2feb4c00..664ef9dfe 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/DataBuilderNoise.java @@ -3,6 +3,7 @@ import de.tum.bgu.msm.data.accessibility.Accessibility; import de.tum.bgu.msm.data.accessibility.AccessibilityImpl; import de.tum.bgu.msm.data.accessibility.CommutingTimeProbability; +import de.tum.bgu.msm.data.accessibility.CommutingTimeProbabilityImpl; import de.tum.bgu.msm.data.dwelling.*; import de.tum.bgu.msm.data.geo.DefaultGeoData; import de.tum.bgu.msm.data.geo.GeoData; @@ -13,7 +14,7 @@ import de.tum.bgu.msm.data.travelTimes.TravelTimes; import de.tum.bgu.msm.io.*; import de.tum.bgu.msm.io.input.*; -import de.tum.bgu.msm.matsim.MatsimTravelTimes; +import de.tum.bgu.msm.matsim.MatsimTravelTimesAndCosts; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.schools.*; import org.matsim.core.config.Config; @@ -40,7 +41,7 @@ public static NoiseDataContainerImpl getModelDataForMuc(Properties properties, C accessibility = new AccessibilityImpl(geoData, travelTimes, properties, dwellingData, jobData); break; case MATSIM: - travelTimes = new MatsimTravelTimes(config); + travelTimes = new MatsimTravelTimesAndCosts(config); // accessibility = new MatsimAccessibility(geoData); accessibility = new AccessibilityImpl(geoData, travelTimes, properties, dwellingData, jobData); break; @@ -48,7 +49,7 @@ public static NoiseDataContainerImpl getModelDataForMuc(Properties properties, C throw new RuntimeException("Travel time not recognized! Please set property \"travel.time\" accordingly!"); } - CommutingTimeProbability commutingTimeProbability = new CommutingTimeProbability(properties); + CommutingTimeProbability commutingTimeProbability = new CommutingTimeProbabilityImpl(properties); //TODO: revise this! new JobType(properties.jobData.jobTypes); @@ -59,7 +60,7 @@ public static NoiseDataContainerImpl getModelDataForMuc(Properties properties, C RealEstateDataManager realEstateDataManager = new RealEstateDataManagerImpl( - DefaultDwellingTypeImpl.values(), dwellingData, householdData, geoData, new NoiseDwellingFactory(new DwellingFactoryImpl()), properties); + new DefaultDwellingTypes(), dwellingData, householdData, geoData, new NoiseDwellingFactory(new DwellingFactoryImpl()), properties); JobDataManager jobDataManager = new JobDataManagerImpl( properties, jobFactory, jobData, geoData, travelTimes, commutingTimeProbability); @@ -96,7 +97,7 @@ static public void read(Properties properties, NoiseDataContainerImpl dataContai PersonReader personReader = new PersonReaderMuc(dataContainer.getHouseholdDataManager()); personReader.readData(personFile); - DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager(), new NoiseDwellingFactory(new DwellingFactoryImpl())); + DwellingReader ddReader = new DwellingReaderMuc(dataContainer.getRealEstateDataManager().getDwellingData(), new NoiseDwellingFactory(new DwellingFactoryImpl())); String dwellingsFile = properties.main.baseDirectory + properties.realEstate.dwellingsFileName + "_" + year + ".csv"; ddReader.readData(dwellingsFile); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java new file mode 100644 index 000000000..b7408b0c9 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java @@ -0,0 +1,95 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.container.DataContainer; +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingType; +import de.tum.bgu.msm.models.AbstractModel; +import de.tum.bgu.msm.models.realEstate.pricing.PricingModel; +import de.tum.bgu.msm.models.realEstate.pricing.PricingModelImpl; +import de.tum.bgu.msm.models.realEstate.pricing.PricingStrategy; +import de.tum.bgu.msm.properties.Properties; +import org.apache.log4j.Logger; + +import java.util.List; +import java.util.Map; +import java.util.Random; + +public class HedonicPricingModelImpl extends AbstractModel implements PricingModel { + + private final static Logger logger = Logger.getLogger(PricingModelImpl.class); + + private final PricingStrategy strategy; + private final HedonicPricingModelPredictor hedonicPredictor; + + public HedonicPricingModelImpl(DataContainer dataContainer, Properties properties, PricingStrategy strategy, Random rnd, HedonicPricingModelPredictor hedonicPredictor) { + super(dataContainer, properties, rnd); + this.strategy = strategy; + this.hedonicPredictor = hedonicPredictor; + } + + @Override + public void setup() { + updateRealEstatePrices(properties.main.baseYear); + } + + @Override + public void prepareYear(int year) { + } + + @Override + public void endYear(int year) { + updateRealEstatePrices(year); + } + + @Override + public void endSimulation() { + } + + private void updateRealEstatePrices(int year) { + // updated prices based on current demand + logger.info(" Updating real-estate prices at " + year); + + // get vacancy rate + double[][] vacRate = dataContainer.getRealEstateDataManager().getVacancyRateByTypeAndRegion(); + List dwellingTypes = dataContainer.getRealEstateDataManager().getDwellingTypes().getTypes(); + + final Map currentRentByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); + + for (Dwelling dd : dataContainer.getRealEstateDataManager().getDwellings()) { + dd.setPrice((int) hedonicPredictor.predictPrice(dd)); + } + + final Map newRentByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); + + int[] cnt = new int[dwellingTypes.size()]; + double[] sumOfPrices = new double[dwellingTypes.size()]; + + for (Dwelling dd : dataContainer.getRealEstateDataManager().getDwellings()) { + int region = dataContainer.getGeoData().getZones().get(dd.getZoneId()).getRegion().getId(); + double scaleFactor = (double) currentRentByRegion.get(region) / newRentByRegion.get(region); + int tempPrice = dd.getPrice(); + tempPrice *= scaleFactor; + + int dto = dwellingTypes.indexOf(dd.getType()); + if (!strategy.isPriceUpdateAllowed(dd)) { + double vacancyRateAtThisRegion = vacRate[dto][region]; + float structuralVacancyRate = dd.getType().getStructuralVacancyRate(); + double changeRate = strategy.getPriceChangeRate(vacancyRateAtThisRegion, structuralVacancyRate); + tempPrice *= changeRate; + + } + dd.setPrice((int) (tempPrice + 0.5)); + cnt[dto]++; + sumOfPrices[dto] += tempPrice; + } + + double[] averagePrice = new double[dwellingTypes.size()]; + logger.info("Updated average real-estate prices by dwelling type:"); + for (DwellingType dt : dwellingTypes) { + int dto = dwellingTypes.indexOf(dt); + averagePrice[dto] = sumOfPrices[dto] / cnt[dto]; + logger.info(dt + ": " + averagePrice[dto]); + } + dataContainer.getRealEstateDataManager().setAvePriceByDwellingType(averagePrice); + } +} \ No newline at end of file diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelPredictor.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelPredictor.java new file mode 100644 index 000000000..474db8efd --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelPredictor.java @@ -0,0 +1,8 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; + +public interface HedonicPricingModelPredictor { + + double predictPrice(Dwelling dwelling); +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java index 859c91fe1..1725bc631 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseInsensitiveDwellingUtilityStrategy.java @@ -1,7 +1,7 @@ package de.tum.bgu.msm.scenarios.noise; import de.tum.bgu.msm.data.Region; -import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypes; import de.tum.bgu.msm.data.dwelling.Dwelling; import de.tum.bgu.msm.data.dwelling.DwellingType; import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; @@ -180,13 +180,13 @@ private int translateDwellingType(Dwelling dwelling) { // final DwellingType type = MF234; - if(type.equals(DefaultDwellingTypeImpl.SFD)) { + if(type.equals(DefaultDwellingTypes.DefaultDwellingTypeImpl.SFD)) { return SINGLE_FAMILY; - } else if( type.equals(DefaultDwellingTypeImpl.SFA)) { + } else if( type.equals(DefaultDwellingTypes.DefaultDwellingTypeImpl.SFA)) { return DUPLEX; - } else if(type.equals(DefaultDwellingTypeImpl.MF234)) { + } else if(type.equals(DefaultDwellingTypes.DefaultDwellingTypeImpl.MF234)) { return TOWNHOUSE; - } else if(type.equals(DefaultDwellingTypeImpl.MF5plus)) { + } else if(type.equals(DefaultDwellingTypes.DefaultDwellingTypeImpl.MF5plus)) { return HIGHRISE; } else { //can only happen for mobile home which shouldn't exist in muc diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java index e30819dd6..9f432d4cb 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -1,7 +1,7 @@ package de.tum.bgu.msm.scenarios.noise; import de.tum.bgu.msm.data.Region; -import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypes; import de.tum.bgu.msm.data.dwelling.Dwelling; import de.tum.bgu.msm.data.dwelling.DwellingType; import de.tum.bgu.msm.data.dwelling.RealEstateDataManager; @@ -18,7 +18,8 @@ import java.util.Objects; -import static de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl.MF234; +import static de.tum.bgu.msm.data.dwelling.DefaultDwellingTypes.DefaultDwellingTypeImpl.MF234; + /** * This relocation model is based on a stated preference study by J.D. Hunt @@ -252,13 +253,13 @@ private int translateDwellingType(Dwelling dwelling) { // final DwellingType type = MF234; - if(type.equals(DefaultDwellingTypeImpl.SFD)) { + if(type.equals(DefaultDwellingTypes.DefaultDwellingTypeImpl.SFD)) { return SINGLE_FAMILY; - } else if( type.equals(DefaultDwellingTypeImpl.SFA)) { + } else if( type.equals(DefaultDwellingTypes.DefaultDwellingTypeImpl.SFA)) { return DUPLEX; } else if(type.equals(MF234)) { return TOWNHOUSE; - } else if(type.equals(DefaultDwellingTypeImpl.MF5plus)) { + } else if(type.equals(DefaultDwellingTypes.DefaultDwellingTypeImpl.MF5plus)) { return HIGHRISE; } else { //can only happen for mobile home which shouldn't exist in muc diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java index 4763c2f09..93fd05146 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -37,6 +37,7 @@ import de.tum.bgu.msm.models.demography.marriage.MarriageModel; import de.tum.bgu.msm.models.jobmography.JobMarketUpdate; import de.tum.bgu.msm.models.jobmography.JobMarketUpdateImpl; +import de.tum.bgu.msm.models.modeChoice.SimpleCommuteModeChoice; import de.tum.bgu.msm.models.realEstate.construction.*; import de.tum.bgu.msm.models.realEstate.demolition.DefaultDemolitionStrategy; import de.tum.bgu.msm.models.realEstate.demolition.DemolitionModel; @@ -78,7 +79,7 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data = new HousingStrategyMuc(dataContainer, properties, dataContainer.getTravelTimes(), new DefaultDwellingProbabilityStrategy(), new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), - new RegionProbabilityStrategyImpl()); + new RegionProbabilityStrategyImpl(), new SimpleCommuteModeChoice(dataContainer, properties,SiloUtil.getRandomObject())); HuntNoiseSensitiveDwellingUtilityStrategy housingStrategy = new HuntNoiseSensitiveDwellingUtilityStrategy(dataContainer.getTravelTimes(), diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java index 371c000ca..c7e0a2688 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java @@ -37,6 +37,7 @@ import de.tum.bgu.msm.models.demography.marriage.MarriageModel; import de.tum.bgu.msm.models.jobmography.JobMarketUpdate; import de.tum.bgu.msm.models.jobmography.JobMarketUpdateImpl; +import de.tum.bgu.msm.models.modeChoice.SimpleCommuteModeChoice; import de.tum.bgu.msm.models.realEstate.construction.*; import de.tum.bgu.msm.models.realEstate.demolition.DefaultDemolitionStrategy; import de.tum.bgu.msm.models.realEstate.demolition.DemolitionModel; @@ -78,7 +79,7 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data = new HousingStrategyMuc(dataContainer, properties, dataContainer.getTravelTimes(), new DefaultDwellingProbabilityStrategy(), new DwellingUtilityStrategyImpl(), new RegionUtilityStrategyMucImpl(), - new RegionProbabilityStrategyImpl()); + new RegionProbabilityStrategyImpl(), new SimpleCommuteModeChoice(dataContainer, properties, SiloUtil.getRandomObject())); HuntNoiseInsensitiveDwellingUtilityStrategy housingStrategy = new HuntNoiseInsensitiveDwellingUtilityStrategy(dataContainer.getTravelTimes(), diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java new file mode 100644 index 000000000..5e6dd45b2 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java @@ -0,0 +1,106 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.matsim.noise.NoiseDwelling; + +import java.util.function.Supplier; + +public class NKHedonicPricingModelPredictor implements HedonicPricingModelPredictor { + + private static double INTERCEPT = 2.2390; + + private static double BETA_LOG_AREA = 0.7706; + + private static double BETA_LOW_NOISE = 0; + private static double BETA_MEDIUM_NOISE = -0.0360; + private static double BETA_LOUD_NOISE = -0.0583; + private static double BETA_VERY_LOUD_NOISE = -0.1005; + + private static double BETA_ACCESSIBILITY = 0.2165; + private static double BETA_PARKING_AVAILABLE = 0.0180; + + private static double BETA_LUXURY_QUALITY = 0.1678; + private static double BETA_SUPERIOR_QUALITY = 0; + private static double BETA_AVERAGE_QUALITY = -0.1430; + + private static double BETA_FIRST_TIME_USE_STATE = 0; + private static double BETA_NEW_BUILDING_STATE = -0.0298; + private static double BETA_FIRST_TIME_USE_AFTER_RESTORATION_STATE = -0.0815; + private static double BETA_RESTORED_STATE = -0.1020; + private static double BETA_MODERNIZED_STATE = -0.1171; + private static double BETA_WELL_KEPT_STATE = -0.1580; + private static double BETA_RENOVATED_STATE = -0.1697; + + //////////////////////////////// + + private final static double INTERCEPT_AREA = 8.1063; + private final static double BETA_ROOMS_AREA = 26.0538; + + @Override + public double predictPrice(Dwelling dwelling) { + + double logPrice = INTERCEPT; + + logPrice += BETA_LOG_AREA * estimateArea(dwelling); + + final double noiseImmission = ((NoiseDwelling) dwelling).getNoiseImmission(); + if(noiseImmission < 55) { + logPrice += BETA_LOW_NOISE; + } else if (noiseImmission < 65){ + logPrice += BETA_MEDIUM_NOISE; + } else if(noiseImmission < 75) { + logPrice += BETA_LOUD_NOISE; + } else { + logPrice += BETA_VERY_LOUD_NOISE; + } + + try { + logPrice += BETA_ACCESSIBILITY * dwelling.getAttribute("matsim_accessibility").map(o ->(Double) o).orElseThrow((Supplier) RuntimeException::new); + } catch (Throwable throwable) { + throwable.printStackTrace(); + } + + logPrice += BETA_PARKING_AVAILABLE * dwelling.getAttribute("parking_available").map(o -> (Integer) o).orElse(0); + logPrice += convertQualityToRentCoefficient(dwelling.getQuality()); + logPrice += getStateImpact(dwelling); + + return Math.exp(logPrice); + } + + private double getStateImpact(Dwelling dwelling) { + final NKHedonicPricingModelState state = (NKHedonicPricingModelState) dwelling.getAttribute("state").get(); + switch (state) { + case FIRST_TIME_USE_STATE: + return BETA_FIRST_TIME_USE_STATE; + case NEW_BUILDING_STATE: + return BETA_NEW_BUILDING_STATE; + case FIRST_TIME_USE_AFTER_RESTORATION_STATE: + return BETA_FIRST_TIME_USE_AFTER_RESTORATION_STATE; + case RESTORED_STATE: + return BETA_RESTORED_STATE; + case MODERNIZED_STATE: + return BETA_MODERNIZED_STATE; + case WELL_KEPT_STATE: + return BETA_WELL_KEPT_STATE; + case RENOVATED_STATE: + return BETA_RENOVATED_STATE; + default: + throw new RuntimeException(); + } + } + + private double convertQualityToRentCoefficient(int qualityLevel) { + if(qualityLevel < 3) { + return BETA_AVERAGE_QUALITY; + } else if(qualityLevel < 4) { + return BETA_SUPERIOR_QUALITY; + } else { + return BETA_LUXURY_QUALITY; + } + } + + private double estimateArea(Dwelling dwelling) { + double area = INTERCEPT_AREA + BETA_ROOMS_AREA * dwelling.getBedrooms(); + return area; + } +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelState.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelState.java new file mode 100644 index 000000000..ed5d062ab --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelState.java @@ -0,0 +1,12 @@ +package de.tum.bgu.msm.scenarios.noise; + +public enum NKHedonicPricingModelState { + + FIRST_TIME_USE_STATE, + NEW_BUILDING_STATE, + FIRST_TIME_USE_AFTER_RESTORATION_STATE, + RESTORED_STATE, + MODERNIZED_STATE, + WELL_KEPT_STATE, + RENOVATED_STATE; +} diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java index 6717fe4b9..222db7b82 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDataContainerImpl.java @@ -90,7 +90,7 @@ private void writeDwellingsWithNoise(int year) { + "_" + year + ".csv"; - new DefaultHouseholdWriter(delegate.getHouseholdDataManager()).writeHouseholds(fileHh); + new DefaultHouseholdWriter(delegate.getHouseholdDataManager().getHouseholds()).writeHouseholds(fileHh); String filePp = outputDirectory + properties.householdData.personFinalFileName diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java index 2c77f4184..7f1d4ce5e 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java @@ -6,6 +6,8 @@ import de.tum.bgu.msm.matsim.noise.NoiseDwelling; import org.locationtech.jts.geom.Coordinate; +import java.util.Optional; + public class NoiseDwellingIml implements NoiseDwelling { private final Dwelling delegate; @@ -100,6 +102,16 @@ public DwellingUsage getUsage() { return delegate.getUsage(); } + @Override + public Optional getAttribute(String key) { + return Optional.empty(); + } + + @Override + public void setAttribute(String key, Object value) { + + } + @Override public String toString() { return delegate.toString(); diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java index 05d1627f8..c7ffb5f47 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategyTest.java @@ -1,9 +1,7 @@ package de.tum.bgu.msm.scenarios.noise; -import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; -import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypes; import de.tum.bgu.msm.data.dwelling.DwellingFactoryImpl; -import de.tum.bgu.msm.data.dwelling.DwellingImpl; import de.tum.bgu.msm.data.household.Household; import de.tum.bgu.msm.data.person.Person; import de.tum.bgu.msm.matsim.noise.NoiseDwelling; @@ -37,15 +35,15 @@ public void test() { for(Person p: household.getPersons().values()) { p.setIncome(p.getAnnualIncome()+50000); } - NoiseDwelling quietDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); + NoiseDwelling quietDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypes.DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); quietDwelling.setNoiseImmision(40); final double v = strategy.calculateHousingUtility(household, quietDwelling); - NoiseDwelling noiseDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); + NoiseDwelling noiseDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypes.DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); noiseDwelling.setNoiseImmision(60); final double v1 = strategy.calculateHousingUtility(household, noiseDwelling); - NoiseDwelling noiseDwelling2 = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); + NoiseDwelling noiseDwelling2 = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(99999, 1, new Coordinate(40000,16000), -1, DefaultDwellingTypes.DefaultDwellingTypeImpl.SFD, 4, 3, 800, 1990)); noiseDwelling2.setNoiseImmision(66); final double v2 = strategy.calculateHousingUtility(household, noiseDwelling2); diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java index f17cb5c6d..cb4e834e4 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java @@ -88,11 +88,11 @@ public void test() { RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); raptorConfig.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); - SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), raptorConfig, scenario.getNetwork()); + SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), null, raptorConfig, scenario.getNetwork(), null); SwissRailRaptor raptor = new SwissRailRaptor(raptorData, new DefaultRaptorParametersForPerson(config), null, new DefaultRaptorStopFinder( null, new DefaultRaptorIntermodalAccessEgress(), - null)); + null), null, null); RoutingModule routingModule = new SwissRailRaptorRoutingModule( diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java index 489c50058..a68ca3c8f 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -1,14 +1,12 @@ package de.tum.bgu.msm.transportModel.matsim; -import de.tum.bgu.msm.SiloModel; import de.tum.bgu.msm.container.ModelContainer; import de.tum.bgu.msm.data.Location; import de.tum.bgu.msm.data.Region; import de.tum.bgu.msm.data.Zone; -import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypeImpl; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypes; import de.tum.bgu.msm.data.dwelling.Dwelling; import de.tum.bgu.msm.data.dwelling.DwellingFactoryImpl; -import de.tum.bgu.msm.data.dwelling.DwellingImpl; import de.tum.bgu.msm.data.household.Household; import de.tum.bgu.msm.data.household.HouseholdMuc; import de.tum.bgu.msm.data.person.Gender; @@ -32,7 +30,10 @@ import org.matsim.core.config.ConfigUtils; import org.matsim.testcases.MatsimTestUtils; -import java.io.*; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; import java.util.List; import java.util.Random; @@ -75,7 +76,7 @@ public final void testMain() throws IOException { } } - NoiseDwelling refDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(1, 20, null, -1, DefaultDwellingTypeImpl.MF234, 1, 1, 1000, 1980)); + NoiseDwelling refDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(1, 20, null, -1, DefaultDwellingTypes.DefaultDwellingTypeImpl.MF234, 1, 1, 1000, 1980)); refDwelling.setNoiseImmision(45); Household poor = new HouseholdMuc(1, 1, 2); From c8026bfb06907487b663c169e1921c76d87f20d7 Mon Sep 17 00:00:00 2001 From: Nico Date: Tue, 2 Feb 2021 11:33:37 +0100 Subject: [PATCH 16/24] updates to hedonic pricing model --- .../de/tum/bgu/msm/matsim/MatsimData.java | 10 +- .../bgu/msm/matsim/MatsimTransportModel.java | 1 + .../tum/bgu/msm/matsim/noise/NoiseModel.java | 27 +++-- extensions/pom.xml | 8 +- siloCore/pom.xml | 23 +++-- useCases/munich/pom.xml | 5 + .../msm/data/mito/MitoDataConverterMuc.java | 3 +- .../noise/HedonicPricingModelImpl.java | 10 +- ...NoiseSensitiveDwellingUtilityStrategy.java | 11 --- .../scenarios/noise/ModelBuilderMucNoise.java | 8 +- .../ModelBuilderMucNoiseInsensitive.java | 2 +- .../noise/NKHedonicPricingModelPredictor.java | 19 +++- .../noise/OsmAccessibilityCalculator.java | 99 +++++++++++++++++++ .../msm/transportModel/matsim/SBBTest.java | 18 +--- .../transportModel/matsim/SiloMucTest.java | 5 +- .../transportModel/matsim/SiloNoiseTest.java | 66 +++++++------ 16 files changed, 215 insertions(+), 100 deletions(-) create mode 100644 useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index 8263680da..05f9ed973 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -110,7 +110,7 @@ public void filterNetwork(Network network) { this.ptNetwork = ptNetwork; } - ZoneConnectorManager getZoneConnectorManager() { + public ZoneConnectorManager getZoneConnectorManager() { return zoneConnectorManager; } @@ -130,11 +130,11 @@ public void update(TravelDisutility travelDisutility, TravelTime travelTime) { if (config.transit().isUseTransit() && schedule != null) { RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); - raptorData = SwissRailRaptorData.create(schedule, null, raptorConfig, ptNetwork, null); + raptorData = SwissRailRaptorData.create(schedule, raptorConfig, ptNetwork); RaptorStaticConfig raptorConfigOneToAll = RaptorUtils.createStaticConfig(config); raptorConfigOneToAll.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); - raptorDataOneToAll = SwissRailRaptorData.create(schedule, null, raptorConfigOneToAll, ptNetwork, null); + raptorDataOneToAll = SwissRailRaptorData.create(schedule, raptorConfigOneToAll, ptNetwork); parametersForPerson = new DefaultRaptorParametersForPerson(config); defaultRaptorStopFinder = new DefaultRaptorStopFinder( @@ -187,9 +187,9 @@ TripRouter createTripRouter() { SwissRailRaptor createSwissRailRaptor(RaptorStaticConfig.RaptorOptimization optimitzaion) { switch (optimitzaion) { case OneToAllRouting: - return new SwissRailRaptor(raptorDataOneToAll, parametersForPerson, routeSelector, defaultRaptorStopFinder, null, null); + return new SwissRailRaptor(raptorDataOneToAll, parametersForPerson, routeSelector, defaultRaptorStopFinder); case OneToOneRouting: - return new SwissRailRaptor(raptorData, parametersForPerson, routeSelector, defaultRaptorStopFinder, null, null); + return new SwissRailRaptor(raptorData, parametersForPerson, routeSelector, defaultRaptorStopFinder); default: throw new RuntimeException("Unrecognized raptor optimization!"); } diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java index 8137ab969..381ed7c4f 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java @@ -160,6 +160,7 @@ private void runTransportModel(int year) { assembledScenario = scenarioAssembler.assembleScenario(initialMatsimConfig, year, travelTimes); finalizeConfig(assembledScenario.getConfig(), year); + assembledScenario.getConfig().transit().setUsingTransitInMobsim(false); final Controler controler = new Controler(assembledScenario); diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index c42466529..352b03d44 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -36,6 +36,9 @@ public class NoiseModel extends AbstractModel implements ModelUpdateListener { private static final Logger logger = Logger.getLogger(NoiseModel.class); + + private final Config initialConfig; + private final RealEstateDataManager realEstateDataManager; private final MatsimData matsimData; private int latestMatsimYear = -1; @@ -43,8 +46,9 @@ public class NoiseModel extends AbstractModel implements ModelUpdateListener { private final NoiseReceiverPoints noiseReceiverPoints; - public NoiseModel(DataContainer data, Properties properties, Random random, MatsimData matsimData) { + public NoiseModel(Config initialConfig, DataContainer data, Properties properties, Random random, MatsimData matsimData) { super(data, properties, random); + this.initialConfig = initialConfig; this.realEstateDataManager = data.getRealEstateDataManager(); this.matsimData = matsimData; this.noiseReceiverPoints = new NoiseReceiverPoints(); @@ -140,20 +144,18 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" + properties.main.scenarioName + "/matsim/" + latestMatsimYear + "/"; - String populationPath = outputDirectoryRoot + latestMatsimYear + ".output_plans.xml.gz"; - - Config config = ConfigUtils.createConfig(); + Config config = ConfigUtils.createConfig(initialConfig.getContext()); config.controler().setOutputDirectory(outputDirectoryRoot); config.controler().setRunId(String.valueOf(latestMatsimYear)); final MutableScenario scenario = ScenarioUtils.createMutableScenario(config); - new PopulationReader(scenario).readFile(populationPath); +// new PopulationReader(scenario).readFile(populationPath); scenario.setNetwork(matsimData.getCarNetwork()); scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); - NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); + NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(initialConfig, NoiseConfigGroup.class); noiseParameters.setInternalizeNoiseDamages(false); noiseParameters.setComputeCausingAgents(false); noiseParameters.setComputeNoiseDamages(false); @@ -161,8 +163,11 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); noiseParameters.setThrowNoiseEventsCaused(false); noiseParameters.setThrowNoiseEventsAffected(false); + noiseParameters.setNoiseComputationMethod(NoiseConfigGroup.NoiseComputationMethod.RLS19); noiseParameters.setWriteOutputIteration(0); - noiseParameters.setScaleFactor(10); + noiseParameters.setScaleFactor(1./initialConfig.qsim().getFlowCapFactor()); + config.addModule(noiseParameters); + config.qsim().setEndTime(24 * 60 * 60); noiseParameters.setConsiderNoiseBarriers(true); @@ -212,18 +217,22 @@ private void replayFromEvents(NoiseReceiverPoints noiseReceiverPoints) { scenario.setNetwork(matsimData.getCarNetwork()); scenario.addScenarioElement(NoiseReceiverPoints.NOISE_RECEIVER_POINTS, noiseReceiverPoints); - NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(scenario.getConfig(), NoiseConfigGroup.class); + NoiseConfigGroup noiseParameters = ConfigUtils.addOrGetModule(initialConfig, NoiseConfigGroup.class); noiseParameters.setInternalizeNoiseDamages(false); noiseParameters.setComputeCausingAgents(false); noiseParameters.setComputeNoiseDamages(false); noiseParameters.setComputePopulationUnits(false); noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); noiseParameters.setThrowNoiseEventsCaused(false); + noiseParameters.setNoiseComputationMethod(NoiseConfigGroup.NoiseComputationMethod.RLS19); noiseParameters.setThrowNoiseEventsAffected(false); noiseParameters.setWriteOutputIteration(0); - noiseParameters.setScaleFactor(10); + noiseParameters.setScaleFactor(1./initialConfig.qsim().getFlowCapFactor()); + config.addModule(noiseParameters); + config.qsim().setEndTime(24 * 60 * 60); + noiseParameters.setConsiderNoiseBarriers(true); noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); diff --git a/extensions/pom.xml b/extensions/pom.xml index 7722bdab3..054fcfc8b 100644 --- a/extensions/pom.xml +++ b/extensions/pom.xml @@ -60,9 +60,9 @@ maven-compiler-plugin 3.8.0 - 8 - 1.8 - 1.8 + 11 + 11 + 11 @@ -168,7 +168,7 @@ osgeo Geotools repository - http://download.osgeo.org/webdav/geotools + https://repo.osgeo.org/repository/release/ false diff --git a/siloCore/pom.xml b/siloCore/pom.xml index 29bf0c64f..4d6b7f28f 100644 --- a/siloCore/pom.xml +++ b/siloCore/pom.xml @@ -70,9 +70,9 @@ maven-compiler-plugin 3.8.0 - 8 - 1.8 - 1.8 + 11 + 11 + 11 @@ -227,6 +227,12 @@ org.geotools gt-main ${geotools.version} + + + org.locationtech.jts + jts-core + + org.geotools @@ -242,7 +248,6 @@ org.geotools gt-epsg-hsql ${geotools.version} - runtime org.geotools @@ -252,7 +257,7 @@ org.locationtech.jts jts-core - 1.17.1 + 1.16.0 common-base @@ -339,7 +344,7 @@ com.github.msmobility mito - v28102020 + master javax.media @@ -386,9 +391,9 @@ 21.5 false 13.0-2020w37-SNAPSHOT - + 1.8 - 1.8 - 1.8 + 11 + 11 \ No newline at end of file diff --git a/useCases/munich/pom.xml b/useCases/munich/pom.xml index a8940574b..67fdba70e 100644 --- a/useCases/munich/pom.xml +++ b/useCases/munich/pom.xml @@ -51,5 +51,10 @@ + + + + + \ No newline at end of file diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java index 8b5fd0899..37ec04b04 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/data/mito/MitoDataConverterMuc.java @@ -13,6 +13,7 @@ import de.tum.bgu.msm.data.person.Person; import de.tum.bgu.msm.data.person.PersonMuc; import de.tum.bgu.msm.mito.MitoDataConverter; +import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.schools.DataContainerWithSchoolsImpl; import de.tum.bgu.msm.schools.School; import de.tum.bgu.msm.schools.SchoolImpl; @@ -47,7 +48,7 @@ private void convertZones(DataSet dataSet, DataContainer dataContainer) { private void convertSchools(DataSet dataSet, DataContainer dataContainer) { Map zones = dataSet.getZones(); - for (School school : ((DataContainerWithSchoolsImpl) dataContainer).getSchoolData().getSchools()) { + for (School school : ((DataContainerWithSchools) dataContainer).getSchoolData().getSchools()) { MitoZone zone = zones.get(school.getZoneId()); Coordinate coordinate; if (school instanceof SchoolImpl) { diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java index b7408b0c9..11c84bc41 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HedonicPricingModelImpl.java @@ -20,16 +20,19 @@ public class HedonicPricingModelImpl extends AbstractModel implements PricingMod private final PricingStrategy strategy; private final HedonicPricingModelPredictor hedonicPredictor; + private final OsmAccessibilityCalculator accessibilityCalculator; - public HedonicPricingModelImpl(DataContainer dataContainer, Properties properties, PricingStrategy strategy, Random rnd, HedonicPricingModelPredictor hedonicPredictor) { + public HedonicPricingModelImpl(DataContainer dataContainer, Properties properties, PricingStrategy strategy, Random rnd, HedonicPricingModelPredictor hedonicPredictor, OsmAccessibilityCalculator accessibilityCalculator) { super(dataContainer, properties, rnd); this.strategy = strategy; this.hedonicPredictor = hedonicPredictor; + this.accessibilityCalculator = accessibilityCalculator; } @Override public void setup() { - updateRealEstatePrices(properties.main.baseYear); + accessibilityCalculator.calculateAccessibilities(properties.main.baseYear); + updateRealEstatePrices(properties.main.baseYear); } @Override @@ -56,7 +59,8 @@ private void updateRealEstatePrices(int year) { final Map currentRentByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); for (Dwelling dd : dataContainer.getRealEstateDataManager().getDwellings()) { - dd.setPrice((int) hedonicPredictor.predictPrice(dd)); + final double predictPrice = hedonicPredictor.predictPrice(dd); + dd.setPrice((int) predictPrice); } final Map newRentByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java index 9f432d4cb..82ca2cf70 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/HuntNoiseSensitiveDwellingUtilityStrategy.java @@ -33,9 +33,6 @@ */ public class HuntNoiseSensitiveDwellingUtilityStrategy implements HousingStrategy { - private static final double MEDIUM_NOISE_DISCOUNT = 0.056; - private static final double LOUD_NOISE_DISCOUNT = 0.096; - private static final int LOW_INCOME = 1; private static final int HIGH_INCOME = 2; private static final int AVERAGE_INCOME = 0; @@ -194,14 +191,6 @@ private double calculateUtilityAlternative(Household household, NoiseDwelling ol private double getNoiseAdjustedPrice(NoiseDwelling dwelling) { double price = dwelling.getPrice() / 0.68; - final double noiseImmission = dwelling.getNoiseImmission(); - if (noiseImmission > 55) { - if (noiseImmission > 65) { - price *= (1 - LOUD_NOISE_DISCOUNT); - } else { - price *= (1 - MEDIUM_NOISE_DISCOUNT); - } - } return price; } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java index 93fd05146..c07574367 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoise.java @@ -44,7 +44,6 @@ import de.tum.bgu.msm.models.realEstate.demolition.DemolitionModelImpl; import de.tum.bgu.msm.models.realEstate.pricing.DefaultPricingStrategy; import de.tum.bgu.msm.models.realEstate.pricing.PricingModel; -import de.tum.bgu.msm.models.realEstate.pricing.PricingModelImpl; import de.tum.bgu.msm.models.realEstate.renovation.DefaultRenovationStrategy; import de.tum.bgu.msm.models.realEstate.renovation.RenovationModel; import de.tum.bgu.msm.models.realEstate.renovation.RenovationModelImpl; @@ -148,9 +147,12 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data default: transportModel = null; } - NoiseModel noiseModel = new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom(), transportModel.getMatsimData()); + NoiseModel noiseModel = new NoiseModel(config, dataContainer, properties, SiloUtil.provideNewRandom(), transportModel.getMatsimData()); + PricingModel pricing = new HedonicPricingModelImpl(dataContainer, properties, + new DefaultPricingStrategy(), SiloUtil.getRandomObject(), new NKHedonicPricingModelPredictor(dataContainer.getGeoData()), + new OsmAccessibilityCalculator(config, properties, dataContainer.getGeoData(), matsimData.getZoneConnectorManager())); final ModelContainer modelContainer = new ModelContainer( birthModel, birthdayModel, @@ -158,7 +160,7 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data divorceModel, driversLicenseModel, educationModel, employmentModel, leaveParentsModel, jobMarketUpdateModel, - construction, demolition, null, renovation, + construction, demolition, pricing, renovation, null, inOutMigration, movesModel, transportModel); modelContainer.registerModelUpdateListener(new UpdateCarOwnershipModelMuc(dataContainer, properties, SiloUtil.provideNewRandom())); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java index c7e0a2688..6c1799f25 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/ModelBuilderMucNoiseInsensitive.java @@ -148,7 +148,7 @@ public static ModelContainer getModelContainerForMuc(NoiseDataContainerImpl data default: transportModel = null; } - NoiseModel noiseModel = new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom(), transportModel.getMatsimData()); + NoiseModel noiseModel = new NoiseModel(config, dataContainer, properties, SiloUtil.provideNewRandom(), transportModel.getMatsimData()); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java index 5e6dd45b2..7f7ab7a57 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java @@ -1,10 +1,13 @@ package de.tum.bgu.msm.scenarios.noise; import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.geo.GeoData; import de.tum.bgu.msm.matsim.noise.NoiseDwelling; import java.util.function.Supplier; +import static de.tum.bgu.msm.scenarios.noise.NKHedonicPricingModelState.FIRST_TIME_USE_STATE; + public class NKHedonicPricingModelPredictor implements HedonicPricingModelPredictor { private static double INTERCEPT = 2.2390; @@ -36,12 +39,18 @@ public class NKHedonicPricingModelPredictor implements HedonicPricingModelPredic private final static double INTERCEPT_AREA = 8.1063; private final static double BETA_ROOMS_AREA = 26.0538; + private final GeoData geoData; + + public NKHedonicPricingModelPredictor(GeoData geoData) { + this.geoData = geoData; + } + @Override public double predictPrice(Dwelling dwelling) { double logPrice = INTERCEPT; - logPrice += BETA_LOG_AREA * estimateArea(dwelling); + logPrice += BETA_LOG_AREA * Math.log(estimateArea(dwelling)); final double noiseImmission = ((NoiseDwelling) dwelling).getNoiseImmission(); if(noiseImmission < 55) { @@ -55,7 +64,8 @@ public double predictPrice(Dwelling dwelling) { } try { - logPrice += BETA_ACCESSIBILITY * dwelling.getAttribute("matsim_accessibility").map(o ->(Double) o).orElseThrow((Supplier) RuntimeException::new); + final Object matsim_accessibility = geoData.getZones().get(dwelling.getZoneId()).getAttributes().get("matsim_accessibility"); + logPrice += BETA_ACCESSIBILITY * (Double) matsim_accessibility; } catch (Throwable throwable) { throwable.printStackTrace(); } @@ -68,7 +78,7 @@ public double predictPrice(Dwelling dwelling) { } private double getStateImpact(Dwelling dwelling) { - final NKHedonicPricingModelState state = (NKHedonicPricingModelState) dwelling.getAttribute("state").get(); + final NKHedonicPricingModelState state = (NKHedonicPricingModelState) dwelling.getAttribute("state").orElse(FIRST_TIME_USE_STATE); switch (state) { case FIRST_TIME_USE_STATE: return BETA_FIRST_TIME_USE_STATE; @@ -100,7 +110,6 @@ private double convertQualityToRentCoefficient(int qualityLevel) { } private double estimateArea(Dwelling dwelling) { - double area = INTERCEPT_AREA + BETA_ROOMS_AREA * dwelling.getBedrooms(); - return area; + return INTERCEPT_AREA + BETA_ROOMS_AREA * dwelling.getBedrooms(); } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java new file mode 100644 index 000000000..65df17724 --- /dev/null +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java @@ -0,0 +1,99 @@ +package de.tum.bgu.msm.scenarios.noise; + +import de.tum.bgu.msm.data.Zone; +import de.tum.bgu.msm.data.geo.GeoData; +import de.tum.bgu.msm.matsim.ZoneConnectorManager; +import de.tum.bgu.msm.properties.Properties; +import org.locationtech.jts.geom.Envelope; +import org.locationtech.jts.geom.Geometry; +import org.matsim.api.core.v01.Coord; +import org.matsim.api.core.v01.Id; +import org.matsim.api.core.v01.Scenario; +import org.matsim.contrib.accessibility.AccessibilityConfigGroup; +import org.matsim.contrib.accessibility.AccessibilityModule; +import org.matsim.contrib.accessibility.FacilityDataExchangeInterface; +import org.matsim.contrib.accessibility.Modes4Accessibility; +import org.matsim.core.config.Config; +import org.matsim.core.config.ConfigUtils; +import org.matsim.core.controler.Controler; +import org.matsim.core.controler.OutputDirectoryHierarchy; +import org.matsim.core.scenario.ScenarioUtils; +import org.matsim.facilities.ActivityFacilities; +import org.matsim.facilities.ActivityFacilitiesFactoryImpl; +import org.matsim.facilities.ActivityFacility; +import org.matsim.facilities.FacilitiesUtils; + +public class OsmAccessibilityCalculator implements FacilityDataExchangeInterface { + + private final Config config; + private final Properties properties; + private final GeoData geoData; + + private final Envelope envelope = new Envelope(); + private final ActivityFacilities facilities; + + public OsmAccessibilityCalculator(Config config, Properties properties, + GeoData geoData, ZoneConnectorManager zoneConnectorManager) { + this.config = config; + this.properties = properties; + this.geoData = geoData; + + facilities = FacilitiesUtils.createActivityFacilities(); + + final ActivityFacilitiesFactoryImpl activityFacilitiesFactory = new ActivityFacilitiesFactoryImpl(); + for (Zone value : geoData.getZones().values()) { + envelope.expandToInclude(((Geometry) value.getZoneFeature().getDefaultGeometry()).getEnvelopeInternal()); + final Coord coord = zoneConnectorManager.getCoordsForZone(value.getZoneId()).get(0); + final ActivityFacility activityFacility = activityFacilitiesFactory + .createActivityFacility(Id.create(value.getId(), ActivityFacility.class), coord); + facilities.addActivityFacility(activityFacility); + } + } + + + public void calculateAccessibilities(int year) { + + String opportunitiesFile = "C:/Users/Nico/tum/facilities_amenities.xml"; + + Config config = ConfigUtils.createConfig(this.config.getContext()); + + AccessibilityConfigGroup acg = ConfigUtils.addOrGetModule(config, AccessibilityConfigGroup.class); + acg.setComputingAccessibilityForMode(Modes4Accessibility.car, true); + acg.setUseParallelization(true); + acg.setTileSize_m(100); // Must be set even though meaningless in given-facilities case + + acg.setEnvelope(envelope); + config.controler().setLastIteration(0); + + final String outputDirectoryRoot = properties.main.baseDirectory + "scenOutput/" + properties.main.scenarioName; + String outputDirectory = outputDirectoryRoot + "/matsim/" + year + "/accessibility/"; + config.controler().setOverwriteFileSetting(OutputDirectoryHierarchy.OverwriteFileSetting.deleteDirectoryIfExists); + config.controler().setRunId(String.valueOf(year)); + config.controler().setOutputDirectory(outputDirectory); + config.network().setInputFile(this.config.network().getInputFile()); + config.plansCalcRoute().setRoutingRandomness(0.); + + config.facilities().setInputFile(opportunitiesFile); + acg.setMeasuringPointsFacilities(facilities); + acg.setAreaOfAccessibilityComputation(AccessibilityConfigGroup.AreaOfAccesssibilityComputation.fromFacilitiesObject); + + final Scenario sc = ScenarioUtils.loadScenario(config); + Controler controler = new Controler(sc); + final AccessibilityModule module = new AccessibilityModule(); + module.setConsideredActivityType(null); + module.addFacilityDataExchangeListener(this); + controler.addOverridingModule(module); + controler.run(); + } + + @Override + public void setFacilityAccessibilities(ActivityFacility activityFacility, Double aDouble, String s, double v) { + final int id = Integer.parseInt(activityFacility.getId().toString()); + this.geoData.getZones().get(id).getAttributes().put("matsim_accessibility", v); + } + + @Override + public void finish() { + + } +} diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java index 336127a76..380d3e886 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java @@ -1,37 +1,25 @@ package de.tum.bgu.msm.transportModel.matsim; import ch.sbb.matsim.routing.pt.raptor.*; -import com.google.common.collect.Lists; import org.junit.Ignore; import org.junit.Test; import org.matsim.api.core.v01.Coord; import org.matsim.api.core.v01.Id; import org.matsim.api.core.v01.Scenario; -import org.matsim.api.core.v01.TransportMode; -import org.matsim.api.core.v01.population.Activity; -import org.matsim.api.core.v01.population.Leg; -import org.matsim.api.core.v01.population.PlanElement; import org.matsim.api.core.v01.population.Population; import org.matsim.core.config.Config; import org.matsim.core.config.ConfigUtils; -import org.matsim.core.controler.Controler; -import org.matsim.core.controler.OutputDirectoryHierarchy; import org.matsim.core.network.io.MatsimNetworkReader; import org.matsim.core.population.PopulationUtils; -import org.matsim.core.router.*; -import org.matsim.core.router.util.LeastCostPathCalculator; +import org.matsim.core.router.TripRouter; import org.matsim.core.scenario.ScenarioUtils; import org.matsim.facilities.ActivityFacilitiesFactory; import org.matsim.facilities.ActivityFacilitiesFactoryImpl; import org.matsim.facilities.ActivityFacility; import org.matsim.facilities.Facility; -import org.matsim.pt.PtConstants; import org.matsim.pt.transitSchedule.api.TransitScheduleReader; import org.matsim.pt.transitSchedule.api.TransitStopFacility; -import org.matsim.vehicles.VehicleReaderV1; -import javax.inject.Provider; -import java.util.List; import java.util.Map; public class SBBTest { @@ -97,11 +85,11 @@ public void test() { RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); raptorConfig.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); - SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), null, raptorConfig, scenario.getNetwork(), null); + SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), raptorConfig, scenario.getNetwork()); SwissRailRaptor raptor = new SwissRailRaptor(raptorData, new DefaultRaptorParametersForPerson(config), null, new DefaultRaptorStopFinder( null, new DefaultRaptorIntermodalAccessEgress(), - null), null, null); + null)); // RoutingModule routingModule = // new SwissRailRaptorRoutingModule( diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java index d291c7a60..eace9a5d1 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMucTest.java @@ -3,6 +3,7 @@ import de.tum.bgu.msm.DataBuilder; import de.tum.bgu.msm.ModelBuilderMuc; import de.tum.bgu.msm.SiloModel; +import de.tum.bgu.msm.container.DataContainer; import de.tum.bgu.msm.container.ModelContainer; import de.tum.bgu.msm.io.output.DefaultResultsMonitor; import de.tum.bgu.msm.io.output.ResultsMonitor; @@ -41,10 +42,10 @@ public final void testMain() { String path = "./test/muc/siloMucTest.properties"; Properties properties = SiloUtil.siloInitialization(path); - NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, null); + DataContainerWithSchools dataContainer = DataBuilder.getModelDataForMuc(properties, null); DataBuilder.read(properties, dataContainer); - ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, null); + ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, null); ResultsMonitor resultsMonitor = new DefaultResultsMonitor(dataContainer, properties); SiloModel siloModel = new SiloModel(properties, dataContainer, modelContainer); diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java index a68ca3c8f..2963ffd38 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -1,5 +1,6 @@ package de.tum.bgu.msm.transportModel.matsim; +import de.tum.bgu.msm.SiloModel; import de.tum.bgu.msm.container.ModelContainer; import de.tum.bgu.msm.data.Location; import de.tum.bgu.msm.data.Region; @@ -67,14 +68,15 @@ public final void testMain() throws IOException { NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); DataBuilderNoise.read(properties, dataContainer); ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); + ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); final List modelUpdateListeners = modelContainer.getModelUpdateListeners(); - for(ModelUpdateListener listenr: modelUpdateListeners) { - if(listenr instanceof NoiseModel) { - listenr.endYear(2011); - } - } +// for(ModelUpdateListener listenr: modelUpdateListeners) { +// if(listenr instanceof NoiseModel) { +// listenr.endYear(2011); +// } +// } NoiseDwelling refDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(1, 20, null, -1, DefaultDwellingTypes.DefaultDwellingTypeImpl.MF234, 1, 1, 1000, 1980)); refDwelling.setNoiseImmision(45); @@ -128,32 +130,32 @@ public TravelTimes duplicate() { Random random = new Random(42); - dataContainer.getRealEstateDataManager().addDwelling(refDwelling); - for(Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { - ((NoiseDwelling)dwelling).setNoiseImmision(((NoiseDwelling) dwelling).getNoiseImmission()+random.nextInt(25)); - if(dwelling == refDwelling) { - continue; - } - dwelling.setPrice(1000); - - final double v = strategy.calculateHousingUtility(poor, dwelling); - final double v2 = strategy.calculateHousingUtility(avg, dwelling); - final double v3 = strategy.calculateHousingUtility(rich, dwelling); - - final double v4 = strategyIns.calculateHousingUtility(poor, dwelling); - final double v5 = strategyIns.calculateHousingUtility(avg, dwelling); - final double v6 = strategyIns.calculateHousingUtility(rich, dwelling); - writer.write(((NoiseDwelling)dwelling).getNoiseImmission()+","+dwelling.getPrice() - +","+dwelling.getType()+","+v+","+v2+","+v3+","+v4+","+v5+","+v6); - writer.newLine(); - } - writer.flush(); - writer.close(); - - - -// SiloModel model = new SiloModel(properties, dataContainer, modelContainer); -// model.addResultMonitor(resultsMonitor); -// model.runModel(); +// dataContainer.getRealEstateDataManager().addDwelling(refDwelling); +// for(Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { +// ((NoiseDwelling)dwelling).setNoiseImmision(((NoiseDwelling) dwelling).getNoiseImmission()+random.nextInt(25)); +// if(dwelling == refDwelling) { +// continue; +// } +// dwelling.setPrice(1000); +// +// final double v = strategy.calculateHousingUtility(poor, dwelling); +// final double v2 = strategy.calculateHousingUtility(avg, dwelling); +// final double v3 = strategy.calculateHousingUtility(rich, dwelling); +// +// final double v4 = strategyIns.calculateHousingUtility(poor, dwelling); +// final double v5 = strategyIns.calculateHousingUtility(avg, dwelling); +// final double v6 = strategyIns.calculateHousingUtility(rich, dwelling); +// writer.write(((NoiseDwelling)dwelling).getNoiseImmission()+","+dwelling.getPrice() +// +","+dwelling.getType()+","+v+","+v2+","+v3+","+v4+","+v5+","+v6); +// writer.newLine(); +// } +// writer.flush(); +// writer.close(); + + + + SiloModel model = new SiloModel(properties, dataContainer, modelContainer); + model.addResultMonitor(resultsMonitor); + model.runModel(); } } From 08659550bf76a2ff38a2130cf9632286c01283db Mon Sep 17 00:00:00 2001 From: Nico Date: Wed, 10 Feb 2021 13:35:39 +0100 Subject: [PATCH 17/24] noise updates --- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 2 + .../noise/OsmAccessibilityCalculator.java | 10 +++ .../transportModel/matsim/SiloNoiseTest.java | 72 ++++++++++--------- 3 files changed, 52 insertions(+), 32 deletions(-) diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 352b03d44..3e8177467 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -163,6 +163,7 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); noiseParameters.setThrowNoiseEventsCaused(false); noiseParameters.setThrowNoiseEventsAffected(false); + noiseParameters.setConsiderNoiseBarriers(true); noiseParameters.setNoiseComputationMethod(NoiseConfigGroup.NoiseComputationMethod.RLS19); noiseParameters.setWriteOutputIteration(0); noiseParameters.setScaleFactor(1./initialConfig.qsim().getFlowCapFactor()); @@ -224,6 +225,7 @@ private void replayFromEvents(NoiseReceiverPoints noiseReceiverPoints) { noiseParameters.setComputePopulationUnits(false); noiseParameters.setComputeAvgNoiseCostPerLinkAndTime(false); noiseParameters.setThrowNoiseEventsCaused(false); + noiseParameters.setConsiderNoiseBarriers(true); noiseParameters.setNoiseComputationMethod(NoiseConfigGroup.NoiseComputationMethod.RLS19); noiseParameters.setThrowNoiseEventsAffected(false); noiseParameters.setWriteOutputIteration(0); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java index 65df17724..bb64fc860 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/OsmAccessibilityCalculator.java @@ -28,6 +28,7 @@ public class OsmAccessibilityCalculator implements FacilityDataExchangeInterface private final Config config; private final Properties properties; private final GeoData geoData; + private final ZoneConnectorManager zoneConnectorManager; private final Envelope envelope = new Envelope(); private final ActivityFacilities facilities; @@ -37,6 +38,7 @@ public OsmAccessibilityCalculator(Config config, Properties properties, this.config = config; this.properties = properties; this.geoData = geoData; + this.zoneConnectorManager = zoneConnectorManager; facilities = FacilitiesUtils.createActivityFacilities(); @@ -48,17 +50,25 @@ public OsmAccessibilityCalculator(Config config, Properties properties, .createActivityFacility(Id.create(value.getId(), ActivityFacility.class), coord); facilities.addActivityFacility(activityFacility); } + } public void calculateAccessibilities(int year) { + + if (properties.main.baseYear != year && !(properties.transportModel.transportModelYears.contains(year + 1))) { + return; + } + + String opportunitiesFile = "C:/Users/Nico/tum/facilities_amenities.xml"; Config config = ConfigUtils.createConfig(this.config.getContext()); AccessibilityConfigGroup acg = ConfigUtils.addOrGetModule(config, AccessibilityConfigGroup.class); acg.setComputingAccessibilityForMode(Modes4Accessibility.car, true); + acg.setComputingAccessibilityForMode(Modes4Accessibility.freespeed, false); acg.setUseParallelization(true); acg.setTileSize_m(100); // Must be set even though meaningless in given-facilities case diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java index 2963ffd38..d0a91154a 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -72,11 +72,11 @@ public final void testMain() throws IOException { ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); final List modelUpdateListeners = modelContainer.getModelUpdateListeners(); -// for(ModelUpdateListener listenr: modelUpdateListeners) { -// if(listenr instanceof NoiseModel) { -// listenr.endYear(2011); -// } -// } + for(ModelUpdateListener listenr: modelUpdateListeners) { + if(listenr instanceof NoiseModel) { + listenr.endYear(2011); + } + } NoiseDwelling refDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(1, 20, null, -1, DefaultDwellingTypes.DefaultDwellingTypeImpl.MF234, 1, 1, 1000, 1980)); refDwelling.setNoiseImmision(45); @@ -130,32 +130,40 @@ public TravelTimes duplicate() { Random random = new Random(42); -// dataContainer.getRealEstateDataManager().addDwelling(refDwelling); -// for(Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { -// ((NoiseDwelling)dwelling).setNoiseImmision(((NoiseDwelling) dwelling).getNoiseImmission()+random.nextInt(25)); -// if(dwelling == refDwelling) { -// continue; -// } -// dwelling.setPrice(1000); -// -// final double v = strategy.calculateHousingUtility(poor, dwelling); -// final double v2 = strategy.calculateHousingUtility(avg, dwelling); -// final double v3 = strategy.calculateHousingUtility(rich, dwelling); -// -// final double v4 = strategyIns.calculateHousingUtility(poor, dwelling); -// final double v5 = strategyIns.calculateHousingUtility(avg, dwelling); -// final double v6 = strategyIns.calculateHousingUtility(rich, dwelling); -// writer.write(((NoiseDwelling)dwelling).getNoiseImmission()+","+dwelling.getPrice() -// +","+dwelling.getType()+","+v+","+v2+","+v3+","+v4+","+v5+","+v6); -// writer.newLine(); -// } -// writer.flush(); -// writer.close(); - - - - SiloModel model = new SiloModel(properties, dataContainer, modelContainer); - model.addResultMonitor(resultsMonitor); - model.runModel(); + dataContainer.getRealEstateDataManager().addDwelling(refDwelling); + for(Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { + ((NoiseDwelling)dwelling).setNoiseImmision(((NoiseDwelling) dwelling).getNoiseImmission()+random.nextInt(25)); + if(dwelling == refDwelling) { + continue; + } + double price = 1000; + if(((NoiseDwelling) dwelling).getNoiseImmission() > 75) { + price = price * (1 -0.1005); + } else if(((NoiseDwelling) dwelling).getNoiseImmission() > 65) { + price = price * (1 -0.0583); + } else if(((NoiseDwelling) dwelling).getNoiseImmission() > 55) { + price = price * (1 -0.0360); + } + dwelling.setPrice((int) price); + + final double v = strategy.calculateHousingUtility(poor, dwelling); + final double v2 = strategy.calculateHousingUtility(avg, dwelling); + final double v3 = strategy.calculateHousingUtility(rich, dwelling); + + final double v4 = strategyIns.calculateHousingUtility(poor, dwelling); + final double v5 = strategyIns.calculateHousingUtility(avg, dwelling); + final double v6 = strategyIns.calculateHousingUtility(rich, dwelling); + writer.write(((NoiseDwelling)dwelling).getNoiseImmission()+","+dwelling.getPrice() + +","+dwelling.getType()+","+v+","+v2+","+v3+","+v4+","+v5+","+v6); + writer.newLine(); + } + writer.flush(); + writer.close(); + + + +// SiloModel model = new SiloModel(properties, dataContainer, modelContainer); +// model.addResultMonitor(resultsMonitor); +// model.runModel(); } } From 0d37e9970a0d883c4659bb97beabddc2f5f09dc1 Mon Sep 17 00:00:00 2001 From: Nico Date: Mon, 26 Jul 2021 10:17:06 +0200 Subject: [PATCH 18/24] noise feedback --- .../tum/bgu/msm/matsim/noise/NoiseModel.java | 2 +- .../noise/NKHedonicPricingModelPredictor.java | 4 +- .../scenarios/noise/NoiseDwellingFactory.java | 44 ++++++++++++++++--- .../msm/scenarios/noise/NoiseDwellingIml.java | 4 +- 4 files changed, 43 insertions(+), 11 deletions(-) diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java index 3e8177467..6ccd83db5 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/noise/NoiseModel.java @@ -172,7 +172,7 @@ private void calculateNoiseOffline(NoiseReceiverPoints noiseReceiverPoints) { config.qsim().setEndTime(24 * 60 * 60); noiseParameters.setConsiderNoiseBarriers(true); - noiseParameters.setNoiseBarriersFilePath("C:\\Users\\Nico\\tum\\diss\\noise\\aggBuildingPoly.geojson"); + noiseParameters.setNoiseBarriersFilePath("D:\\resultStorage\\diss\\noise\\aggBuildingPoly.geojson"); noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468"); config.global().setCoordinateSystem("EPSG:31468"); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java index 7f7ab7a57..eb881b0f8 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NKHedonicPricingModelPredictor.java @@ -64,8 +64,8 @@ public double predictPrice(Dwelling dwelling) { } try { - final Object matsim_accessibility = geoData.getZones().get(dwelling.getZoneId()).getAttributes().get("matsim_accessibility"); - logPrice += BETA_ACCESSIBILITY * (Double) matsim_accessibility; + final Object matsim_accessibility = geoData.getZones().get(dwelling.getZoneId()).getAttributes().get("matsim_accessibility"); + logPrice += BETA_ACCESSIBILITY * (Double) matsim_accessibility; } catch (Throwable throwable) { throwable.printStackTrace(); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java index 8020b86dc..4f7f7def9 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java @@ -1,22 +1,54 @@ package de.tum.bgu.msm.scenarios.noise; -import de.tum.bgu.msm.data.dwelling.Dwelling; -import de.tum.bgu.msm.data.dwelling.DwellingFactory; -import de.tum.bgu.msm.data.dwelling.DwellingImpl; -import de.tum.bgu.msm.data.dwelling.DwellingType; +import de.tum.bgu.msm.SampleGenerator; +import de.tum.bgu.msm.data.dwelling.*; +import de.tum.bgu.msm.utils.SampleException; +import de.tum.bgu.msm.utils.Sampler; import org.locationtech.jts.geom.Coordinate; +import java.util.Random; + public class NoiseDwellingFactory implements DwellingFactory { + private final Random random; private DwellingFactory delegate; + private final Sampler stateSampler; public NoiseDwellingFactory(DwellingFactory delegate) { this.delegate = delegate; - } + this.random = new Random(42); + stateSampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + stateSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0.138); + stateSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 0.08); + stateSampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 0.291); + stateSampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 0.054); + stateSampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 0.243); + stateSampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 0.165); + stateSampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 0.027); + } @Override public Dwelling createDwelling(int id, int zoneId, Coordinate coordinate, int hhId, DwellingType type, int bedrooms, int quality, int price, int year) { - return new NoiseDwellingIml(delegate.createDwelling(id, zoneId, coordinate, hhId, type, bedrooms, quality, price, year)); + final NoiseDwellingIml noiseDwellingIml = new NoiseDwellingIml(delegate.createDwelling(id, zoneId, coordinate, hhId, type, bedrooms, quality, price, year)); + if(type == DefaultDwellingTypes.DefaultDwellingTypeImpl.MF5plus) { + if(random.nextDouble() < 0.8) { + noiseDwellingIml.setAttribute("parking_available", 1); + } else { + noiseDwellingIml.setAttribute("parking_available", 0); + } + } else { + noiseDwellingIml.setAttribute("parking_available", 1); + } + + try { + final NKHedonicPricingModelState state = stateSampler.sampleObject(); + noiseDwellingIml.setAttribute("state", state); + } catch (SampleException e) { + e.printStackTrace(); + } + + return noiseDwellingIml; } } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java index 7f1d4ce5e..569b62c7f 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingIml.java @@ -104,12 +104,12 @@ public DwellingUsage getUsage() { @Override public Optional getAttribute(String key) { - return Optional.empty(); + return delegate.getAttribute(key); } @Override public void setAttribute(String key, Object value) { - + delegate.setAttribute(key, value); } @Override From 80b7e799a1fbb7bb8a934fe7c909e9a05808fd50 Mon Sep 17 00:00:00 2001 From: Nico Date: Tue, 24 Aug 2021 17:07:37 +0200 Subject: [PATCH 19/24] updates noise feedback --- siloCore/pom.xml | 2 +- .../scenarios/noise/NoiseDwellingFactory.java | 196 ++++++++++++++++-- 2 files changed, 185 insertions(+), 13 deletions(-) diff --git a/siloCore/pom.xml b/siloCore/pom.xml index 4d6b7f28f..ff38006e5 100644 --- a/siloCore/pom.xml +++ b/siloCore/pom.xml @@ -342,7 +342,7 @@ 2.6 - com.github.msmobility + de.tum.bgu.msm mito master diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java index 4f7f7def9..4337614d9 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/NoiseDwellingFactory.java @@ -1,32 +1,177 @@ package de.tum.bgu.msm.scenarios.noise; -import de.tum.bgu.msm.SampleGenerator; -import de.tum.bgu.msm.data.dwelling.*; +import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypes; +import de.tum.bgu.msm.data.dwelling.Dwelling; +import de.tum.bgu.msm.data.dwelling.DwellingFactory; +import de.tum.bgu.msm.data.dwelling.DwellingType; import de.tum.bgu.msm.utils.SampleException; import de.tum.bgu.msm.utils.Sampler; import org.locationtech.jts.geom.Coordinate; +import java.util.LinkedHashMap; +import java.util.Map; import java.util.Random; public class NoiseDwellingFactory implements DwellingFactory { + private enum AgeCategory { + LESS_THAN_TWO, + TWO_TO_FIVE, + FIVE_TO_TEN, + TEN_TO_FIFTEEN, + FIFTEEN_TO_TWENTY, + TWENTY_TO_THIRTY, + THIRTY_TO_FORTY, + FORTY_TO_FIFTY, + FIFTY_TO_SIXTY, + SIXTY_TO_SEVENTY, + GREATER_THAN_SEVENTY + } + + private final static Map> probabilityByStateByAgeGroup = new LinkedHashMap<>(); + private final Random random; private DwellingFactory delegate; - private final Sampler stateSampler; public NoiseDwellingFactory(DwellingFactory delegate) { this.delegate = delegate; this.random = new Random(42); - stateSampler = new Sampler<>(NKHedonicPricingModelState.values().length, + initializeStateProbabilities(); + + } + + private void initializeStateProbabilities() { + + Sampler lessThanTwoSampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + lessThanTwoSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 350); + lessThanTwoSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 1); + lessThanTwoSampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 1); + lessThanTwoSampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 0); + lessThanTwoSampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 40); + lessThanTwoSampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 0); + lessThanTwoSampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 0); + probabilityByStateByAgeGroup.put(AgeCategory.LESS_THAN_TWO, lessThanTwoSampler); + + Sampler twoToFiveSampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + twoToFiveSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 26); + twoToFiveSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 1); + twoToFiveSampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 5); + twoToFiveSampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 0); + twoToFiveSampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 126); + twoToFiveSampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 0); + twoToFiveSampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 1); + probabilityByStateByAgeGroup.put(AgeCategory.TWO_TO_FIVE, twoToFiveSampler); + + + Sampler fiveToTenSampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + fiveToTenSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 2); + fiveToTenSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 1); + fiveToTenSampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 32); + fiveToTenSampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 0); + fiveToTenSampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 356); + fiveToTenSampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 5); + fiveToTenSampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 2); + probabilityByStateByAgeGroup.put(AgeCategory.FIVE_TO_TEN, fiveToTenSampler); + + + Sampler tenToFifteenSampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + tenToFifteenSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + tenToFifteenSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 0); + tenToFifteenSampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 26); + tenToFifteenSampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 2); + tenToFifteenSampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 38); + tenToFifteenSampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 5); + tenToFifteenSampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 1); + probabilityByStateByAgeGroup.put(AgeCategory.TEN_TO_FIFTEEN, tenToFifteenSampler); + + + Sampler fifteenToTwentySampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + fifteenToTwentySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + fifteenToTwentySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 1); + fifteenToTwentySampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 39); + fifteenToTwentySampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 0); + fifteenToTwentySampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 24); + fifteenToTwentySampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 7); + fifteenToTwentySampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 2); + probabilityByStateByAgeGroup.put(AgeCategory.FIFTEEN_TO_TWENTY, fifteenToTwentySampler); + + + Sampler twentyToThirtySampler = new Sampler<>(NKHedonicPricingModelState.values().length, NKHedonicPricingModelState.class, new Random(42)); - stateSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0.138); - stateSampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 0.08); - stateSampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 0.291); - stateSampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 0.054); - stateSampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 0.243); - stateSampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 0.165); - stateSampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 0.027); + twentyToThirtySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + twentyToThirtySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 11); + twentyToThirtySampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 136); + twentyToThirtySampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 12); + twentyToThirtySampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 19); + twentyToThirtySampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 43); + twentyToThirtySampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 2); + probabilityByStateByAgeGroup.put(AgeCategory.TWENTY_TO_THIRTY, twentyToThirtySampler); + + + Sampler thirtyToFortySampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + thirtyToFortySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + thirtyToFortySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 20); + thirtyToFortySampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 108); + thirtyToFortySampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 20); + thirtyToFortySampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 9); + thirtyToFortySampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 28); + thirtyToFortySampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 8); + probabilityByStateByAgeGroup.put(AgeCategory.THIRTY_TO_FORTY, thirtyToFortySampler); + + + Sampler fortyToFiftySampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + fortyToFiftySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + fortyToFiftySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 35); + fortyToFiftySampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 132); + fortyToFiftySampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 40); + fortyToFiftySampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 33); + fortyToFiftySampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 88); + fortyToFiftySampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 13); + probabilityByStateByAgeGroup.put(AgeCategory.FORTY_TO_FIFTY, fortyToFiftySampler); + + + Sampler fiftyToSixtySampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + fiftyToSixtySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + fiftyToSixtySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 50); + fiftyToSixtySampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 175); + fiftyToSixtySampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 28); + fiftyToSixtySampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 42); + fiftyToSixtySampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 136); + fiftyToSixtySampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 28); + probabilityByStateByAgeGroup.put(AgeCategory.FIFTY_TO_SIXTY, fortyToFiftySampler); + + + Sampler sixtyToSeventySampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + sixtyToSeventySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + sixtyToSeventySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 56); + sixtyToSeventySampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 121); + sixtyToSeventySampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 26); + sixtyToSeventySampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 29); + sixtyToSeventySampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 98); + sixtyToSeventySampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 11); + probabilityByStateByAgeGroup.put(AgeCategory.SIXTY_TO_SEVENTY, sixtyToSeventySampler); + + + Sampler greaterThanSeventySampler = new Sampler<>(NKHedonicPricingModelState.values().length, + NKHedonicPricingModelState.class, new Random(42)); + greaterThanSeventySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_STATE, 0); + greaterThanSeventySampler.incrementalAdd(NKHedonicPricingModelState.FIRST_TIME_USE_AFTER_RESTORATION_STATE, 78); + greaterThanSeventySampler.incrementalAdd(NKHedonicPricingModelState.WELL_KEPT_STATE, 140); + greaterThanSeventySampler.incrementalAdd(NKHedonicPricingModelState.MODERNIZED_STATE, 43); + greaterThanSeventySampler.incrementalAdd(NKHedonicPricingModelState.NEW_BUILDING_STATE, 0); + greaterThanSeventySampler.incrementalAdd(NKHedonicPricingModelState.RENOVATED_STATE, 107); + greaterThanSeventySampler.incrementalAdd(NKHedonicPricingModelState.RESTORED_STATE, 17); + probabilityByStateByAgeGroup.put(AgeCategory.GREATER_THAN_SEVENTY, greaterThanSeventySampler); } @Override @@ -43,7 +188,34 @@ public Dwelling createDwelling(int id, int zoneId, Coordinate coordinate, int hh } try { - final NKHedonicPricingModelState state = stateSampler.sampleObject(); + + Sampler sampler = null; + int age = 2011 - year; + if(age<2) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.LESS_THAN_TWO); + } else if(age < 5) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.TWO_TO_FIVE); + } else if(age < 10) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.FIVE_TO_TEN); + } else if(age < 15) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.TEN_TO_FIFTEEN); + } else if(age < 20) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.FIFTEEN_TO_TWENTY); + } else if(age < 30) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.TWENTY_TO_THIRTY); + } else if(age < 40) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.THIRTY_TO_FORTY); + } else if(age < 50) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.FORTY_TO_FIFTY); + } else if(age<60) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.FIFTY_TO_SIXTY); + } else if( age < 70) { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.SIXTY_TO_SEVENTY); + } else { + sampler = probabilityByStateByAgeGroup.get(AgeCategory.GREATER_THAN_SEVENTY); + } + + final NKHedonicPricingModelState state = sampler.sampleObject(); noiseDwellingIml.setAttribute("state", state); } catch (SampleException e) { e.printStackTrace(); From 8edd908cfbefe012ae4a8b5f1a60b9cc684f160c Mon Sep 17 00:00:00 2001 From: Nico Date: Tue, 31 Aug 2021 12:21:22 +0200 Subject: [PATCH 20/24] noise feedback updates --- pom.xml | 5 +++++ .../java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java | 6 ++---- .../bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java | 4 ++-- .../de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java | 5 ++--- 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/pom.xml b/pom.xml index 66e757725..37bab73a0 100644 --- a/pom.xml +++ b/pom.xml @@ -45,6 +45,11 @@ always + + + matsim + https://repo.matsim.org/repository/matsim + oss-jfrog-artifactory artifactory-snapshots diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java index 694604cd2..286f3186e 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoise.java @@ -1,12 +1,10 @@ package de.tum.bgu.msm.scenarios.noise; -import de.tum.bgu.msm.ModelBuilderMuc; import de.tum.bgu.msm.SiloModel; import de.tum.bgu.msm.SiloMuc; import de.tum.bgu.msm.container.ModelContainer; -import de.tum.bgu.msm.io.ResultsMonitorMuc; +import de.tum.bgu.msm.io.MultiFileResultsMonitorMuc; import de.tum.bgu.msm.io.output.ResultsMonitor; -import de.tum.bgu.msm.matsim.noise.NoiseModel; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.utils.SiloUtil; import org.apache.log4j.Logger; @@ -30,7 +28,7 @@ public static void main(String[] args) { DataBuilderNoise.read(properties, dataContainer); ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); // modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); - ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); + ResultsMonitor resultsMonitor = new MultiFileResultsMonitorMuc(dataContainer, properties); SiloModel model = new SiloModel(properties, dataContainer, modelContainer); model.addResultMonitor(resultsMonitor); model.runModel(); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java index 16a9fc80d..d79dac311 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/noise/SiloMucNoiseInsensitive.java @@ -3,7 +3,7 @@ import de.tum.bgu.msm.SiloModel; import de.tum.bgu.msm.SiloMuc; import de.tum.bgu.msm.container.ModelContainer; -import de.tum.bgu.msm.io.ResultsMonitorMuc; +import de.tum.bgu.msm.io.MultiFileResultsMonitorMuc; import de.tum.bgu.msm.io.output.ResultsMonitor; import de.tum.bgu.msm.properties.Properties; import de.tum.bgu.msm.utils.SiloUtil; @@ -28,7 +28,7 @@ public static void main(String[] args) { DataBuilderNoise.read(properties, dataContainer); ModelContainer modelContainer = ModelBuilderMucNoiseInsensitive.getModelContainerForMuc(dataContainer, properties, config); // modelContainer.registerModelUpdateListener(new NoiseModel(dataContainer, properties, SiloUtil.provideNewRandom())); - ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); + ResultsMonitor resultsMonitor = new MultiFileResultsMonitorMuc(dataContainer, properties); SiloModel model = new SiloModel(properties, dataContainer, modelContainer); model.addResultMonitor(resultsMonitor); model.runModel(); diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java index d0a91154a..05b095f35 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java @@ -1,6 +1,5 @@ package de.tum.bgu.msm.transportModel.matsim; -import de.tum.bgu.msm.SiloModel; import de.tum.bgu.msm.container.ModelContainer; import de.tum.bgu.msm.data.Location; import de.tum.bgu.msm.data.Region; @@ -15,7 +14,7 @@ import de.tum.bgu.msm.data.person.PersonMuc; import de.tum.bgu.msm.data.person.PersonRole; import de.tum.bgu.msm.data.travelTimes.TravelTimes; -import de.tum.bgu.msm.io.ResultsMonitorMuc; +import de.tum.bgu.msm.io.MultiFileResultsMonitorMuc; import de.tum.bgu.msm.io.output.ResultsMonitor; import de.tum.bgu.msm.matsim.noise.NoiseDwelling; import de.tum.bgu.msm.matsim.noise.NoiseModel; @@ -69,7 +68,7 @@ public final void testMain() throws IOException { DataBuilderNoise.read(properties, dataContainer); ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); - ResultsMonitor resultsMonitor = new ResultsMonitorMuc(dataContainer, properties); + ResultsMonitor resultsMonitor = new MultiFileResultsMonitorMuc(dataContainer, properties); final List modelUpdateListeners = modelContainer.getModelUpdateListeners(); for(ModelUpdateListener listenr: modelUpdateListeners) { From 5e435c8d06e8648d18d225e90ae66cdb93650195 Mon Sep 17 00:00:00 2001 From: nkuehnel Date: Tue, 31 Aug 2021 13:25:12 +0200 Subject: [PATCH 21/24] matsim release 13.0 --- .../de/tum/bgu/msm/matsim/MatsimData.java | 8 +- .../bgu/msm/matsim/MatsimTransportModel.java | 2 +- pom.xml | 2 +- .../msm/transportModel/matsim/SBBTest.java | 136 ------------------ 4 files changed, 6 insertions(+), 142 deletions(-) delete mode 100644 useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index 05f9ed973..676365567 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -130,11 +130,11 @@ public void update(TravelDisutility travelDisutility, TravelTime travelTime) { if (config.transit().isUseTransit() && schedule != null) { RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); - raptorData = SwissRailRaptorData.create(schedule, raptorConfig, ptNetwork); + raptorData = SwissRailRaptorData.create(schedule, null, raptorConfig, ptNetwork, new OccupancyData()); RaptorStaticConfig raptorConfigOneToAll = RaptorUtils.createStaticConfig(config); raptorConfigOneToAll.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); - raptorDataOneToAll = SwissRailRaptorData.create(schedule, raptorConfigOneToAll, ptNetwork); + raptorDataOneToAll = SwissRailRaptorData.create(schedule, null, raptorConfigOneToAll, ptNetwork, new OccupancyData()); parametersForPerson = new DefaultRaptorParametersForPerson(config); defaultRaptorStopFinder = new DefaultRaptorStopFinder( @@ -187,9 +187,9 @@ TripRouter createTripRouter() { SwissRailRaptor createSwissRailRaptor(RaptorStaticConfig.RaptorOptimization optimitzaion) { switch (optimitzaion) { case OneToAllRouting: - return new SwissRailRaptor(raptorDataOneToAll, parametersForPerson, routeSelector, defaultRaptorStopFinder); + return new SwissRailRaptor(raptorDataOneToAll, parametersForPerson, routeSelector, defaultRaptorStopFinder, new DefaultRaptorInVehicleCostCalculator(), new DefaultRaptorTransferCostCalculator()); case OneToOneRouting: - return new SwissRailRaptor(raptorData, parametersForPerson, routeSelector, defaultRaptorStopFinder); + return new SwissRailRaptor(raptorData, parametersForPerson, routeSelector, defaultRaptorStopFinder, new DefaultRaptorInVehicleCostCalculator(), new DefaultRaptorTransferCostCalculator()); default: throw new RuntimeException("Unrecognized raptor optimization!"); } diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java index 381ed7c4f..dbbc8630b 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimTransportModel.java @@ -191,7 +191,7 @@ private void finalizeConfig(Config config, int year) { private void replayFromEvents(String eventsFile) { logger.warn("Setting up MATSim with initial events file: " + eventsFile); Scenario scenario = ScenarioUtils.loadScenario(initialMatsimConfig); - TravelTime travelTime = TravelTimeUtils.createTravelTimesFromEvents(scenario, eventsFile); + TravelTime travelTime = TravelTimeUtils.createTravelTimesFromEvents(scenario.getNetwork(), initialMatsimConfig, eventsFile); TravelDisutility travelDisutility = ControlerDefaults.createDefaultTravelDisutilityFactory(scenario).createTravelDisutility(travelTime); updateTravelTimes(travelTime, travelDisutility); } diff --git a/pom.xml b/pom.xml index 37bab73a0..6f9e7694e 100644 --- a/pom.xml +++ b/pom.xml @@ -142,7 +142,7 @@ 21.5 - 13.0-2020w37-SNAPSHOT + 13.0 2.9.5 \ No newline at end of file diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java deleted file mode 100644 index 380d3e886..000000000 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SBBTest.java +++ /dev/null @@ -1,136 +0,0 @@ -package de.tum.bgu.msm.transportModel.matsim; - -import ch.sbb.matsim.routing.pt.raptor.*; -import org.junit.Ignore; -import org.junit.Test; -import org.matsim.api.core.v01.Coord; -import org.matsim.api.core.v01.Id; -import org.matsim.api.core.v01.Scenario; -import org.matsim.api.core.v01.population.Population; -import org.matsim.core.config.Config; -import org.matsim.core.config.ConfigUtils; -import org.matsim.core.network.io.MatsimNetworkReader; -import org.matsim.core.population.PopulationUtils; -import org.matsim.core.router.TripRouter; -import org.matsim.core.scenario.ScenarioUtils; -import org.matsim.facilities.ActivityFacilitiesFactory; -import org.matsim.facilities.ActivityFacilitiesFactoryImpl; -import org.matsim.facilities.ActivityFacility; -import org.matsim.facilities.Facility; -import org.matsim.pt.transitSchedule.api.TransitScheduleReader; -import org.matsim.pt.transitSchedule.api.TransitStopFacility; - -import java.util.Map; - -public class SBBTest { - - @Ignore - @Test - public void test() { - Config config = ConfigUtils.createConfig(); - - Scenario scenario = ScenarioUtils.createScenario(config); - - new MatsimNetworkReader(scenario.getNetwork()).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\network2018.xml"); - new TransitScheduleReader(scenario).readFile("C:\\Users\\Nico\\tum\\fabilut\\transitInput\\schedule2018.xml"); - -// Provider provider = () -> -// new DefaultRaptorStopFinder( -// null, -// new DefaultRaptorIntermodalAccessEgress(), -// null); -// -// Population pop = PopulationUtils.createPopulation(config); -// final SwissRailRaptorFactory swissRailRaptorFactory = new SwissRailRaptorFactory( -// scenario.getTransitSchedule(), -// config, -// scenario.getNetwork(), -// new DefaultRaptorParametersForPerson(config), -// new LeastCostRaptorRouteSelector(), -// provider, -// config.plans(), -// pop, -// null -// ); -// -// TripRouter.Builder bd = new TripRouter.Builder(ConfigUtils.createConfig()); -// TeleportationRoutingModule teleportationRoutingModule = -// new TeleportationRoutingModule( -// TransportMode.transit_walk, -// PopulationUtils.getFactory(), -// 1.4, -// 1.3); -// RoutingModule routingModule = -// new SwissRailRaptorRoutingModule( -// swissRailRaptorFactory.get(), -// scenario.getTransitSchedule(), -// scenario.getNetwork(), -// teleportationRoutingModule); -// bd.setRoutingModule(TransportMode.pt, routingModule); -// - - Population population = PopulationUtils.createPopulation(config); - TripRouter.Builder bd = new TripRouter.Builder(config); - -// TeleportationRoutingModule teleportationRoutingModule = new TeleportationRoutingModule(TransportMode.pt, PopulationUtils.getFactory(), 10, 1.3); -// bd.setRoutingModule(TransportMode.pt, teleportationRoutingModule); - - -// TeleportationRoutingModule teleportationRoutingModule = -// new TeleportationRoutingModule( -// TransportMode.transit_walk, -// PopulationUtils.getFactory(), -// 1.4, -// 1.3); - - RaptorStaticConfig raptorConfig = RaptorUtils.createStaticConfig(config); - raptorConfig.setOptimization(RaptorStaticConfig.RaptorOptimization.OneToAllRouting); - SwissRailRaptorData raptorData = SwissRailRaptorData.create(scenario.getTransitSchedule(), raptorConfig, scenario.getNetwork()); - SwissRailRaptor raptor = new SwissRailRaptor(raptorData, new DefaultRaptorParametersForPerson(config), null, new DefaultRaptorStopFinder( - null, - new DefaultRaptorIntermodalAccessEgress(), - null)); - -// RoutingModule routingModule = -// new SwissRailRaptorRoutingModule( -// raptor, -// scenario.getTransitSchedule(), -// scenario.getNetwork(), -// teleportationRoutingModule); -// bd.setRoutingModule(TransportMode.pt, routingModule); - - - final Coord originCoord = new Coord(4436689.657372447, 5368527.815536651); - ActivityFacilitiesFactoryImpl activityFacilitiesFactory = new ActivityFacilitiesFactoryImpl(); - Facility fromFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(1, ActivityFacility.class), originCoord); - - long time = System.currentTimeMillis(); - final Map, SwissRailRaptorCore.TravelInfo> idTravelInfoMap = raptor.calcTree(fromFacility, 28800, null); - - System.out.println(System.currentTimeMillis() - time); - - TripRouter router = bd.build(); - -// final Coord destinationCoord = new Coord(4489369.625538794, 5294502.251605561); -// -// Facility toFacility = ((ActivityFacilitiesFactory) activityFacilitiesFactory).createActivityFacility(Id.create(2, ActivityFacility.class), destinationCoord); -// -// long timeQuery = System.currentTimeMillis(); -// -// double time = 0; -// List planElements = router.calcRoute(TransportMode.pt, fromFacility, toFacility, 28800, null); -// System.out.println(System.currentTimeMillis()-timeQuery); -// -// for (PlanElement e : planElements) { -// if (e instanceof Leg) { -// time += ((Leg) e).getTravelTime(); -// } else if (e instanceof Activity) { -// if (((Activity) e).getType().equalsIgnoreCase(PtConstants.TRANSIT_ACTIVITY_TYPE)) { -// time += ((Activity) e).getEndTime() - ((Activity) e).getStartTime(); -// } -// } -// } - - - } -} From a04158a161edc9e7929921cacc3a534082b1d3bf Mon Sep 17 00:00:00 2001 From: nkuehnel Date: Tue, 31 Aug 2021 13:59:32 +0200 Subject: [PATCH 22/24] update geotools version --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 6f9e7694e..535b7411a 100644 --- a/pom.xml +++ b/pom.xml @@ -141,7 +141,7 @@ - 21.5 + 24.2 13.0 2.9.5 From fe215b4f912f6c117c294fa7641c10c35cfdab53 Mon Sep 17 00:00:00 2001 From: nkuehnel Date: Tue, 31 Aug 2021 14:30:49 +0200 Subject: [PATCH 23/24] delete code artifacts --- .../matsim/SiloMatsimMucTest.java | 9 +- .../transportModel/matsim/SiloNoiseTest.java | 168 ------------------ 2 files changed, 3 insertions(+), 174 deletions(-) delete mode 100644 useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java index a6537bc87..3b9055275 100644 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java +++ b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloMatsimMucTest.java @@ -7,9 +7,6 @@ import de.tum.bgu.msm.io.output.DefaultResultsMonitor; import de.tum.bgu.msm.io.output.ResultsMonitor; import de.tum.bgu.msm.properties.Properties; -import de.tum.bgu.msm.scenarios.noise.DataBuilderNoise; -import de.tum.bgu.msm.scenarios.noise.ModelBuilderMucNoise; -import de.tum.bgu.msm.scenarios.noise.NoiseDataContainerImpl; import de.tum.bgu.msm.schools.DataContainerWithSchools; import de.tum.bgu.msm.utils.SiloUtil; import junitx.framework.FileAssert; @@ -66,10 +63,10 @@ public final void testMain() { Properties properties = SiloUtil.siloInitialization(path); - NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); - DataBuilderNoise.read(properties, dataContainer); + DataContainerWithSchools dataContainer = DataBuilder.getModelDataForMuc(properties, config); + DataBuilder.read(properties, dataContainer); - ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); + ModelContainer modelContainer = ModelBuilderMuc.getModelContainerForMuc(dataContainer, properties, config); ResultsMonitor resultsMonitor = new DefaultResultsMonitor(dataContainer, properties); SiloModel siloModel = new SiloModel(properties, dataContainer, modelContainer); diff --git a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java b/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java deleted file mode 100644 index 05b095f35..000000000 --- a/useCases/munich/src/test/java/de/tum/bgu/msm/transportModel/matsim/SiloNoiseTest.java +++ /dev/null @@ -1,168 +0,0 @@ -package de.tum.bgu.msm.transportModel.matsim; - -import de.tum.bgu.msm.container.ModelContainer; -import de.tum.bgu.msm.data.Location; -import de.tum.bgu.msm.data.Region; -import de.tum.bgu.msm.data.Zone; -import de.tum.bgu.msm.data.dwelling.DefaultDwellingTypes; -import de.tum.bgu.msm.data.dwelling.Dwelling; -import de.tum.bgu.msm.data.dwelling.DwellingFactoryImpl; -import de.tum.bgu.msm.data.household.Household; -import de.tum.bgu.msm.data.household.HouseholdMuc; -import de.tum.bgu.msm.data.person.Gender; -import de.tum.bgu.msm.data.person.Occupation; -import de.tum.bgu.msm.data.person.PersonMuc; -import de.tum.bgu.msm.data.person.PersonRole; -import de.tum.bgu.msm.data.travelTimes.TravelTimes; -import de.tum.bgu.msm.io.MultiFileResultsMonitorMuc; -import de.tum.bgu.msm.io.output.ResultsMonitor; -import de.tum.bgu.msm.matsim.noise.NoiseDwelling; -import de.tum.bgu.msm.matsim.noise.NoiseModel; -import de.tum.bgu.msm.models.ModelUpdateListener; -import de.tum.bgu.msm.properties.Properties; -import de.tum.bgu.msm.scenarios.noise.*; -import de.tum.bgu.msm.util.matrices.IndexedDoubleMatrix2D; -import de.tum.bgu.msm.utils.SiloUtil; -import org.apache.log4j.Logger; -import org.junit.Rule; -import org.junit.Test; -import org.matsim.core.config.Config; -import org.matsim.core.config.ConfigUtils; -import org.matsim.testcases.MatsimTestUtils; - -import java.io.BufferedWriter; -import java.io.File; -import java.io.FileWriter; -import java.io.IOException; -import java.util.List; -import java.util.Random; - -public class SiloNoiseTest { - - @Rule - public MatsimTestUtils utils = new MatsimTestUtils(); - - private static final Logger log = Logger.getLogger(SiloMatsimMucTest.class); - - @Test - public final void testMain() throws IOException { - - String path = "./test/muc/siloMatsimMucTest.properties"; - Config config = ConfigUtils.loadConfig("./test/muc/matsim_input/config.xml") ; - - try { - utils.initWithoutJUnitForFixture(this.getClass(), this.getClass().getMethod("testMain", null)); - } catch (NoSuchMethodException e) { - e.printStackTrace(); - } - - File dir = new File("./test/muc/scenOutput/test/"); - - config.global().setNumberOfThreads(1); - config.parallelEventHandling().setNumberOfThreads(1); - config.qsim().setNumberOfThreads(1); - - Properties properties = SiloUtil.siloInitialization(path); - - NoiseDataContainerImpl dataContainer = DataBuilderNoise.getModelDataForMuc(properties, config); - DataBuilderNoise.read(properties, dataContainer); - ModelContainer modelContainer = ModelBuilderMucNoise.getModelContainerForMuc(dataContainer, properties, config); - - ResultsMonitor resultsMonitor = new MultiFileResultsMonitorMuc(dataContainer, properties); - - final List modelUpdateListeners = modelContainer.getModelUpdateListeners(); - for(ModelUpdateListener listenr: modelUpdateListeners) { - if(listenr instanceof NoiseModel) { - listenr.endYear(2011); - } - } - - NoiseDwelling refDwelling = new NoiseDwellingIml(new DwellingFactoryImpl().createDwelling(1, 20, null, -1, DefaultDwellingTypes.DefaultDwellingTypeImpl.MF234, 1, 1, 1000, 1980)); - refDwelling.setNoiseImmision(45); - - Household poor = new HouseholdMuc(1, 1, 2); - poor.addPerson(new PersonMuc(1, 23, Gender.MALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 6000)); - poor.addPerson(new PersonMuc(2, 23, Gender.FEMALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 6000)); - - - Household rich = new HouseholdMuc(2, 1, 2); - rich.addPerson(new PersonMuc(1, 23, Gender.MALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 35000)); - rich.addPerson(new PersonMuc(2, 23, Gender.FEMALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 35000)); - - Household avg = new HouseholdMuc(3, 1, 2); - avg.addPerson(new PersonMuc(1, 23, Gender.MALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 15000)); - avg.addPerson(new PersonMuc(2, 23, Gender.FEMALE, Occupation.UNEMPLOYED, PersonRole.MARRIED, -1, 15000)); - - final TravelTimes travelTimes = new TravelTimes() { - @Override - public double getTravelTime(Location location, Location location1, double v, String s) { - return 10; - } - - @Override - public double getTravelTimeFromRegion(Region region, Zone zone, double v, String s) { - return 10; - } - - @Override - public double getTravelTimeToRegion(Zone zone, Region region, double v, String s) { - return 10; - } - - @Override - public IndexedDoubleMatrix2D getPeakSkim(String s) { - return null; - } - - @Override - public TravelTimes duplicate() { - return null; - } - }; - - HuntNoiseSensitiveDwellingUtilityStrategy strategy = new HuntNoiseSensitiveDwellingUtilityStrategy(travelTimes, dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); - HuntNoiseInsensitiveDwellingUtilityStrategy strategyIns = new HuntNoiseInsensitiveDwellingUtilityStrategy(travelTimes, dataContainer.getJobDataManager(), dataContainer.getRealEstateDataManager(), null); - - BufferedWriter writer = new BufferedWriter(new FileWriter("C:/users/nico/desktop/noiseutil9.csv")); - writer.write("noise,price,type,poorUitl,mediumUtil,richUtil,poorUitlIn,mediumUtilIn,richUtilIn"); - writer.newLine(); - - Random random = new Random(42); - - dataContainer.getRealEstateDataManager().addDwelling(refDwelling); - for(Dwelling dwelling: dataContainer.getRealEstateDataManager().getDwellings()) { - ((NoiseDwelling)dwelling).setNoiseImmision(((NoiseDwelling) dwelling).getNoiseImmission()+random.nextInt(25)); - if(dwelling == refDwelling) { - continue; - } - double price = 1000; - if(((NoiseDwelling) dwelling).getNoiseImmission() > 75) { - price = price * (1 -0.1005); - } else if(((NoiseDwelling) dwelling).getNoiseImmission() > 65) { - price = price * (1 -0.0583); - } else if(((NoiseDwelling) dwelling).getNoiseImmission() > 55) { - price = price * (1 -0.0360); - } - dwelling.setPrice((int) price); - - final double v = strategy.calculateHousingUtility(poor, dwelling); - final double v2 = strategy.calculateHousingUtility(avg, dwelling); - final double v3 = strategy.calculateHousingUtility(rich, dwelling); - - final double v4 = strategyIns.calculateHousingUtility(poor, dwelling); - final double v5 = strategyIns.calculateHousingUtility(avg, dwelling); - final double v6 = strategyIns.calculateHousingUtility(rich, dwelling); - writer.write(((NoiseDwelling)dwelling).getNoiseImmission()+","+dwelling.getPrice() - +","+dwelling.getType()+","+v+","+v2+","+v3+","+v4+","+v5+","+v6); - writer.newLine(); - } - writer.flush(); - writer.close(); - - - -// SiloModel model = new SiloModel(properties, dataContainer, modelContainer); -// model.addResultMonitor(resultsMonitor); -// model.runModel(); - } -} From 7162880d35b55be7b8193aed405a95e1f2492e34 Mon Sep 17 00:00:00 2001 From: nkuehnel Date: Tue, 31 Aug 2021 15:05:31 +0200 Subject: [PATCH 24/24] fix test --- .../src/main/java/de/tum/bgu/msm/matsim/MatsimData.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java index 676365567..bdc7966c8 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/MatsimData.java @@ -138,7 +138,7 @@ public void update(TravelDisutility travelDisutility, TravelTime travelTime) { parametersForPerson = new DefaultRaptorParametersForPerson(config); defaultRaptorStopFinder = new DefaultRaptorStopFinder( - null, + config, new DefaultRaptorIntermodalAccessEgress(), null); routeSelector = new LeastCostRaptorRouteSelector();