From d59e430395d740d6b4a8bf78b60f30bbd26aa7e2 Mon Sep 17 00:00:00 2001 From: Kai Nagel Date: Tue, 21 Apr 2026 09:18:02 +0200 Subject: [PATCH 1/5] replace all HashMap by LinkedHashMap. With the former, the sequence of iteration may depend on the hardware --- analysis/src/main/java/sdg/SDGCalculator.java | 14 +-- .../sdg/reader/CongestionEventHandler.java | 3 +- .../EmissionsOnLinkEventHandler.java | 7 +- .../airPollutant/emission/AnalyzedObject.java | 5 +- .../emission/LinkEmissionHandler.java | 5 +- .../bgu/msm/health/data/ActivityLocation.java | 3 +- .../de/tum/bgu/msm/health/data/LinkInfo.java | 5 +- .../bgu/msm/health/data/RelativeRisks.java | 3 +- .../java/de/tum/bgu/msm/health/data/Trip.java | 7 +- .../msm/health/injury/AccidentAgentInfo.java | 3 +- .../msm/health/injury/AccidentLinkInfo.java | 15 +-- .../AccidentRateModelCoefficientReader.java | 5 +- .../msm/health/injury/AccidentsContext.java | 5 +- .../health/injury/AnalysisEventHandler.java | 23 ++-- .../injury/AnalysisEventHandlerOnline.java | 17 +-- .../io/HealthTransitionTableReader.java | 2 +- .../io/SportPAmodelCoefficientReader.java | 6 +- .../bgu/msm/health/io/TripReaderHealth.java | 3 +- .../msm/matsim/MatsimTravelTimesAndCosts.java | 2 +- .../matsim/SimpleMatsimCommuteModeChoice.java | 15 ++- .../accessibility/AccessibilityModule.java | 3 +- .../accessibility/MatsimAccessibility.java | 9 +- .../msm/mito/MitoMatsimScenarioAssembler.java | 5 +- .../de/tum/bgu/msm/data/SummarizeData.java | 3 +- .../dwelling/RealEstateDataManagerImpl.java | 10 +- .../de/tum/bgu/msm/data/geo/RegionImpl.java | 2 +- .../de/tum/bgu/msm/data/geo/ZoneImpl.java | 3 +- .../household/HouseholdDataManagerImpl.java | 7 +- .../bgu/msm/data/household/HouseholdUtil.java | 3 +- .../bgu/msm/data/job/JobDataManagerImpl.java | 14 +-- .../JobDataManagerWithCommuteModeChoice.java | 14 +-- .../java/de/tum/bgu/msm/data/job/JobType.java | 3 +- .../tum/bgu/msm/data/vehicle/VehicleUtil.java | 3 +- .../bgu/msm/io/input/CoefficientsReader.java | 3 +- .../io/output/ModalSharesResultMonitor.java | 15 +-- .../jobmography/JobMarketUpdateImpl.java | 2 +- .../modeChoice/SimpleCommuteModeChoice.java | 13 +-- .../ConstructionOverwriteImpl.java | 2 +- .../realEstate/pricing/PricingModelImpl.java | 11 +- .../CarAndTransitHousingStrategyImpl.java | 3 +- .../moves/CarOnlyHousingStrategyImpl.java | 3 +- .../relocation/moves/MovesModelImpl.java | 4 +- ...uteHousingStrategyWithoutCarOwnership.java | 3 +- ...eCommuteModeChoiceHousingStrategyImpl.java | 7 +- .../bgu/msm/properties/PropertiesUtil.java | 2 +- .../properties/modules/JobDataProperties.java | 3 +- .../msm/utils/DeferredAcceptanceMatching.java | 4 +- .../CoefficientsReader.java | 3 +- .../austin/SyntheticPopUs.java | 20 ++-- .../bangkok/allocation/Allocation.java | 4 +- .../bangkok/allocation/AssignJobs.java | 14 +-- .../bangkok/allocation/AssignSchools.java | 8 +- .../GenerateHouseholdsPersonsDwellings.java | 12 +-- .../bangkok/allocation/GenerateJobs.java | 3 +- .../allocation/GenerateVacantDwellings.java | 14 +-- .../GenerateDwellingMicrolocation.java | 17 +-- .../GenerateJobMicrolocation.java | 21 ++-- .../GenerateSchoolMicrolocation.java | 7 +- .../bangkok/microlocation/Microlocation.java | 3 +- .../CheckHouseholdRelationship.java | 13 +-- .../bangkok/preparation/ReadZonalData.java | 13 +-- .../capeTown/SyntheticPopCT.java | 96 ++++++++--------- .../capeTown/SyntheticPopCTrace.java | 102 +++++++++--------- .../germany/SyntheticPopGermanyMito.java | 6 +- .../SyntheticPopGermanyMitoByState.java | 17 ++- .../germany/allocation/AssignJobs.java | 14 +-- .../allocation/AssignJobsBySubpopulation.java | 2 +- .../germany/allocation/AssignSchools.java | 8 +- .../AssignSchoolsBySubpopulation.java | 3 +- .../allocation/GenerateHouseholdsPersons.java | 2 +- .../allocation/GenerateJobCounters.java | 10 +- .../germany/allocation/GenerateJobs.java | 3 +- .../GenerateSchoolMicrolocations.java | 11 +- .../Read2011JobsForMicrolocation.java | 6 +- ...ValidateTripLengthDistributionByState.java | 5 +- .../germany/io/ReadSubPopulations.java | 20 ++-- .../io/WriteSubpopulationsByState.java | 11 +- .../germany/preparation/MicroDataManager.java | 33 +++--- .../germany/preparation/ReadMicroData.java | 9 +- .../germany/preparation/ReadZonalData.java | 12 +-- .../kagawa/ExtractMicroDataJP.java | 15 +-- .../kagawa/IPUbyCityWithSubsample.java | 12 +-- .../kagawa/SyntheticPopJP.java | 44 ++++---- .../manchester/DataSetSynPopMCR.java | 3 +- .../manchester/allocation/Allocation.java | 5 +- .../manchester/allocation/AssignJobs.java | 14 +-- .../manchester/allocation/AssignSchools.java | 14 +-- .../GenerateHouseholdsPersonsDwellings.java | 8 +- .../manchester/allocation/GenerateJobs.java | 3 +- .../allocation/GenerateVacantDwellings.java | 14 +-- .../GenerateDwellingMicrolocation.java | 8 +- .../GenerateJobMicrolocation.java | 10 +- .../GenerateSchoolMicrolocation.java | 7 +- .../CheckHouseholdRelationship.java | 11 +- .../preparation/MicroDataManager.java | 99 ++++++++--------- .../manchester/preparation/ReadZonalData.java | 33 +++--- .../maryland/CreateFreeFlowCarSkim.java | 2 +- .../maryland/SyntheticPopUs.java | 20 ++-- .../munich/allocation/Allocation.java | 5 +- .../munich/allocation/AssignJobs.java | 14 +-- .../allocation/AssignPropertiesToJobs.java | 8 +- .../munich/allocation/AssignSchools.java | 8 +- .../GenerateHouseholdsPersonsDwellings.java | 3 +- .../munich/allocation/GenerateJobs.java | 3 +- .../allocation/GenerateVacantDwellings.java | 13 +-- .../GenerateDwellingMicrolocation.java | 17 +-- .../GenerateJobMicrolocation.java | 21 ++-- .../GenerateSchoolMicrolocation.java | 7 +- .../munich/microlocation/Microlocation.java | 3 +- .../CheckHouseholdRelationship.java | 11 +- .../munich/preparation/MicroDataManager.java | 99 ++++++++--------- .../munich/preparation/ReadMicroData.java | 11 +- .../munich/preparation/ReadZonalData.java | 15 +-- .../munich/synpopTrampa/AllocationTrampa.java | 5 +- ...erateHouseholdsPersonsDwellingsTrampa.java | 7 +- .../synpopTrampa/GenerateJobsTrampa.java | 3 +- .../optimization/IPUbyCity.java | 12 +-- .../optimization/IPUbyCountyAndCity.java | 25 ++--- .../IPUbyCountyCityAndBorough.java | 35 +++--- .../perth/SyntheticPopPerth.java | 18 ++-- .../sanFrancisco/CreateSkimFromUber.java | 7 +- .../sanFrancisco/SyntheticPopUs.java | 18 ++-- .../bgu/msm/syntheticPopulation/ipuTest.java | 4 +- .../msm/syntheticPopulation/ipuTestOpt.java | 22 ++-- .../msm/run/data/jobs/BangkokJobFactory.java | 5 +- .../data/job/JobFactoryBerlinBrandenburg.java | 5 +- ...tonomousVehicleModelBerlinBrandenburg.java | 3 +- .../relocation/HousingStrategyCapeTown.java | 11 +- .../java/inputGeneration/CreateShapefile.java | 2 +- .../inputGeneration/PTScheduleCreator.java | 2 +- .../src/test/java/run/RunFabilandTest.java | 2 + .../CoreCityJobMarketUpdateTak.java | 2 +- ...raconicResettlementJobMarketUpdateTak.java | 2 +- ...LongCommutePenaltytHousingStrategyTak.java | 3 +- .../tum/bgu/msm/health/DataBuilderHealth.java | 3 +- .../msm/health/HealthDataContainerImpl.java | 6 +- .../msm/health/HealthExposureModelMCR.java | 2 +- .../health/MatsimTransportModelMCRHealth.java | 2 +- .../MitoMatsimScenarioAssemblerMCR.java | 5 +- .../tum/bgu/msm/health/PersonHealthMCR.java | 10 +- .../tum/bgu/msm/health/SportPAModelMCR.java | 2 +- .../HealthExposuresReader.java | 5 +- .../de/tum/bgu/msm/models/BirthModelMCR.java | 2 +- .../models/ConstructionOverwriteMCRImpl.java | 2 +- .../de/tum/bgu/msm/models/MovesModelMCR.java | 4 +- .../msm/data/HouseholdDataManagerMstm.java | 4 +- .../msm/data/RealEstateDataManagerMstm.java | 2 +- .../de/tum/bgu/msm/data/geo/GeoDataMstm.java | 3 +- .../msm/models/ConstructionOverwriteMstm.java | 2 +- .../tum/bgu/msm/models/MarriageModelMstm.java | 4 +- .../java/de/tum/bgu/msm/run/MstmMonitor.java | 17 +-- .../tum/bgu/msm/data/job/JobFactoryMuc.java | 5 +- .../SwitchToAutonomousVehicleModelMuc.java | 3 +- .../scenarios/av/ParkingSimpleMoceChoice.java | 13 +-- .../CoreCityJobMarketUpdate.java | 2 +- .../DraconicResettlementJobMarketUpdate.java | 2 +- .../bgu/msm/scenarios/ev/EVResultMonitor.java | 2 +- .../ev/SwitchToElectricVehicleModelMuc.java | 2 +- .../healthMuc/HealthDataContainerImpl.java | 2 +- .../scenarios/healthMuc/HealthModelMuc.java | 12 +-- .../scenarios/healthMuc/PersonHealthMuc.java | 6 +- 161 files changed, 869 insertions(+), 832 deletions(-) diff --git a/analysis/src/main/java/sdg/SDGCalculator.java b/analysis/src/main/java/sdg/SDGCalculator.java index 81f1f1f13..897a1f4a6 100644 --- a/analysis/src/main/java/sdg/SDGCalculator.java +++ b/analysis/src/main/java/sdg/SDGCalculator.java @@ -31,13 +31,13 @@ public class SDGCalculator { private Collection dwellings = new ArrayList<>(); private Collection persons = new ArrayList<>(); private RealEstateDataManager realEstateDataManager; - private Map> hhByZone = new HashMap<>(); - private Map> ppByZone = new HashMap<>(); - private Map> ddByZone = new HashMap<>(); - private Map matsimPerson = new HashMap<>(); - private Map> commutingTripsByZone = new HashMap<>(); - private Map> schoolTripsByZone = new HashMap<>(); - private Map>> ttByModeByZone = new HashMap<>(); + private Map> hhByZone = new LinkedHashMap<>(); + private Map> ppByZone = new LinkedHashMap<>(); + private Map> ddByZone = new LinkedHashMap<>(); + private Map matsimPerson = new LinkedHashMap<>(); + private Map> commutingTripsByZone = new LinkedHashMap<>(); + private Map> schoolTripsByZone = new LinkedHashMap<>(); + private Map>> ttByModeByZone = new LinkedHashMap<>(); public void setMatsimPerson(Map matsimPerson) { this.matsimPerson = matsimPerson; diff --git a/analysis/src/main/java/sdg/reader/CongestionEventHandler.java b/analysis/src/main/java/sdg/reader/CongestionEventHandler.java index df4e06f7f..15f8b73c0 100644 --- a/analysis/src/main/java/sdg/reader/CongestionEventHandler.java +++ b/analysis/src/main/java/sdg/reader/CongestionEventHandler.java @@ -13,6 +13,7 @@ import sdg.data.AnalyzedPerson; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class CongestionEventHandler implements LinkEnterEventHandler, LinkLeaveEventHandler, VehicleLeavesTrafficEventHandler { @@ -23,7 +24,7 @@ public Map getPersons() { return persons; } - private Map persons = new HashMap<>(); + private Map persons = new LinkedHashMap<>(); public CongestionEventHandler(Network network) { this.network = network; diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/dispersion/EmissionsOnLinkEventHandler.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/dispersion/EmissionsOnLinkEventHandler.java index 5f461a2a6..cd509db35 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/dispersion/EmissionsOnLinkEventHandler.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/dispersion/EmissionsOnLinkEventHandler.java @@ -11,6 +11,7 @@ import org.matsim.contrib.emissions.events.WarmEmissionEventHandler; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; /** @@ -41,7 +42,7 @@ public void reset(int iteration) { @Override public void handleEvent(WarmEmissionEvent event) { - Map map = new HashMap<>() ; + Map map = new LinkedHashMap<>() ; for( Map.Entry entry : event.getWarmEmissions().entrySet() ){ map.put( entry.getKey(), entry.getValue() ) ; } @@ -59,10 +60,10 @@ private void handleEmissionEvent(double time, Id linkId, Map, EmissionsByPollutant>> currentBin = timeBins.getTimeBin(time); if (!currentBin.hasValue()){ - currentBin.setValue( new HashMap<>() ); + currentBin.setValue( new LinkedHashMap<>() ); } if (!currentBin.getValue().containsKey(linkId)){ - currentBin.getValue().put( linkId, new EmissionsByPollutant( new HashMap<>( emissions ) ) ); + currentBin.getValue().put( linkId, new EmissionsByPollutant( new LinkedHashMap<>( emissions ) ) ); } else{ currentBin.getValue().get( linkId ).addEmissions( emissions ); } diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/AnalyzedObject.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/AnalyzedObject.java index 66d6a02fd..32715b891 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/AnalyzedObject.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/AnalyzedObject.java @@ -4,6 +4,7 @@ import org.matsim.contrib.emissions.Pollutant; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class AnalyzedObject { @@ -13,8 +14,8 @@ public class AnalyzedObject { public AnalyzedObject(Id id) { this.id = id; - this.warmEmissions = new HashMap<>(); - this.coldEmissions = new HashMap<>(); + this.warmEmissions = new LinkedHashMap<>(); + this.coldEmissions = new LinkedHashMap<>(); } public Map getWarmEmissions() { diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/LinkEmissionHandler.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/LinkEmissionHandler.java index 1555954b8..1af0cdd8a 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/LinkEmissionHandler.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/airPollutant/emission/LinkEmissionHandler.java @@ -13,6 +13,7 @@ import org.matsim.vehicles.Vehicle; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class LinkEmissionHandler implements WarmEmissionEventHandler, ColdEmissionEventHandler { @@ -26,8 +27,8 @@ public class LinkEmissionHandler implements WarmEmissionEventHandler, ColdEmissi public LinkEmissionHandler(Network network) { this.network = network; - emmisionsByLink = new HashMap<>(); - emmisionsByVehicle = new HashMap<>(); + emmisionsByLink = new LinkedHashMap<>(); + emmisionsByVehicle = new LinkedHashMap<>(); } @Override diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/ActivityLocation.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/ActivityLocation.java index aab3c6128..fbeee0b80 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/ActivityLocation.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/ActivityLocation.java @@ -5,6 +5,7 @@ import org.matsim.contrib.emissions.Pollutant; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class ActivityLocation { @@ -13,7 +14,7 @@ public class ActivityLocation { private final Coordinate coordinate; - private Map exposure2Pollutant2TimeBin = new HashMap<>(); + private Map exposure2Pollutant2TimeBin = new LinkedHashMap<>(); private OpenIntFloatHashMap noiseLevel2TimeBin = new OpenIntFloatHashMap(); diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/LinkInfo.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/LinkInfo.java index 85475b25b..bd0856fcd 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/LinkInfo.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/LinkInfo.java @@ -7,15 +7,16 @@ import org.matsim.contrib.emissions.Pollutant; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class LinkInfo { private final Id linkId; - private Map severeFatalCasualityExposureByAccidentTypeByTime = new HashMap<>(); + private Map severeFatalCasualityExposureByAccidentTypeByTime = new LinkedHashMap<>(); - private Map exposure2Pollutant2TimeBin = new HashMap<>(); + private Map exposure2Pollutant2TimeBin = new LinkedHashMap<>(); private OpenIntFloatHashMap noiseLevel2TimeBin = new OpenIntFloatHashMap(); diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/RelativeRisks.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/RelativeRisks.java index cd2594844..008740287 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/RelativeRisks.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/RelativeRisks.java @@ -3,13 +3,14 @@ import de.tum.bgu.msm.data.Mode; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; // Dose-response functions for health exposures (simple for now but will become more complex) public class RelativeRisks { public static Map calculate(PersonHealth personHealth) { - Map relativeRisks = new HashMap<>(); + Map relativeRisks = new LinkedHashMap<>(); relativeRisks.put("walk", (float) walk(personHealth.getWeeklyMarginalMetHours(Mode.walk))); relativeRisks.put("cycle", (float) bike(personHealth.getWeeklyMarginalMetHours(Mode.bicycle))); diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/Trip.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/Trip.java index 6807a17b2..451a6d34e 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/data/Trip.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/data/Trip.java @@ -5,6 +5,7 @@ import java.util.Arrays; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; /** @@ -44,12 +45,12 @@ public class Trip implements Id { private double matsimTravelDistance = 0.; private double marginalMetHours = 0.; - private Map travelRiskMap = new HashMap<>(); - private Map travelExposureMap = new HashMap<>(); + private Map travelRiskMap = new LinkedHashMap<>(); + private Map travelExposureMap = new LinkedHashMap<>(); private double travelNoiseExposure = 0.; private double travelNdviExposure = 0.; - private Map activityExposureMap = new HashMap<>(); + private Map activityExposureMap = new LinkedHashMap<>(); private double activityNoiseExposure = 0.; private double activityNdviExposure = 0.; diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentAgentInfo.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentAgentInfo.java index d060494fa..7b0a2bff4 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentAgentInfo.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentAgentInfo.java @@ -4,12 +4,13 @@ import org.matsim.api.core.v01.network.Link; import org.matsim.api.core.v01.population.Person; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class AccidentAgentInfo { private final Id personId; - private final Map, Map> linkId2time2mode = new HashMap<>(); + private final Map, Map> linkId2time2mode = new LinkedHashMap<>(); private double lightInjuryRisk; private double severeInjuryRisk; diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentLinkInfo.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentLinkInfo.java index 4cb231fab..61a785968 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentLinkInfo.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentLinkInfo.java @@ -25,6 +25,7 @@ import org.matsim.api.core.v01.network.Link; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; /** @@ -35,19 +36,19 @@ public class AccidentLinkInfo { private final Id linkId; - private final Map timeSpecificInfo = new HashMap<>(); + private final Map timeSpecificInfo = new LinkedHashMap<>(); -// private Map> lightCrashRateByAccidentTypeByTime = new HashMap<>(); +// private Map> lightCrashRateByAccidentTypeByTime = new LinkedHashMap<>(); // -// private Map> severeFatalCrashRateByAccidentTypeByTime = new HashMap<>(); +// private Map> severeFatalCrashRateByAccidentTypeByTime = new LinkedHashMap<>(); // -// private Map> lightCasualityRateByAccidentTypeByTime = new HashMap<>(); +// private Map> lightCasualityRateByAccidentTypeByTime = new LinkedHashMap<>(); // -// private Map> severeFatalCasualityRateByAccidentTypeByTime = new HashMap<>(); +// private Map> severeFatalCasualityRateByAccidentTypeByTime = new LinkedHashMap<>(); - private Map lightCasualityExposureByAccidentTypeByTime = new HashMap<>(); + private Map lightCasualityExposureByAccidentTypeByTime = new LinkedHashMap<>(); - private Map severeFatalCasualityExposureByAccidentTypeByTime = new HashMap<>(); + private Map severeFatalCasualityExposureByAccidentTypeByTime = new LinkedHashMap<>(); public AccidentLinkInfo(Id linkId) { this.linkId = linkId; diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentRateModelCoefficientReader.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentRateModelCoefficientReader.java index b95b2c19a..ebc3591e5 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentRateModelCoefficientReader.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentRateModelCoefficientReader.java @@ -7,6 +7,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class AccidentRateModelCoefficientReader { @@ -15,8 +16,8 @@ public class AccidentRateModelCoefficientReader { private AccidentType accidentType; private AccidentSeverity accidentSeverity; private String path; - private final Map coefficients = new HashMap<>(); - private final Map timeOfDayDistribution = new HashMap<>(); + private final Map coefficients = new LinkedHashMap<>(); + private final Map timeOfDayDistribution = new LinkedHashMap<>(); public AccidentRateModelCoefficientReader(AccidentType accidentType, AccidentSeverity accidentSeverity, String path) { this.accidentType = accidentType; diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentsContext.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentsContext.java index 79be01d16..cec9c584a 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentsContext.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AccidentsContext.java @@ -25,6 +25,7 @@ import org.matsim.api.core.v01.population.Person; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; /** @@ -37,9 +38,9 @@ public final class AccidentsContext { @Inject AccidentsContext(){} // injected constructor is package-private so that nobody can instantiate this class directly - private Map, AccidentLinkInfo> linkId2info = new HashMap<>(); + private Map, AccidentLinkInfo> linkId2info = new LinkedHashMap<>(); - private Map, AccidentAgentInfo> personId2info = new HashMap<>(); + private Map, AccidentAgentInfo> personId2info = new LinkedHashMap<>(); public Map, AccidentLinkInfo> getLinkId2info() { return linkId2info; diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandler.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandler.java index c9b33f39b..ab16f2e03 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandler.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandler.java @@ -33,10 +33,7 @@ import org.matsim.core.events.handler.EventHandler; import org.matsim.vehicles.Vehicle; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; /** * @author ikaddoura @@ -44,11 +41,11 @@ public class AnalysisEventHandler implements EventHandler, LinkLeaveEventHandler, PersonEntersVehicleEventHandler, PersonDepartureEventHandler { - private final Map, Map> linkId2time2leavingAgents = new HashMap<>(); - private final Map, Map>>> linkId2time2personIds = new HashMap<>(); - private final Map, Id> vehicleId2personId = new HashMap<>(); - private final Map, Map>> linkId2mode2time2leavingAgents = new HashMap<>(); - private final Map, String> personId2legMode = new HashMap<>(); + private final Map, Map> linkId2time2leavingAgents = new LinkedHashMap<>(); + private final Map, Map>>> linkId2time2personIds = new LinkedHashMap<>(); + private final Map, Id> vehicleId2personId = new LinkedHashMap<>(); + private final Map, Map>> linkId2mode2time2leavingAgents = new LinkedHashMap<>(); + private final Map, String> personId2legMode = new LinkedHashMap<>(); @Inject AnalysisEventHandler(){} @@ -89,13 +86,13 @@ public void handleEvent(LinkLeaveEvent event) { linkId2mode2time2leavingAgents.get(linkId).get(legMode).put(timeBinNr, 1); } } else { - Map time2leavingAgents = new HashMap<>(); + Map time2leavingAgents = new LinkedHashMap<>(); time2leavingAgents.put(timeBinNr,1); linkId2mode2time2leavingAgents.get(linkId).put(legMode, time2leavingAgents); } } else { - Map> mode2time2leavingAgents = new HashMap<>(); - Map time2leavingAgents = new HashMap<>(); + Map> mode2time2leavingAgents = new LinkedHashMap<>(); + Map time2leavingAgents = new LinkedHashMap<>(); time2leavingAgents.put(timeBinNr,1); mode2time2leavingAgents.put(legMode,time2leavingAgents); linkId2mode2time2leavingAgents.put(linkId, mode2time2leavingAgents); @@ -110,7 +107,7 @@ public void handleEvent(LinkLeaveEvent event) { if(personInfo.getLinkId2time2mode().get(linkId)!=null){ personInfo.getLinkId2time2mode().get(linkId).put(hour, legMode); }else{ - Map time2Mode = new HashMap<>(); + Map time2Mode = new LinkedHashMap<>(); time2Mode.put(hour, legMode); personInfo.getLinkId2time2mode().put(linkId, time2Mode); } diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandlerOnline.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandlerOnline.java index 38858f3ca..b6eb4548c 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandlerOnline.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/injury/AnalysisEventHandlerOnline.java @@ -34,6 +34,7 @@ import org.matsim.vehicles.Vehicle; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -43,11 +44,11 @@ public final class AnalysisEventHandlerOnline extends AnalysisEventHandler { - /*private final Map, Map> linkId2time2leavingAgents = new HashMap<>(); - private final Map, Map>>> linkId2time2personIds = new HashMap<>();*/ - private final Map, Id> vehicleId2personId = new HashMap<>(); - private final Map, Map>> linkId2mode2time2leavingAgents = new HashMap<>(); - private final Map, String> personId2legMode = new HashMap<>(); + /*private final Map, Map> linkId2time2leavingAgents = new LinkedHashMap<>(); + private final Map, Map>>> linkId2time2personIds = new LinkedHashMap<>();*/ + private final Map, Id> vehicleId2personId = new LinkedHashMap<>(); + private final Map, Map>> linkId2mode2time2leavingAgents = new LinkedHashMap<>(); + private final Map, String> personId2legMode = new LinkedHashMap<>(); @Inject @@ -89,13 +90,13 @@ public void handleEvent(LinkLeaveEvent event) { linkId2mode2time2leavingAgents.get(linkId).get(legMode).put(timeBinNr, 1); } } else { - Map time2leavingAgents = new HashMap<>(); + Map time2leavingAgents = new LinkedHashMap<>(); time2leavingAgents.put(timeBinNr,1); linkId2mode2time2leavingAgents.get(linkId).put(legMode, time2leavingAgents); } } else { - Map> mode2time2leavingAgents = new HashMap<>(); - Map time2leavingAgents = new HashMap<>(); + Map> mode2time2leavingAgents = new LinkedHashMap<>(); + Map time2leavingAgents = new LinkedHashMap<>(); time2leavingAgents.put(timeBinNr,1); mode2time2leavingAgents.put(legMode,time2leavingAgents); linkId2mode2time2leavingAgents.put(linkId, mode2time2leavingAgents); diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/io/HealthTransitionTableReader.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/io/HealthTransitionTableReader.java index cf73186ff..bb406f6a4 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/io/HealthTransitionTableReader.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/io/HealthTransitionTableReader.java @@ -47,7 +47,7 @@ public EnumMap> readData(DataContainerHealth dataC String compositeKey = dataContainer.createTransitionLookupIndex(age,gender,location); - healthDiseaseData.computeIfAbsent(diseases, k -> new HashMap<>()).put(compositeKey, prob); + healthDiseaseData.computeIfAbsent(diseases, k -> new LinkedHashMap<>()).put(compositeKey, prob); } } catch (IOException e) { diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/io/SportPAmodelCoefficientReader.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/io/SportPAmodelCoefficientReader.java index 9ddb313ee..bfb297a80 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/io/SportPAmodelCoefficientReader.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/io/SportPAmodelCoefficientReader.java @@ -16,9 +16,9 @@ public class SportPAmodelCoefficientReader { public Map> readData(String fileName) { logger.info("Reading sport PA model coefficient from csv file"); - Map> coef = new HashMap<>(); - coef.put("zero", new HashMap<>()); - coef.put("linear", new HashMap<>()); + Map> coef = new LinkedHashMap<>(); + coef.put("zero", new LinkedHashMap<>()); + coef.put("linear", new LinkedHashMap<>()); String recString = ""; diff --git a/extensions/health/src/main/java/de/tum/bgu/msm/health/io/TripReaderHealth.java b/extensions/health/src/main/java/de/tum/bgu/msm/health/io/TripReaderHealth.java index 26ad082cf..99390096e 100644 --- a/extensions/health/src/main/java/de/tum/bgu/msm/health/io/TripReaderHealth.java +++ b/extensions/health/src/main/java/de/tum/bgu/msm/health/io/TripReaderHealth.java @@ -13,6 +13,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class TripReaderHealth { @@ -22,7 +23,7 @@ public class TripReaderHealth { public Map readData(String path) { logger.info("Reading mito trip micro data from csv file"); - Map mitoTrips = new HashMap<>(); + Map mitoTrips = new LinkedHashMap<>(); String recString = ""; int recCount = 0; 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 367a711cb..c2d00fccb 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 @@ -49,7 +49,7 @@ public final class MatsimTravelTimesAndCosts implements TravelTimes { private MatsimData matsimData; - private final Map skimsByMode = new HashMap<>(); + private final Map skimsByMode = new LinkedHashMap<>(); private Map zones; private TripRouter tripRouter; diff --git a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/SimpleMatsimCommuteModeChoice.java b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/SimpleMatsimCommuteModeChoice.java index cbe982033..e4c748414 100644 --- a/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/SimpleMatsimCommuteModeChoice.java +++ b/extensions/matsim2silo/src/main/java/de/tum/bgu/msm/matsim/SimpleMatsimCommuteModeChoice.java @@ -19,10 +19,7 @@ import de.tum.bgu.msm.properties.Properties; import org.matsim.api.core.v01.TransportMode; -import java.util.HashMap; -import java.util.Map; -import java.util.Random; -import java.util.TreeMap; +import java.util.*; /** * Copy of SimpleCommuteModeChoice, but with person in argument of travel time request @@ -33,7 +30,7 @@ public class SimpleMatsimCommuteModeChoice implements CommuteModeChoice { private final CommutingTimeProbability commutingTimeProbability; private final JobDataManager jobDataManager; private final GeoData geoData; - private Random random; + private final Random random; public SimpleMatsimCommuteModeChoice(DataContainer dataContainer, Properties properties, Random random) { @@ -50,7 +47,7 @@ public CommuteModeChoiceMapping assignCommuteModeChoice(Location from, TravelTim CommuteModeChoiceMapping commuteModeChoiceMapping = new CommuteModeChoiceMapping(HouseholdUtil.getNumberOfWorkers(household)); - Map> commuteModesByPerson = new HashMap<>(); + Map> commuteModesByPerson = new LinkedHashMap<>(); TreeMap personByProbability = new TreeMap<>(); for (Person pp : household.getPersons().values()) { @@ -69,7 +66,7 @@ public CommuteModeChoiceMapping assignCommuteModeChoice(Location from, TravelTim // TODO clean up the following line int carMinutes = (int) ((MatsimTravelTimesAndCosts) travelTimes).getTravelTime(from, job, job.getStartTimeInSeconds().orElse((int) properties.transportModel.peakHour_s), TransportMode.car, pp); double carUtility = commutingTimeProbability.getCommutingTimeProbability(carMinutes, TransportMode.car); - Map utilityByMode = new HashMap<>(); + Map utilityByMode = new LinkedHashMap<>(); utilityByMode.put(TransportMode.car, carUtility); utilityByMode.put(TransportMode.pt, ptUtility); commuteModesByPerson.put(pp.getId(), utilityByMode); @@ -114,7 +111,7 @@ public CommuteModeChoiceMapping assignRegionalCommuteModeChoice(Region region, T CommuteModeChoiceMapping commuteModeChoiceMapping = new CommuteModeChoiceMapping(HouseholdUtil.getNumberOfWorkers(household)); - Map> commuteModesByPerson = new HashMap<>(); + Map> commuteModesByPerson = new LinkedHashMap<>(); TreeMap personByProbability = new TreeMap<>(); @@ -134,7 +131,7 @@ public CommuteModeChoiceMapping assignRegionalCommuteModeChoice(Region region, T } else { int carMinutes = (int) travelTimes.getTravelTimeFromRegion(region, jobZone, job.getStartTimeInSeconds().orElse((int) properties.transportModel.peakHour_s), TransportMode.car); double carUtility = commutingTimeProbability.getCommutingTimeProbability(carMinutes, TransportMode.car); - Map utilityByMode = new HashMap<>(); + Map utilityByMode = new LinkedHashMap<>(); utilityByMode.put(TransportMode.car, carUtility); utilityByMode.put(TransportMode.pt, ptUtility); commuteModesByPerson.put(pp.getId(), utilityByMode); 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 f35fc48b0..26bdea04d 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 @@ -26,6 +26,7 @@ import org.matsim.facilities.*; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.TreeMap; @@ -85,7 +86,7 @@ public void prepareAccessibility(Scenario scenario, Controler controler) { acg.setMeasuringPointsFacilities(zoneRepresentativeCoords); // Map, Geometry> measurePointGeometryMap = new TreeMap<>(); - Map zoneFeatureMap = new HashMap<>(); + Map zoneFeatureMap = new LinkedHashMap<>(); for (Zone zone : dataContainer.getGeoData().getZones().values()) { zoneFeatureMap.put(zone.getId(), zone.getZoneFeature()); } 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 2858838f5..1ddc320ff 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 @@ -2,6 +2,7 @@ import java.util.Collection; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import de.tum.bgu.msm.data.accessibility.Accessibility; @@ -26,10 +27,10 @@ public class MatsimAccessibility implements Accessibility, FacilityDataExchangeI private final GeoData geoData; - private Map, Map> accessibilitiesMap = new HashMap<>(); + private Map, Map> accessibilitiesMap = new LinkedHashMap<>(); - private Map, Double> autoAccessibilities = new HashMap<>(); - private Map, Double> transitAccessibilities = new HashMap<>(); + private Map, Double> autoAccessibilities = new LinkedHashMap<>(); + private Map, Double> transitAccessibilities = new LinkedHashMap<>(); private IndexedDoubleMatrix1D regionalAccessibilities; public MatsimAccessibility(GeoData geoData) { @@ -42,7 +43,7 @@ public void setFacilityAccessibilities(ActivityFacility measurePoint, Double tim if (timeOfDay == 8 * 60. * 60.) { // TODO Find better way for this check Tuple key = new Tuple<>(measurePoint, timeOfDay); if (!accessibilitiesMap.containsKey(key)) { - Map accessibilitiesByMode = new HashMap<>(); + Map accessibilitiesByMode = new LinkedHashMap<>(); accessibilitiesMap.put(key, accessibilitiesByMode); } accessibilitiesMap.get(key).put(mode, accessibility); 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 8d6f0284a..8b319eed4 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 @@ -32,6 +32,7 @@ import uk.cam.mrc.phm.MitoModelMCR; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Objects; import java.util.stream.Collectors; @@ -93,9 +94,9 @@ public Map assembleMultiScenarios(Config initialMatsimConfig, int mito.run(); logger.info(" Receiving demand from MITO"); - Map scenarios = new HashMap<>(); + Map scenarios = new LinkedHashMap<>(); - Map populationByDay = new HashMap(); + Map populationByDay = new LinkedHashMap(); for(Person person: dataSet.getPopulation().getPersons().values()){ Day day = Day.valueOf((String)person.getAttributes().getAttribute("day")); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/SummarizeData.java b/siloCore/src/main/java/de/tum/bgu/msm/data/SummarizeData.java index 384e4bc9e..8d6819d87 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/SummarizeData.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/SummarizeData.java @@ -22,6 +22,7 @@ import java.io.PrintWriter; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -192,7 +193,7 @@ public static void scaleMicroDataToExogenousForecast(int year, DataContainer dat int[] changeOfHh = new int[highestId + 1]; - Map hhByZone = new HashMap<>(); + Map hhByZone = new LinkedHashMap<>(); RealEstateDataManager realEstateDataManager = dataContainer.getRealEstateDataManager(); for (Household hh : dataContainer.getHouseholdDataManager().getHouseholds()) { int zone = -1; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/dwelling/RealEstateDataManagerImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/data/dwelling/RealEstateDataManagerImpl.java index fd272473b..7f8df7283 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/dwelling/RealEstateDataManagerImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/dwelling/RealEstateDataManagerImpl.java @@ -45,11 +45,11 @@ public class RealEstateDataManagerImpl implements RealEstateDataManager { /** * Stores current shares of dwellings by quality levels. Updated once per year. */ - private final Map updatedQualityShares = new HashMap<>(); + private final Map updatedQualityShares = new LinkedHashMap<>(); /** * Stores initial shares of dwellings by quality levels in the base year. */ - private final Map initialQualityShares = new HashMap<>(); + private final Map initialQualityShares = new LinkedHashMap<>(); private int highestDwellingIdInUse; private static final Map> ddPriceByIncomeCategory = new EnumMap<>(IncomeCategory.class); @@ -263,7 +263,7 @@ private void setHighestVariablesAndCalculateRentShareByIncome() { countOfHouseholdsByIncomeAndRentCategory.get(highestIncCat).add(RENT_CATEGORIES); // make sure that most expensive category can be afforded by richest households for (IncomeCategory incomeCategory : IncomeCategory.values()) { float sum = countOfHouseholdsByIncomeAndRentCategory.get(incomeCategory).size(); - Map shareOfRentsForThisIncCat = new HashMap<>(); + Map shareOfRentsForThisIncCat = new LinkedHashMap<>(); for (int rentCategory = 0; rentCategory <= RENT_CATEGORIES; rentCategory++) { int thisRentAndIncomeCat = countOfHouseholdsByIncomeAndRentCategory.get(incomeCategory).count(rentCategory); if (sum != 0) { @@ -456,7 +456,7 @@ private void readDevelopmentData() { TableDataSet developmentTable = SiloUtil.readCSVfile(baseDirectory + Properties.get().geo.landUseAndDevelopmentFile); int[] zoneIdData = developmentTable.getColumnAsInt("Zone"); - Map constraintData = new HashMap<>(); + Map constraintData = new LinkedHashMap<>(); for (DwellingType dwellingType : dwellingTypes.getTypes()) { constraintData.put(dwellingType, developmentTable.getColumnAsInt(dwellingType.toString())); } @@ -466,7 +466,7 @@ private void readDevelopmentData() { for (int i = 0; i < zoneIdData.length; i++) { if(geoData.getZones().containsKey(zoneIdData[i])) { - Map constraints = new HashMap<>(); + Map constraints = new LinkedHashMap<>(); for (DwellingType dwellingType : dwellingTypes.getTypes()) { constraints.put(dwellingType, constraintData.get(dwellingType)[i] == 1); } diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/geo/RegionImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/data/geo/RegionImpl.java index 5d68a0b8c..0c6096d7e 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/geo/RegionImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/geo/RegionImpl.java @@ -9,7 +9,7 @@ public class RegionImpl implements Region { private final Set zones = new LinkedHashSet<>(); private final int id; - private final Map attributes = new HashMap<>(); + private final Map attributes = new LinkedHashMap<>(); public RegionImpl(int id) { this.id = id; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/geo/ZoneImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/data/geo/ZoneImpl.java index 5b9e90471..576d97910 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/geo/ZoneImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/geo/ZoneImpl.java @@ -14,6 +14,7 @@ import org.matsim.core.utils.geometry.geotools.MGC; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Random; @@ -28,7 +29,7 @@ public class ZoneImpl implements Zone { private Development development; - private final Map attributes = new HashMap<>(); + private final Map attributes = new LinkedHashMap<>(); public ZoneImpl(int id, float area_sqmi, Region region) { this.id = id; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdDataManagerImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdDataManagerImpl.java index 26daee44b..35fcf3d14 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdDataManagerImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdDataManagerImpl.java @@ -31,10 +31,7 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; +import java.util.*; /** * @author Greg Erhardt @@ -59,7 +56,7 @@ public class HouseholdDataManagerImpl implements HouseholdDataManager { private float[][][] avgIncomeByGenderByAgeByOccupation; - private Map householdMementos = new HashMap<>(); + private Map householdMementos = new LinkedHashMap<>(); public HouseholdDataManagerImpl(HouseholdData householdData, DwellingData dwellingData, PersonFactory ppFactory, HouseholdFactory hhFactory, diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdUtil.java b/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdUtil.java index 4229c2a7a..78b470619 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdUtil.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/household/HouseholdUtil.java @@ -8,6 +8,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; @@ -201,7 +202,7 @@ public static void findMarriedCouple(Household hh) { } public static Map getPopulationByZoneAsMap(DataContainer dataContainer) { - Map zonePopulationMap = new HashMap<>(); + Map zonePopulationMap = new LinkedHashMap<>(); for (int zone : dataContainer.getGeoData().getZones().keySet()) { zonePopulationMap.put(zone, 0); } diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerImpl.java index 04c945045..0993cc784 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerImpl.java @@ -76,7 +76,7 @@ public JobDataManagerImpl(Properties properties, this.jobData = jobData; this.travelTimes = travelTimes; this.commutingTimeProbability = commutingTimeProbability; - this.zonalJobDensity = new HashMap<>(); + this.zonalJobDensity = new LinkedHashMap<>(); } @Override @@ -165,11 +165,11 @@ private void calculateEmploymentForecast() { private void calculateEmploymentForecastWithRate() { int year = properties.main.startYear; - Map> jobCountBaseyear = new HashMap<>(); + Map> jobCountBaseyear = new LinkedHashMap<>(); jobsByYearByZoneByIndustry.put(year, jobCountBaseyear); //initialize maps with count = 0 for (Zone zone : geoData.getZones().values()){ - Map jobsInThisZone = new HashMap<>(); + Map jobsInThisZone = new LinkedHashMap<>(); jobCountBaseyear.put(zone.getZoneId(), jobsInThisZone); for (String jobType : JobType.getJobTypes()){ jobsInThisZone.put(jobType, 0.f); @@ -185,10 +185,10 @@ private void calculateEmploymentForecastWithRate() { //forecast the following years year++; while (year <= properties.main.endYear){ - Map> jobCountThisyear = new HashMap<>(); + Map> jobCountThisyear = new LinkedHashMap<>(); jobsByYearByZoneByIndustry.put(year, jobCountThisyear); for (int zone : geoData.getZones().keySet()) { - Map jobCountThisZone = new HashMap<>(); + Map jobCountThisZone = new LinkedHashMap<>(); for (String jobType : JobType.getJobTypes()){ jobCountThisZone.put(jobType, (float)(jobCountBaseyear.get(zone).get(jobType)* Math.pow(1+properties.jobData.growthRateInPercentByJobType.get(jobType)/100,year - properties.main.startYear))); @@ -252,7 +252,7 @@ private void interpolateEmploymentForecast(){ for (int i = 0; i < yearsGiven.length - 1; i++) { nextFixedYear = Integer.parseInt(yearsGiven[i + 1]); while (interpolatedYear <= nextFixedYear) { - Map> jobsThisyear = new HashMap<>(); + Map> jobsThisyear = new LinkedHashMap<>(); jobsByYearByZoneByIndustry.put(2000 + interpolatedYear, jobsThisyear); final String forecastFileName = dir + properties.jobData.employmentForeCastFile + (2000 + interpolatedYear) + ".csv"; final PrintWriter pw = SiloUtil.openFileForSequentialWriting(forecastFileName, false); @@ -262,7 +262,7 @@ private void interpolateEmploymentForecast(){ } builder.append("\n"); for (int zone : geoData.getZones().keySet()) { - Map jobsThisZone = new HashMap<>(); + Map jobsThisZone = new LinkedHashMap<>(); jobsThisyear.put(zone, jobsThisZone); builder.append(zone); for (int jobTp = 0; jobTp < JobType.getNumberOfJobTypes(); jobTp++) { diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerWithCommuteModeChoice.java b/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerWithCommuteModeChoice.java index f1f973fe0..ebf659542 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerWithCommuteModeChoice.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobDataManagerWithCommuteModeChoice.java @@ -81,7 +81,7 @@ public JobDataManagerWithCommuteModeChoice(Properties properties, this.travelTimes = travelTimes; this.commutingTimeProbability = commutingTimeProbability; this.commuteModeChoice = commuteModeChoice; - this.zonalJobDensity = new HashMap<>(); + this.zonalJobDensity = new LinkedHashMap<>(); } @Override @@ -170,11 +170,11 @@ private void calculateEmploymentForecast() { private void calculateEmploymentForecastWithRate() { int year = properties.main.startYear; - Map> jobCountBaseyear = new HashMap<>(); + Map> jobCountBaseyear = new LinkedHashMap<>(); jobsByYearByZoneByIndustry.put(year, jobCountBaseyear); //initialize maps with count = 0 for (Zone zone : geoData.getZones().values()) { - Map jobsInThisZone = new HashMap<>(); + Map jobsInThisZone = new LinkedHashMap<>(); jobCountBaseyear.put(zone.getZoneId(), jobsInThisZone); for (String jobType : JobType.getJobTypes()) { jobsInThisZone.put(jobType, 0.f); @@ -190,10 +190,10 @@ private void calculateEmploymentForecastWithRate() { //forecast the following years year++; while (year <= properties.main.endYear) { - Map> jobCountThisyear = new HashMap<>(); + Map> jobCountThisyear = new LinkedHashMap<>(); jobsByYearByZoneByIndustry.put(year, jobCountThisyear); for (int zone : geoData.getZones().keySet()) { - Map jobCountThisZone = new HashMap<>(); + Map jobCountThisZone = new LinkedHashMap<>(); for (String jobType : JobType.getJobTypes()) { jobCountThisZone.put(jobType, (float) (jobCountBaseyear.get(zone).get(jobType) * Math.pow(1 + properties.jobData.growthRateInPercentByJobType.get(jobType) / 100, year - properties.main.startYear))); @@ -257,7 +257,7 @@ private void interpolateEmploymentForecast() { for (int i = 0; i < yearsGiven.length - 1; i++) { nextFixedYear = Integer.parseInt(yearsGiven[i + 1]); while (interpolatedYear <= nextFixedYear) { - Map> jobsThisyear = new HashMap<>(); + Map> jobsThisyear = new LinkedHashMap<>(); jobsByYearByZoneByIndustry.put(2000 + interpolatedYear, jobsThisyear); final String forecastFileName = dir + properties.jobData.employmentForeCastFile + (2000 + interpolatedYear) + ".csv"; final PrintWriter pw = SiloUtil.openFileForSequentialWriting(forecastFileName, false); @@ -267,7 +267,7 @@ private void interpolateEmploymentForecast() { } builder.append("\n"); for (int zone : geoData.getZones().keySet()) { - Map jobsThisZone = new HashMap<>(); + Map jobsThisZone = new LinkedHashMap<>(); jobsThisyear.put(zone, jobsThisZone); builder.append(zone); for (int jobTp = 0; jobTp < JobType.getNumberOfJobTypes(); jobTp++) { diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobType.java b/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobType.java index ddd184bb9..fbb28bb5a 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobType.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/job/JobType.java @@ -2,6 +2,7 @@ import java.util.HashMap; +import java.util.LinkedHashMap; /** * Job types that are distinguished in the model @@ -18,7 +19,7 @@ public class JobType { public JobType(String[] jobTypesArg) { jobTypes = jobTypesArg; - ordinal = new HashMap<>(); + ordinal = new LinkedHashMap<>(); for (int i = 0; i < jobTypes.length; i++) { ordinal.put(jobTypes[i], i); } diff --git a/siloCore/src/main/java/de/tum/bgu/msm/data/vehicle/VehicleUtil.java b/siloCore/src/main/java/de/tum/bgu/msm/data/vehicle/VehicleUtil.java index 1106a1b3d..77fc5ccf4 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/data/vehicle/VehicleUtil.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/data/vehicle/VehicleUtil.java @@ -5,11 +5,12 @@ import org.apache.commons.math3.distribution.NormalDistribution; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class VehicleUtil { - static Map probabilities = new HashMap<>(); + static Map probabilities = new LinkedHashMap<>(); public static void initializeVehicleUtils(){ final NormalDistribution normalDistribution = new NormalDistribution(4.29, 8.15); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/io/input/CoefficientsReader.java b/siloCore/src/main/java/de/tum/bgu/msm/io/input/CoefficientsReader.java index e50cc319b..472688c83 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/io/input/CoefficientsReader.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/io/input/CoefficientsReader.java @@ -5,12 +5,13 @@ import java.nio.file.Path; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class CoefficientsReader extends AbstractCsvReader{ - private final Map coefficients = new HashMap<>(); + private final Map coefficients = new LinkedHashMap<>(); private final String id; private int variableIndex; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/io/output/ModalSharesResultMonitor.java b/siloCore/src/main/java/de/tum/bgu/msm/io/output/ModalSharesResultMonitor.java index b3ce2a2ae..b8fb32076 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/io/output/ModalSharesResultMonitor.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/io/output/ModalSharesResultMonitor.java @@ -18,6 +18,7 @@ import java.io.FileNotFoundException; import java.io.PrintWriter; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; @@ -72,13 +73,13 @@ public void endYear(int year, Multiset> eventCounter logger.info("Printing out modal shares by zone"); - Map tripsByCar = new HashMap<>(); - Map tripsByPt = new HashMap<>(); - MaptripsByOther = new HashMap<>(); - Map timeByCar = new HashMap<>(); - Map timeByPt = new HashMap<>(); - Map timeByOther = new HashMap<>(); - Map doNotTravel = new HashMap<>(); + Map tripsByCar = new LinkedHashMap<>(); + Map tripsByPt = new LinkedHashMap<>(); + MaptripsByOther = new LinkedHashMap<>(); + Map timeByCar = new LinkedHashMap<>(); + Map timeByPt = new LinkedHashMap<>(); + Map timeByOther = new LinkedHashMap<>(); + Map doNotTravel = new LinkedHashMap<>(); AtomicInteger car = new AtomicInteger(); AtomicInteger pt = new AtomicInteger(); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/jobmography/JobMarketUpdateImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/jobmography/JobMarketUpdateImpl.java index b9c8e278a..f76c49dba 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/jobmography/JobMarketUpdateImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/jobmography/JobMarketUpdateImpl.java @@ -67,7 +67,7 @@ private void updateJobInventoryMultiThreadedThisYear(int year) { //TableDataSet forecast = SiloUtil.readCSVfile(forecastFileName); - Map> jobsAvailableForRemoval = new HashMap<>(); + Map> jobsAvailableForRemoval = new LinkedHashMap<>(); for (Job jj : jobDataManager.getJobs()) { String token = jj.getType() + "." + jj.getZoneId() + "." + (jj.getWorkerId() == -1); if (jobsAvailableForRemoval.containsKey(token)) { diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/modeChoice/SimpleCommuteModeChoice.java b/siloCore/src/main/java/de/tum/bgu/msm/models/modeChoice/SimpleCommuteModeChoice.java index d532966a5..824ee3b4d 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/modeChoice/SimpleCommuteModeChoice.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/modeChoice/SimpleCommuteModeChoice.java @@ -17,10 +17,7 @@ import de.tum.bgu.msm.properties.Properties; import org.matsim.api.core.v01.TransportMode; -import java.util.HashMap; -import java.util.Map; -import java.util.Random; -import java.util.TreeMap; +import java.util.*; public class SimpleCommuteModeChoice implements CommuteModeChoice { @@ -63,7 +60,7 @@ public CommuteModeChoiceMapping assignCommuteModeChoice(Location from, TravelTim CommuteModeChoiceMapping commuteModeChoiceMapping = new CommuteModeChoiceMapping(HouseholdUtil.getNumberOfWorkers(household)); - Map> commuteModesByPerson = new HashMap<>(); + Map> commuteModesByPerson = new LinkedHashMap<>(); TreeMap personByProbability = new TreeMap<>(); for (Person pp : household.getPersons().values()) { @@ -90,7 +87,7 @@ public CommuteModeChoiceMapping assignCommuteModeChoice(Location from, TravelTim ptUtility = Math.exp(ptUtility); carUtility = Math.exp(carUtility); - Map utilityByMode = new HashMap<>(); + Map utilityByMode = new LinkedHashMap<>(); utilityByMode.put(TransportMode.car, Math.pow(commutingTimeProbabilityCar, B_EXP_HOUSING_UTILITY)); utilityByMode.put(TransportMode.pt, Math.pow(commutingTimeProbabilityPt, B_EXP_HOUSING_UTILITY)); commuteModesByPerson.put(pp.getId(), utilityByMode); @@ -138,7 +135,7 @@ public CommuteModeChoiceMapping assignRegionalCommuteModeChoice(Region region, T CommuteModeChoiceMapping commuteModeChoiceMapping = new CommuteModeChoiceMapping(HouseholdUtil.getNumberOfWorkers(household)); - Map> commuteModesByPerson = new HashMap<>(); + Map> commuteModesByPerson = new LinkedHashMap<>(); TreeMap personByProbability = new TreeMap<>(); @@ -163,7 +160,7 @@ public CommuteModeChoiceMapping assignRegionalCommuteModeChoice(Region region, T job.getStartTimeInSeconds().orElse((int) properties.transportModel.peakHour_s), TransportMode.car); double commutingTimeProbabilityCar = this.commutingTimeProbability.getCommutingTimeProbability(carMinutes, TransportMode.car); double carUtility = B_TIME * commutingTimeProbabilityCar; - Map utilityByMode = new HashMap<>(); + Map utilityByMode = new LinkedHashMap<>(); utilityByMode.put(TransportMode.car, Math.pow(commutingTimeProbabilityCar, B_EXP_HOUSING_UTILITY)); utilityByMode.put(TransportMode.pt, Math.pow(commutingTimeProbabilityPt, B_EXP_HOUSING_UTILITY)); commuteModesByPerson.put(pp.getId(), utilityByMode); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/construction/ConstructionOverwriteImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/construction/ConstructionOverwriteImpl.java index db8c81c18..9fc4a6cb2 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/construction/ConstructionOverwriteImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/construction/ConstructionOverwriteImpl.java @@ -80,7 +80,7 @@ private void readOverwriteFile() { String fileName = properties.main.baseDirectory + properties.realEstate.constructionOverwriteDwellingFile; TableDataSet overwrite = SiloUtil.readCSVfile(fileName); - plannedDwellings = new HashMap<>(); + plannedDwellings = new LinkedHashMap<>(); for (int row = 1; row <= overwrite.getRowCount(); row++) { int year = (int) overwrite.getValueAt(row, "year"); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/pricing/PricingModelImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/pricing/PricingModelImpl.java index 08216d72d..99defa7ef 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/pricing/PricingModelImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/realEstate/pricing/PricingModelImpl.java @@ -11,10 +11,7 @@ import java.io.File; import java.io.PrintWriter; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Random; +import java.util.*; /** * Updates prices of dwellings based on current demand @@ -49,9 +46,9 @@ public void setup() { @Override public void prepareYear(int year) { - changeRateDistribution = new HashMap<>(); + changeRateDistribution = new LinkedHashMap<>(); for (DwellingType type : dataContainer.getRealEstateDataManager().getDwellingTypes().getTypes()) { - changeRateDistribution.put(type, new HashMap<>()); + changeRateDistribution.put(type, new LinkedHashMap<>()); } } @@ -78,7 +75,7 @@ private void updateRealEstatePrices(int year) { // get vacancy rate double[][] vacRate = dataContainer.getRealEstateDataManager().getVacancyRateByTypeAndRegion(); List dwellingTypes = dataContainer.getRealEstateDataManager().getDwellingTypes().getTypes(); -// HashMap priceChange = new HashMap<>(); +// HashMap priceChange = new LinkedHashMap<>(); double[] globalVacRate = dataContainer.getRealEstateDataManager().getAverageVacancyByDwellingType(); int[] cnt = new int[dwellingTypes.size()]; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarAndTransitHousingStrategyImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarAndTransitHousingStrategyImpl.java index 9a4fd6583..698d39563 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarAndTransitHousingStrategyImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarAndTransitHousingStrategyImpl.java @@ -27,6 +27,7 @@ import java.util.EnumMap; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; @@ -233,7 +234,7 @@ private void calculateRegionalUtilities() { logger.info("Calculating regional utilities"); final Map rentsByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); for (IncomeCategory incomeCategory : IncomeCategory.values()) { - Map utilityByRegion = new HashMap<>(); + Map utilityByRegion = new LinkedHashMap<>(); for (Region region : geoData.getRegions().values()) { final int averageRegionalRent = rentsByRegion.get(region.getId()).intValue(); final float regAcc = (float) convertAccessToUtility(accessibility.getRegionalAccessibility(region)); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarOnlyHousingStrategyImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarOnlyHousingStrategyImpl.java index 0fb06c27a..9ebf4e791 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarOnlyHousingStrategyImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/CarOnlyHousingStrategyImpl.java @@ -25,6 +25,7 @@ import java.util.EnumMap; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; @@ -206,7 +207,7 @@ private void calculateRegionalUtilities() { logger.info("Calculating regional utilities"); final Map rentsByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); for (IncomeCategory incomeCategory : IncomeCategory.values()) { - Map utilityByRegion = new HashMap<>(); + Map utilityByRegion = new LinkedHashMap<>(); for (Region region : geoData.getRegions().values()) { final int averageRegionalRent = rentsByRegion.get(region.getId()).intValue(); final float regAcc = (float) convertAccessToUtility(accessibility.getRegionalAccessibility(region)); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java index 35b43572f..72c6a7fa7 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java @@ -55,8 +55,8 @@ public class MovesModelImpl extends AbstractModel implements MovesModel { private final Map averageHousingSatisfaction = new ConcurrentHashMap<>(); private final Map satisfactionByHousehold = new ConcurrentHashMap<>(); - private final Map householdsByZone = new HashMap<>(); - private final Map sumOfSatisfactionsByZone = new HashMap<>(); + private final Map householdsByZone = new LinkedHashMap<>(); + private final Map sumOfSatisfactionsByZone = new LinkedHashMap<>(); private YearByYearCsvModelTracker relocationTracker; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteHousingStrategyWithoutCarOwnership.java b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteHousingStrategyWithoutCarOwnership.java index 90349076a..1322307ed 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteHousingStrategyWithoutCarOwnership.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteHousingStrategyWithoutCarOwnership.java @@ -24,6 +24,7 @@ import java.util.EnumMap; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; @@ -218,7 +219,7 @@ private void calculateRegionalUtilities() { logger.info("Calculating regional utilities"); final Map rentsByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); for (IncomeCategory incomeCategory : IncomeCategory.values()) { - Map utilityByRegion = new HashMap<>(); + Map utilityByRegion = new LinkedHashMap<>(); for (Region region : geoData.getRegions().values()) { final int averageRegionalRent = rentsByRegion.get(region.getId()).intValue(); final float regAcc = (float) convertAccessToUtility(accessibility.getRegionalAccessibility(region)); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteModeChoiceHousingStrategyImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteModeChoiceHousingStrategyImpl.java index a98e9cd42..48a4b16b0 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteModeChoiceHousingStrategyImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/SimpleCommuteModeChoiceHousingStrategyImpl.java @@ -23,10 +23,7 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import java.util.Collections; -import java.util.EnumMap; -import java.util.HashMap; -import java.util.Map; +import java.util.*; import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; @@ -219,7 +216,7 @@ private void calculateRegionalUtilities() { logger.info("Calculating regional utilities"); final Map rentsByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); for (IncomeCategory incomeCategory : IncomeCategory.values()) { - Map utilityByRegion = new HashMap<>(); + Map utilityByRegion = new LinkedHashMap<>(); for (Region region : geoData.getRegions().values()) { final int averageRegionalRent = rentsByRegion.get(region.getId()).intValue(); final float regAcc = (float) convertAccessToUtility(accessibility.getRegionalAccessibility(region)); diff --git a/siloCore/src/main/java/de/tum/bgu/msm/properties/PropertiesUtil.java b/siloCore/src/main/java/de/tum/bgu/msm/properties/PropertiesUtil.java index 256c43767..5d21fff28 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/properties/PropertiesUtil.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/properties/PropertiesUtil.java @@ -15,7 +15,7 @@ private PropertiesUtil(){ private final static String FORMAT = "%-60s%s"; private final static String FORMAT_DEFAULT = "%-80s%s"; - private final static Map propertiesInUse = new HashMap<>(); + private final static Map propertiesInUse = new LinkedHashMap<>(); private final static Logger logger = LogManager.getLogger(PropertiesUtil.class); public static int getIntProperty(ResourceBundle bundle, String key, int defaultValue) { diff --git a/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/JobDataProperties.java b/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/JobDataProperties.java index f74fe92aa..a78806baf 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/JobDataProperties.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/properties/modules/JobDataProperties.java @@ -3,6 +3,7 @@ import de.tum.bgu.msm.properties.PropertiesUtil; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.ResourceBundle; @@ -15,7 +16,7 @@ public final class JobDataProperties { public final JobForecastMethod jobForecastMethod; public final String jobControlTotalsFileName; public final String employmentForeCastFile; - public final Map growthRateInPercentByJobType = new HashMap<>(); + public final Map growthRateInPercentByJobType = new LinkedHashMap<>(); public final String jobStartTimeDistributionFile; public final String jobDurationDistributionFile; diff --git a/siloCore/src/main/java/de/tum/bgu/msm/utils/DeferredAcceptanceMatching.java b/siloCore/src/main/java/de/tum/bgu/msm/utils/DeferredAcceptanceMatching.java index f7cd70e16..a2559810e 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/utils/DeferredAcceptanceMatching.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/utils/DeferredAcceptanceMatching.java @@ -19,8 +19,8 @@ private static Map iteration(Collection set, Collection set2, DoubleMatrix2D preferences) { - Map matches = new HashMap<>(); - Map>> offers = new HashMap<>(); + Map matches = new LinkedHashMap<>(); + Map>> offers = new LinkedHashMap<>(); for (int id: set) { double[] max = preferences.viewRow(id).getMaxLocation(); if (offers.containsKey((int) max[1])) { diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/CoefficientsReader.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/CoefficientsReader.java index e7106b009..e391edf8e 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/CoefficientsReader.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/CoefficientsReader.java @@ -6,12 +6,13 @@ import java.nio.file.Path; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class CoefficientsReader extends AbstractCsvReader { - private final Map coefficients = new HashMap<>(); + private final Map coefficients = new LinkedHashMap<>(); private final String id; private int variableIndex; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/austin/SyntheticPopUs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/austin/SyntheticPopUs.java index 910f29275..2a4da19cc 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/austin/SyntheticPopUs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/austin/SyntheticPopUs.java @@ -153,7 +153,7 @@ public void runSP () { private void identifyUniquePUMAzones() { // walk through list of zones and collect unique PUMA zone IDs within the study area - tazByPuma = new HashMap<>(); + tazByPuma = new LinkedHashMap<>(); ArrayList alHomePuma = new ArrayList<>(); ArrayList alWorkPuma = new ArrayList<>(); for (Zone zone: geoData.getZones().values()) { @@ -184,7 +184,7 @@ private void readControlTotals () { logger.info(" Reading control total data for households and dwellings"); // TableDataSet pop = SiloUtil.readCSVfile(Properties.get().main.baseDirectory + ResourceUtil.getProperty(rb, PROPERTIES_HOUSEHOLD_CONTROL_TOTAL)); - householdTarget = new HashMap<>(); + householdTarget = new LinkedHashMap<>(); // for (int row = 1; row <= pop.getRowCount(); row++) { // String fips = String.valueOf(pop.getValueAt(row, "Fips")); // // note: doesn't make much sense to store these data in a HashMap. It's legacy code. @@ -206,7 +206,7 @@ private void createJobs () { // jobInventory by [industry][taz] final int highestZoneId = geoData.getZones().keySet().stream().max(Comparator.naturalOrder()).get(); float[][] jobInventory = new float[JobType.getNumberOfJobTypes()][highestZoneId + 1]; - tazByWorkZonePuma = new HashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined + tazByWorkZonePuma = new LinkedHashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined // read employment data // For reasons that are not explained in the documentation, some of the PUMA work zones were aggregated to the @@ -250,7 +250,7 @@ private void identifyVacantJobsByZone () { // populate HashMap with Jobs by zone logger.info(" Identifying vacant jobs by zone"); - vacantJobsByZone = new HashMap<>(); + vacantJobsByZone = new LinkedHashMap<>(); Collection jobs = jobData.getJobs(); for (Job jj: jobs) { if (jj.getWorkerId() == -1) { @@ -285,11 +285,11 @@ private void processPums() { String[] states = {"tx"}; - jobErrorCounter = new HashMap<>(); + jobErrorCounter = new LinkedHashMap<>(); for (String state : states) { - Map relationsHipsByPerson = new HashMap<>(); - Map> households = new HashMap<>(); + Map relationsHipsByPerson = new LinkedHashMap<>(); + Map> households = new LinkedHashMap<>(); String pumsHhFileName = baseDirectory + ResourceUtil.getProperty(rb, PROPERTIES_PUMS_FILES) + "ss17h" + state + ".csv"; @@ -790,7 +790,7 @@ private int selectWorkplaceByTripLengthFrequencyDistribution (int workPumaZone, return -2; // person does work in puma zone outside of study area } - Map zoneProbabilities = new HashMap<>(); + Map zoneProbabilities = new LinkedHashMap<>(); for (Zone zone: geoData.getZones().values()) { if (vacantJobsByZone.containsKey(zone.getZoneId())) { int numberOfJobsInThisZone = vacantJobsByZone.get(zone.getZoneId()).length; @@ -951,7 +951,7 @@ private void generateAutoOwnership (DataContainer dataContainer) { // select number of cars for every household dataContainer.getJobDataManager().setup(); MaryLandUpdateCarOwnershipModel ao = new MaryLandUpdateCarOwnershipModel(dataContainer, accessibility, Properties.get(), SiloUtil.provideNewRandom()); // calculate auto-ownership probabilities - Map households = new HashMap<>(); + Map households = new LinkedHashMap<>(); for (Household hh: householdData.getHouseholds()) { households.put(hh.getId(), null); } @@ -964,7 +964,7 @@ private void addVacantDwellings () { logger.info(" Adding empty dwellings to match vacancy rate"); List dwellingTypes = realEstateData.getDwellingTypes().getTypes(); - HashMap> ddPointer = new HashMap<>(); + HashMap> ddPointer = new LinkedHashMap<>(); // summarize vacancy final int highestZoneId = geoData.getZones().keySet().stream().max(Comparator.naturalOrder()).get(); int[][][] ddCount = new int [highestZoneId + 1][DefaultDwellingTypes.DefaultDwellingTypeImpl.values().length][2]; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/Allocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/Allocation.java index 7e78ee487..4107cf2e5 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/Allocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/Allocation.java @@ -58,7 +58,7 @@ public void run(){ } public void generateHouseholdsPersonsDwellings(){ - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new GenerateHouseholdsPersonsDwellings(dataContainer, dataSetSynPop, educationalLevel).run(); } @@ -77,7 +77,7 @@ public void assignSchools(){ public void generateAutos() {new CarOwnership(dataContainer).run();} public void readPopulation(){ - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new ReadPopulation(dataContainer, educationalLevel).run(); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignJobs.java index 3bbc8bac9..2ab95ce3c 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignJobs.java @@ -138,18 +138,18 @@ private void identifyVacantJobsByZoneType() { Collection jobs = dataContainer.getJobDataManager().getJobs(); jobStringTypes = PropertiesSynPop.get().main.jobStringType; - jobIntTypes = new HashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++) { jobIntTypes.put(PropertiesSynPop.get().main.jobStringType[i], i); } tazIds = dataSetSynPop.getTazs().stream().mapToInt(i -> i).toArray(); - idVacantJobsByZoneType = new HashMap<>(); - numberVacantJobsByType = new HashMap<>(); - idZonesVacantJobsByType = new HashMap<>(); - numberZonesByType = new HashMap<>(); - numberVacantJobsByZoneByType = new HashMap<>(); - jobIntTypes = new HashMap<>(); + idVacantJobsByZoneType = new LinkedHashMap<>(); + numberVacantJobsByType = new LinkedHashMap<>(); + idZonesVacantJobsByType = new LinkedHashMap<>(); + numberZonesByType = new LinkedHashMap<>(); + numberVacantJobsByZoneByType = new LinkedHashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++) { jobIntTypes.put(PropertiesSynPop.get().main.jobStringType[i], i); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignSchools.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignSchools.java index 69cff8521..241bd1c9d 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignSchools.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/AssignSchools.java @@ -95,7 +95,7 @@ private int selectTertiarySchool(int hometaz){ int schooltaz = -2; if (numberOfVacantPlacesByType.get(3) > 0) { - Map probability = new HashMap<>(); + Map probability = new LinkedHashMap<>(); Iterator iterator = schoolCapacityMap.get(3).keySet().iterator(); while (iterator.hasNext()) { Integer zone = iterator.next(); @@ -159,8 +159,8 @@ private void shuffleStudents(){ private void initializeSchoolCapacity(){ - schoolCapacityMap = new HashMap<>(); - numberOfVacantPlacesByType = new HashMap<>(); + schoolCapacityMap = new LinkedHashMap<>(); + numberOfVacantPlacesByType = new LinkedHashMap<>(); Table schoolCapacity = dataSetSynPop.getSchoolCapacity(); Iterator iteratorRow = schoolCapacity.rowKeySet().iterator(); while (iteratorRow.hasNext()){ @@ -170,7 +170,7 @@ private void initializeSchoolCapacity(){ int schoolType = iteratorCol.next(); int places = schoolCapacity.get(zone, schoolType); if (places > 0) { - Map prevPlaces = new HashMap<>(); + Map prevPlaces = new LinkedHashMap<>(); if (schoolCapacityMap.get(schoolType)!= null) { prevPlaces = schoolCapacityMap.get(schoolType); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateHouseholdsPersonsDwellings.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateHouseholdsPersonsDwellings.java index edf4605e8..4cdb0a467 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateHouseholdsPersonsDwellings.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateHouseholdsPersonsDwellings.java @@ -183,9 +183,9 @@ private void recalculateIncomeAndDwellingPrice(int municipality) { double averageIncomeByZoneCensus = PropertiesSynPop.get().main.cellsMatrix.getIndexedValueAt(municipality, "income"); double averageIncomeZone = incomeByMunicipality / personCounterByMunicipality; double incomeMultiplier = averageIncomeByZoneCensus / averageIncomeZone; - Map householdMap = new HashMap<>(); - Map dwellingMap = new HashMap<>(); - Map personMap = new HashMap<>(); + Map householdMap = new LinkedHashMap<>(); + Map dwellingMap = new LinkedHashMap<>(); + Map personMap = new LinkedHashMap<>(); int ppHumber = 0; for (int hhNumber = 0; hhNumber < totalHouseholds; hhNumber++){ Household hh = householdData.getHouseholdFromId(hhNumber + firstHouseholdMunicipality); @@ -288,13 +288,13 @@ private int guessIncome(int age, int occupationCode, Occupation occupation, Gend return 0; //student } else { - Map expUtilities = new HashMap<>(); + Map expUtilities = new LinkedHashMap<>(); expUtilities.put(1, 1.0); for (int incomeCat = 2; incomeCat < 10; incomeCat++){ expUtilities.put(incomeCat, Math.exp(calculateUtilityForIncome(incomeCat, age, occupation, gender))); } double denominator = expUtilities.values().stream().mapToDouble(Double::doubleValue).sum(); - Map probabilities = new HashMap<>(); + Map probabilities = new LinkedHashMap<>(); expUtilities.forEach((x,y)-> probabilities.put(x,y/denominator)); int incomeCat = SiloUtil.select(probabilities); int income = (int) PropertiesSynPop.get().main.incomeCoefficients.getValueAt(incomeCat, "averageIncome"); @@ -438,7 +438,7 @@ private void initializeMunicipalityData(int municipality){ logger.info(" Municipality " + municipality + ". Starting to generate households and persons"); totalHouseholds = (int) PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, "households"); - probMicroData = new HashMap<>(); + probMicroData = new LinkedHashMap<>(); probabilityId = new double[dataSetSynPop.getWeights().getRowCount()]; ids = new int[probabilityId.length]; sumProbabilities = 0; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateJobs.java index 297581493..6d30095bf 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateJobs.java @@ -10,6 +10,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateJobs { @@ -58,7 +59,7 @@ private void generateJobsByTypeAtMunicipalityWithReplacement(int municipality, S private void initializeTAZprobability(int municipality, String jobType){ - jobsByTaz = new HashMap<>(); + jobsByTaz = new LinkedHashMap<>(); jobsByTaz.clear(); for (int taz : dataSetSynPop.getTazByMunicipality().get(municipality)){ jobsByTaz.put(taz, (float) Math.round(PropertiesSynPop.get().main.cellsMatrix.getIndexedValueAt(taz, jobType) * PropertiesSynPop.get().main.jobScaler)); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateVacantDwellings.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateVacantDwellings.java index 1dca1b3e2..6b57795d2 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateVacantDwellings.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/allocation/GenerateVacantDwellings.java @@ -29,7 +29,7 @@ public class GenerateVacantDwellings { private int highestDwellingIdInUse; private final DataContainer dataContainer; private RealEstateDataManager realEstateData; - private Map> occupiedDwellings = new HashMap<>(); + private Map> occupiedDwellings = new LinkedHashMap<>(); public GenerateVacantDwellings(DataContainer dataContainer, DataSetSynPop dataSetSynPop){ @@ -103,11 +103,11 @@ private void generateVacantDwellings(){ private void initializeVacantDwellingData(int municipality){ - probVacantFloor = new HashMap<>(); + probVacantFloor = new LinkedHashMap<>(); for (int floor : PropertiesSynPop.get().main.sizeBracketsDwelling) { probVacantFloor.put(floor, PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, "vacantDwellings" + floor)); } - probVacantBuildingSize = new HashMap<>(); + probVacantBuildingSize = new LinkedHashMap<>(); for (int year : PropertiesSynPop.get().main.yearBracketsDwelling){ int sizeYear = year; String label = "vacantSmallDwellings" + year; @@ -144,13 +144,13 @@ private void updateQualityMap(int municipality, int year, int quality){ } ddQuality.put(key, qualities); } else { - Map qualities = new HashMap<>(); + Map qualities = new LinkedHashMap<>(); qualities.put(quality, 1f); ddQuality.put(key, qualities); } } else { - ddQuality = new HashMap<>(); - Map qualities = new HashMap<>(); + ddQuality = new LinkedHashMap<>(); + Map qualities = new LinkedHashMap<>(); qualities.put(quality, 1f); ddQuality.put(key, qualities); } @@ -223,7 +223,7 @@ private DwellingType extractDwellingType (int buildingYear, float ddType1Prob, f private int selectQualityVacant(int municipality, int year){ int result = 0; if (ddQuality.get(year * 10000000 + municipality) == null) { - HashMap qualities = new HashMap<>(); + HashMap qualities = new LinkedHashMap<>(); for (int quality = 1; quality <= PropertiesSynPop.get().main.numberofQualityLevels; quality++){ qualities.put(quality, 1f); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateDwellingMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateDwellingMicrolocation.java index f129a76bc..a32f3f0bd 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateDwellingMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateDwellingMicrolocation.java @@ -12,6 +12,7 @@ import java.util.Collection; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateDwellingMicrolocation { @@ -20,13 +21,13 @@ public class GenerateDwellingMicrolocation { private static final double PENALTY = 0.5; private final DataContainer dataContainer; private final DataSetSynPop dataSetSynPop; - private HashMap buildingX = new HashMap<>(); - private HashMap buildingY = new HashMap<>(); - private HashMap> zoneBuildingMap = new HashMap<>(); - Map buildingZone = new HashMap(); - Map buildingArea = new HashMap<>(); - Map zoneDensity = new HashMap<>(); - Map dwellingsInTAZ = new HashMap(); + private HashMap buildingX = new LinkedHashMap<>(); + private HashMap buildingY = new LinkedHashMap<>(); + private HashMap> zoneBuildingMap = new LinkedHashMap<>(); + Map buildingZone = new LinkedHashMap(); + Map buildingArea = new LinkedHashMap<>(); + Map zoneDensity = new LinkedHashMap<>(); + Map dwellingsInTAZ = new LinkedHashMap(); public GenerateDwellingMicrolocation(DataContainer dataContainer, DataSetSynPop dataSetSynPop){ this.dataSetSynPop = dataSetSynPop; @@ -79,7 +80,7 @@ private void readBuidlingFile() { buildingZone.put(id,zone); //put all buildings with the same zoneID into one building list if (zoneBuildingMap.get(zone) == null){ - HashMap buildingAreaList = new HashMap(); + HashMap buildingAreaList = new LinkedHashMap(); zoneBuildingMap.put(zone,buildingAreaList); } zoneBuildingMap.get(zone).put(id,area); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateJobMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateJobMicrolocation.java index 6aacfe06d..516b6718c 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateJobMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateJobMicrolocation.java @@ -13,6 +13,7 @@ import java.util.Collection; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateJobMicrolocation { @@ -21,12 +22,12 @@ public class GenerateJobMicrolocation { private final DataContainer dataContainer; private final DataSetSynPop dataSetSynPop; - private Map jobX = new HashMap<>(); - private Map jobY = new HashMap<>(); - Map jobZone = new HashMap(); - Map>> zoneJobTypeJobLocationArea = new HashMap<>(); - Map> zoneJobTypeDensity = new HashMap<>(); - Map> jobsByJobTypeInTAZ = new HashMap<>(); + private Map jobX = new LinkedHashMap<>(); + private Map jobY = new LinkedHashMap<>(); + Map jobZone = new LinkedHashMap(); + Map>> zoneJobTypeJobLocationArea = new LinkedHashMap<>(); + Map> zoneJobTypeDensity = new LinkedHashMap<>(); + Map> jobsByJobTypeInTAZ = new LinkedHashMap<>(); public GenerateJobMicrolocation(DataContainer dataContainer, DataSetSynPop dataSetSynPop){ this.dataSetSynPop = dataSetSynPop; @@ -68,9 +69,9 @@ public void run() { private void readJobFile() { for (int zone : dataSetSynPop.getTazs()){ - Map> jobLocationListForThisJobType = new HashMap<>(); + Map> jobLocationListForThisJobType = new LinkedHashMap<>(); for (String jobType : PropertiesSynPop.get().main.jobStringType){ - Map jobLocationAndArea = new HashMap<>(); + Map jobLocationAndArea = new LinkedHashMap<>(); jobLocationListForThisJobType.put(jobType,jobLocationAndArea); } zoneJobTypeJobLocationArea.put(zone,jobLocationListForThisJobType); @@ -115,8 +116,8 @@ private void readJobFile() { private void calculateDensity() { for (int zone : dataSetSynPop.getTazs()){ - Map jobsByJobType = new HashMap<>(); - Map densityByJobType = new HashMap<>(); + Map jobsByJobType = new LinkedHashMap<>(); + Map densityByJobType = new LinkedHashMap<>(); jobsByJobTypeInTAZ.put(zone,jobsByJobType); zoneJobTypeDensity.put(zone,densityByJobType); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateSchoolMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateSchoolMicrolocation.java index 1519996df..6fb05edba 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateSchoolMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/GenerateSchoolMicrolocation.java @@ -16,6 +16,7 @@ import org.locationtech.jts.geom.Coordinate; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateSchoolMicrolocation { @@ -24,7 +25,7 @@ public class GenerateSchoolMicrolocation { private final DataContainerWithSchools dataContainer; private final DataSetSynPop dataSetSynPop; - Map>> zoneSchoolTypeSchoolLocationCapacity = new HashMap<>(); + Map>> zoneSchoolTypeSchoolLocationCapacity = new LinkedHashMap<>(); public GenerateSchoolMicrolocation(DataContainerWithSchools dataContainer, DataSetSynPop dataSetSynPop){ @@ -74,9 +75,9 @@ public void run() { private void createSchools() { for (int zone : dataSetSynPop.getTazs()){ - Map> schoolLocationListForThisSchoolType = new HashMap<>(); + Map> schoolLocationListForThisSchoolType = new LinkedHashMap<>(); for (int type = 1 ; type <= 3; type++){ - Map schoolCapacity = new HashMap<>(); + Map schoolCapacity = new LinkedHashMap<>(); schoolLocationListForThisSchoolType.put(type,schoolCapacity); } zoneSchoolTypeSchoolLocationCapacity.put(zone,schoolLocationListForThisSchoolType); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/Microlocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/Microlocation.java index 6511e66d2..750b9c945 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/Microlocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/microlocation/Microlocation.java @@ -14,6 +14,7 @@ import org.matsim.core.utils.gis.ShapeFileReader; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class Microlocation extends ModuleSynPop { @@ -30,7 +31,7 @@ public void run(){ logger.info(" Started microlocation model."); String zoneShapeFile = Properties.get().geo.zoneShapeFile; - Map zoneFeatureMap = new HashMap<>(); + Map zoneFeatureMap = new LinkedHashMap<>(); for (SimpleFeature feature: ShapeFileReader.getAllFeatures(zoneShapeFile)) { int zoneId = Integer.parseInt(feature.getAttribute("ZONE").toString()); zoneFeatureMap.put(zoneId,feature); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/CheckHouseholdRelationship.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/CheckHouseholdRelationship.java index 79267ad30..ab1641926 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/CheckHouseholdRelationship.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/CheckHouseholdRelationship.java @@ -8,6 +8,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class CheckHouseholdRelationship { @@ -576,11 +577,11 @@ private void initialize(){ SiloUtil.addIntegerColumnToTableDataSet(microDataPerson, "rearrangedRole"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold,"nonClassifiedMales"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold, "nonClassifiedFemales"); - childrenInHousehold = new HashMap<>(); - noClass = new HashMap<>(); - singles = new HashMap<>(); - married = new HashMap<>(); - headCouple = new HashMap<>(); + childrenInHousehold = new LinkedHashMap<>(); + noClass = new LinkedHashMap<>(); + singles = new LinkedHashMap<>(); + married = new LinkedHashMap<>(); + headCouple = new LinkedHashMap<>(); } @@ -600,7 +601,7 @@ private HashMap> updateInnerMap(HashMap inner = outer.get(key); if (inner == null){ - inner = new HashMap(); + inner = new LinkedHashMap(); outer.put(key, inner); } inner.put(row, age); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/ReadZonalData.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/ReadZonalData.java index 04f5aa833..4e0fc8062 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/ReadZonalData.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/bangkok/preparation/ReadZonalData.java @@ -15,6 +15,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class ReadZonalData { @@ -42,7 +43,7 @@ private void readCities() { //List of municipalities and counties that are used for IPU and allocation ArrayList municipalities = new ArrayList<>(); ArrayList counties = new ArrayList<>(); - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); ArrayList municipalitiesWithZero = new ArrayList<>(); for (int row = 1; row <= PropertiesSynPop.get().main.selectedMunicipalities.getRowCount(); row++) { if (PropertiesSynPop.get().main.selectedMunicipalities.getValueAt(row, "Select") == 1f) { @@ -69,13 +70,13 @@ private void readCities() { private void readZones(){ //TAZ attributes - HashMap cityTAZ = new HashMap<>(); - Map> probabilityZone = new HashMap<>(); + HashMap cityTAZ = new LinkedHashMap<>(); + Map> probabilityZone = new LinkedHashMap<>(); Table schoolCapacity = HashBasedTable.create(); ArrayList tazs = new ArrayList<>(); ArrayList areas = new ArrayList<>(); TableDataSet zoneAttributes = PropertiesSynPop.get().main.cellsMatrix; - HashMap> attributesZone = new HashMap<>(); + HashMap> attributesZone = new LinkedHashMap<>(); for (int i = 1; i <= zoneAttributes.getRowCount(); i++){ int city = (int) zoneAttributes.getValueAt(i,"ID_city"); @@ -94,11 +95,11 @@ private void readZones(){ tazs.add(taz); int[] previousTaz = {taz}; cityTAZ.put(city,previousTaz); - Map probabilities = new HashMap<>(); + Map probabilities = new LinkedHashMap<>(); probabilities.put(taz, probability); probabilityZone.put(city, probabilities); schoolCapacity.put(taz,1, (int) (capacitySchool * ratioJobs)); - HashMap Attributes = new HashMap<>(); + HashMap Attributes = new LinkedHashMap<>(); Attributes.put("percentageVacantDwelings", percentageVacantDwellings); Attributes.put("income", averageIncome); Attributes.put("households", households); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCT.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCT.java index 92487e565..bdc12e45d 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCT.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCT.java @@ -204,14 +204,14 @@ // // String fileName = "input/syntheticPopulation/variablesCTDictionary.csv"; // -// attributeCodeValues = new HashMap<>(); -// attributesControlTotal = new HashMap<>(); -// attributesMicroPerson = new HashMap<>(); -// attributesMicroHousehold = new HashMap<>(); -// attributeCodeToControlTotal = new HashMap<>(); -// attributeCodeToMicroPerson = new HashMap<>(); -// attributeCodeToMicroHousehold = new HashMap<>(); -// HashMap attributeOrder = new HashMap<>(); +// attributeCodeValues = new LinkedHashMap<>(); +// attributesControlTotal = new LinkedHashMap<>(); +// attributesMicroPerson = new LinkedHashMap<>(); +// attributesMicroHousehold = new LinkedHashMap<>(); +// attributeCodeToControlTotal = new LinkedHashMap<>(); +// attributeCodeToMicroPerson = new LinkedHashMap<>(); +// attributeCodeToMicroHousehold = new LinkedHashMap<>(); +// HashMap attributeOrder = new LinkedHashMap<>(); // // String recString = ""; // int recCount = 0; @@ -320,7 +320,7 @@ // TableDataSet selectedMunicipalities = SiloUtil.readCSVfile(rb.getString(PROPERTIES_SELECTED_MUNICIPALITIES_LIST)); //TableDataSet with all municipalities // municipalities = new ArrayList<>(); // counties = new ArrayList<>(); -// municipalitiesByCounty = new HashMap<>(); +// municipalitiesByCounty = new LinkedHashMap<>(); // for (int row = 1; row <= selectedMunicipalities.getRowCount(); row++){ // if (selectedMunicipalities.getValueAt(row,"Select") == 1f){ // int city = (int) selectedMunicipalities.getValueAt(row,"ID_city"); @@ -347,7 +347,7 @@ // //TAZ attributes // cellsMatrix = SiloUtil.readCSVfile(rb.getString(PROPERTIES_RASTER_CELLS)); // cellsMatrix.buildIndex(cellsMatrix.getColumnPosition("ID_cell")); -// cityTAZ = new HashMap<>(); +// cityTAZ = new LinkedHashMap<>(); // for (int i = 1; i <= cellsMatrix.getRowCount(); i++){ // int city = (int) cellsMatrix.getValueAt(i,"ID_city"); // int taz = (int) cellsMatrix.getValueAt(i,"ID_cell"); @@ -511,8 +511,8 @@ // private void readPersons() { // // String fileName = "input/syntheticPopulation/newPersons.csv"; -// personsInHouseholds = new HashMap<>(); -// HashMap> noDatas = new HashMap<>(); +// personsInHouseholds = new LinkedHashMap<>(); +// HashMap> noDatas = new LinkedHashMap<>(); // // String recString = ""; // int recCount = 0; @@ -524,7 +524,7 @@ // String[] header = recString.split(","); // int posHhId = SiloUtil.findPositionInArray("new$X.x", header); // int posId = SiloUtil.findPositionInArray("X.y",header); -// HashMap positionAttribute = new HashMap<>(); +// HashMap positionAttribute = new LinkedHashMap<>(); // for (int i = 0; i < microPersonAttributes.length; i++){ // positionAttribute.put(microPersonAttributes[i], SiloUtil.findPositionInArray(microPersonAttributes[i], header)); // } @@ -536,7 +536,7 @@ // int idHh = Integer.parseInt(lineElements[posHhId]); // Integer id = Integer.parseInt(lineElements[posId]); // recCount++; -// HashMap attributeMap = new HashMap<>(); +// HashMap attributeMap = new LinkedHashMap<>(); // attributeMap.put("hhId", idHh); // boolean allData = true; // for (int i = 0; i < microPersonAttributes.length; i++){ @@ -598,7 +598,7 @@ // // String fileName = "input/syntheticPopulation/newHouseholds.csv"; // -// households = new HashMap<>(); +// households = new LinkedHashMap<>(); // String recString = ""; // int recCount = 0; // try { @@ -608,7 +608,7 @@ // // read header // String[] header = recString.split(","); // int posId = SiloUtil.findPositionInArray("X.x", header); -// HashMap positionAttribute = new HashMap<>(); +// HashMap positionAttribute = new LinkedHashMap<>(); // for (Map.Entry pairCode : attributeCodeToMicroHousehold.entrySet()){ // String attributeMicro = pairCode.getValue(); // positionAttribute.put(attributeMicro, SiloUtil.findPositionInArray(attributeMicro, header)); @@ -619,7 +619,7 @@ // recCount++; // String[] lineElements = recString.split(","); // int idhH = Integer.parseInt(lineElements[posId]); -// HashMap attributeMap = new HashMap<>(); +// HashMap attributeMap = new LinkedHashMap<>(); // for (Map.Entry pairCode : attributeCodeToMicroHousehold.entrySet()){ // String attribute = pairCode.getKey(); // String attributeMicro = pairCode.getValue(); @@ -805,10 +805,10 @@ // } else { // // //Create the maps to store the classified members of the households -// HashMap childrenInHousehold = new HashMap<>(); -// HashMap> noClass = new HashMap<>(); -// HashMap> singles = new HashMap<>(); -// HashMap> married = new HashMap<>(); +// HashMap childrenInHousehold = new LinkedHashMap<>(); +// HashMap> noClass = new LinkedHashMap<>(); +// HashMap> singles = new LinkedHashMap<>(); +// HashMap> married = new LinkedHashMap<>(); // // //direct classification of the members of the household // for (int j = 0; j < hhSize; j++) { @@ -1054,13 +1054,13 @@ // municipalities = municipalitiesByCounty.get(county); // // //weights, values, control totals -// Map weightsByMun = Collections.synchronizedMap(new HashMap<>()); -// Map minWeightsByMun = Collections.synchronizedMap(new HashMap<>()); -// Map valuesByHousehold = Collections.synchronizedMap(new HashMap<>()); -// Map totalCounty = Collections.synchronizedMap(new HashMap<>()); -// Map> totalMunicipality = Collections.synchronizedMap(new HashMap<>()); -// Map> errorByMun = Collections.synchronizedMap(new HashMap<>()); -// Map errorByRegion = Collections.synchronizedMap(new HashMap<>()); +// Map weightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); +// Map minWeightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); +// Map valuesByHousehold = Collections.synchronizedMap(new LinkedHashMap<>()); +// Map totalCounty = Collections.synchronizedMap(new LinkedHashMap<>()); +// Map> totalMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); +// Map> errorByMun = Collections.synchronizedMap(new LinkedHashMap<>()); +// Map errorByRegion = Collections.synchronizedMap(new LinkedHashMap<>()); // double weightedSum0 = 0f; // // //parameters of the IPU @@ -1109,10 +1109,10 @@ // inner1.put(attribute, 0.); // errorByMun.put(municipality, inner1); // } else { -// HashMap inner = new HashMap<>(); +// HashMap inner = new LinkedHashMap<>(); // inner.put(attribute, (int) marginalsMunicipality.getIndexedValueAt(municipality, attribute)); // totalMunicipality.put(municipality, inner); -// HashMap inner1 = new HashMap<>(); +// HashMap inner1 = new LinkedHashMap<>(); // inner1.put(attribute, 0.); // errorByMun.put(municipality, inner1); // } @@ -1177,7 +1177,7 @@ // Iterator iterator1 = municipalities.iterator(); // while (iterator1.hasNext()){ // Integer municipality = iterator1.next(); -// Map errorsByMunicipality = Collections.synchronizedMap(new HashMap<>()); +// Map errorsByMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); // executor1.addTaskToQueue(() ->{ // for (String attribute : attributesMunicipality){ // double weightedSumMunicipality = SiloUtil.sumProduct(weightsByMun.get(municipality), valuesByHousehold.get(attribute)); @@ -1833,11 +1833,11 @@ // // //Driver license probability // TableDataSet probabilityDriverLicense = SiloUtil.readCSVfile("input/syntheticPopulation/driverLicenseProb.csv"); -// educationalLevelByPerson = new HashMap<>(); +// educationalLevelByPerson = new LinkedHashMap<>(); // generateCountersForValidation(); // // //Create hashmaps to store quality of occupied dwellings -// HashMap ddQuality = new HashMap<>(); +// HashMap ddQuality = new LinkedHashMap<>(); // numberofQualityLevels = ResourceUtil.getIntegerProperty(rb, PROPERTIES_NUMBER_OF_DWELLING_QUALITY_LEVELS); // for (int municipality = 0; municipality < cityID.length; municipality++){ // for (int year : yearBracketsDwelling){ @@ -2363,13 +2363,13 @@ // logger.info(" Identifying vacant jobs by zone"); // Collection jobs = dataContainer.getJobData().getJobs(); // -// idVacantJobsByZoneType = new HashMap<>(); -// numberVacantJobsByType = new HashMap<>(); -// idZonesVacantJobsByType = new HashMap<>(); -// numberZonesByType = new HashMap<>(); -// numberVacantJobsByZoneByType = new HashMap<>(); +// idVacantJobsByZoneType = new LinkedHashMap<>(); +// numberVacantJobsByType = new LinkedHashMap<>(); +// idZonesVacantJobsByType = new LinkedHashMap<>(); +// numberZonesByType = new LinkedHashMap<>(); +// numberVacantJobsByZoneByType = new LinkedHashMap<>(); // jobStringTypes = ResourceUtil.getArray(rb, PROPERTIES_JOB_TYPES); -// jobIntTypes = new HashMap<>(); +// jobIntTypes = new LinkedHashMap<>(); // for (int i = 0; i < jobStringTypes.length; i++) { // jobIntTypes.put(jobStringTypes[i], i); // } @@ -2437,10 +2437,10 @@ // private void identifyVacantSchoolsByZoneByType(){ // logger.info(" Create vacant schools"); // -// numberVacantSchoolsByZoneByType = new HashMap<>(); -// numberZonesWithVacantSchoolsByType = new HashMap<>(); -// idZonesVacantSchoolsByType = new HashMap<>(); -// schoolCapacityByType = new HashMap<>(); +// numberVacantSchoolsByZoneByType = new LinkedHashMap<>(); +// numberZonesWithVacantSchoolsByType = new LinkedHashMap<>(); +// idZonesVacantSchoolsByType = new LinkedHashMap<>(); +// schoolCapacityByType = new LinkedHashMap<>(); // schoolTypes = ResourceUtil.getIntegerArray(rb, PROPERTIES_SCHOOL_TYPES_DE); // int[] cellsID = cellsMatrix.getColumnAsInt("ID_cell"); // @@ -2964,7 +2964,7 @@ // } // HashMap inner = outer.get(key); // if (inner == null){ -// inner = new HashMap(); +// inner = new LinkedHashMap(); // outer.put(key, inner); // } // inner.put(row, age); @@ -3089,7 +3089,7 @@ // innerMap.put(valueString, valueCode); // map.put(label, innerMap); // } else { -// HashMap innerMap = new HashMap<>(); +// HashMap innerMap = new LinkedHashMap<>(); // innerMap.put(valueString, valueCode); // map.put(label, innerMap); // } @@ -3103,7 +3103,7 @@ // innerMap.put(valueString, valueCode); // map.put(label, innerMap); // } else { -// Map innerMap = new HashMap<>(); +// Map innerMap = new LinkedHashMap<>(); // innerMap.put(valueString, valueCode); // map.put(label, innerMap); // } @@ -3117,7 +3117,7 @@ // innerMap.put(valueInt, valueCode); // map.put(label, innerMap); // } else { -// HashMap innerMap = new HashMap<>(); +// HashMap innerMap = new LinkedHashMap<>(); // innerMap.put(valueInt, valueCode); // map.put(label, innerMap); // } @@ -3130,7 +3130,7 @@ // inner.put(id, attributeMap); // personsInHouseholds.put(hhId, inner); // } else { -// HashMap> inner = new HashMap<>(); +// HashMap> inner = new LinkedHashMap<>(); // inner.put(id, attributeMap); // personsInHouseholds.put(hhId, inner); // } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCTrace.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCTrace.java index d996ed91c..83bb9d773 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCTrace.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/capeTown/SyntheticPopCTrace.java @@ -235,14 +235,14 @@ private void readAttributes() { String fileName = "input/syntheticPopulation/variablesCTDictionary.csv"; - attributeCodeValues = new HashMap<>(); - attributesControlTotal = new HashMap<>(); - attributesMicroPerson = new HashMap<>(); - attributesMicroHousehold = new HashMap<>(); - attributeCodeToControlTotal = new HashMap<>(); - attributeCodeToMicroPerson = new HashMap<>(); - attributeCodeToMicroHousehold = new HashMap<>(); - HashMap attributeOrder = new HashMap<>(); + attributeCodeValues = new LinkedHashMap<>(); + attributesControlTotal = new LinkedHashMap<>(); + attributesMicroPerson = new LinkedHashMap<>(); + attributesMicroHousehold = new LinkedHashMap<>(); + attributeCodeToControlTotal = new LinkedHashMap<>(); + attributeCodeToMicroPerson = new LinkedHashMap<>(); + attributeCodeToMicroHousehold = new LinkedHashMap<>(); + HashMap attributeOrder = new LinkedHashMap<>(); ageBracketsPerson = new int[]{6,14,18,21,25,30,35,40,45,50,55,60,65,70,75,80,120}; String recString = ""; @@ -352,7 +352,7 @@ private void readZonalData() { TableDataSet selectedMunicipalities = SiloUtil.readCSVfile(rb.getString(PROPERTIES_SELECTED_MUNICIPALITIES_LIST)); //TableDataSet with all municipalities municipalities = new ArrayList<>(); counties = new ArrayList<>(); - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); for (int row = 1; row <= selectedMunicipalities.getRowCount(); row++){ if (selectedMunicipalities.getValueAt(row,"Select") == 1f){ int city = (int) selectedMunicipalities.getValueAt(row,"ID_city"); @@ -379,7 +379,7 @@ private void readZonalData() { //TAZ attributes cellsMatrix = SiloUtil.readCSVfile(rb.getString(PROPERTIES_RASTER_CELLS)); cellsMatrix.buildIndex(cellsMatrix.getColumnPosition("ID_cell")); - cityTAZ = new HashMap<>(); + cityTAZ = new LinkedHashMap<>(); for (int i = 1; i <= cellsMatrix.getRowCount(); i++){ int city = (int) cellsMatrix.getValueAt(i,"ID_city"); int taz = (int) cellsMatrix.getValueAt(i,"ID_cell"); @@ -413,7 +413,7 @@ private void readZonalData() { //Read trip length frequency distribution logger.info(" Starting to read trip length frequency distribution"); TableDataSet tripLength = SiloUtil.readCSVfile2(rb.getString(PROPERTIES_TRIP_LENGTH_DISTRIBUTION)); - tripLengthFrequencyDistribution = new HashMap<>(); + tripLengthFrequencyDistribution = new LinkedHashMap<>(); for (int i = 1; i <= tripLength.getRowCount(); i++){ int distance = (int) tripLength.getValueAt(i, "km"); float value = tripLength.getValueAt(i, "HBW"); @@ -550,8 +550,8 @@ private int checkHouseholdAndPersonCorrespondence() { private void readPersons() { String fileName = "input/syntheticPopulation/newPersons.csv"; - personsInHouseholds = new HashMap<>(); - HashMap> noDatas = new HashMap<>(); + personsInHouseholds = new LinkedHashMap<>(); + HashMap> noDatas = new LinkedHashMap<>(); String recString = ""; int recCount = 0; @@ -563,7 +563,7 @@ private void readPersons() { String[] header = recString.split(","); int posHhId = SiloUtil.findPositionInArray("new$X.x", header); int posId = SiloUtil.findPositionInArray("X.y",header); - HashMap positionAttribute = new HashMap<>(); + HashMap positionAttribute = new LinkedHashMap<>(); for (int i = 0; i < microPersonAttributes.length; i++){ positionAttribute.put(microPersonAttributes[i], SiloUtil.findPositionInArray(microPersonAttributes[i], header)); } @@ -575,7 +575,7 @@ private void readPersons() { int idHh = Integer.parseInt(lineElements[posHhId]); Integer id = Integer.parseInt(lineElements[posId]); recCount++; - HashMap attributeMap = new HashMap<>(); + HashMap attributeMap = new LinkedHashMap<>(); attributeMap.put("hhId", idHh); boolean allData = true; for (int i = 0; i < microPersonAttributes.length; i++){ @@ -637,7 +637,7 @@ private void readHouseholds() { String fileName = "input/syntheticPopulation/newHouseholds.csv"; - households = new HashMap<>(); + households = new LinkedHashMap<>(); String recString = ""; int recCount = 0; try { @@ -647,7 +647,7 @@ private void readHouseholds() { // read header String[] header = recString.split(","); int posId = SiloUtil.findPositionInArray("X.x", header); - HashMap positionAttribute = new HashMap<>(); + HashMap positionAttribute = new LinkedHashMap<>(); for (Map.Entry pairCode : attributeCodeToMicroHousehold.entrySet()){ String attributeMicro = pairCode.getValue(); positionAttribute.put(attributeMicro, SiloUtil.findPositionInArray(attributeMicro, header)); @@ -658,7 +658,7 @@ private void readHouseholds() { recCount++; String[] lineElements = recString.split(","); int idhH = Integer.parseInt(lineElements[posId]); - HashMap attributeMap = new HashMap<>(); + HashMap attributeMap = new LinkedHashMap<>(); for (Map.Entry pairCode : attributeCodeToMicroHousehold.entrySet()){ String attribute = pairCode.getKey(); String attributeMicro = pairCode.getValue(); @@ -852,10 +852,10 @@ private void checkHouseholdRelationship(){ } else { //Create the maps to store the classified members of the households - HashMap childrenInHousehold = new HashMap<>(); - HashMap> noClass = new HashMap<>(); - HashMap> singles = new HashMap<>(); - HashMap> married = new HashMap<>(); + HashMap childrenInHousehold = new LinkedHashMap<>(); + HashMap> noClass = new LinkedHashMap<>(); + HashMap> singles = new LinkedHashMap<>(); + HashMap> married = new LinkedHashMap<>(); //direct classification of the members of the household for (int j = 0; j < hhSize; j++) { @@ -1137,10 +1137,10 @@ private void checkHouseholdRelationshipObject(){ } else { //Create the maps to store the classified members of the households - HashMap childrenInHousehold = new HashMap<>(); - HashMap> noClass = new HashMap<>(); - HashMap> singles = new HashMap<>(); - HashMap> married = new HashMap<>(); + HashMap childrenInHousehold = new LinkedHashMap<>(); + HashMap> noClass = new LinkedHashMap<>(); + HashMap> singles = new LinkedHashMap<>(); + HashMap> married = new LinkedHashMap<>(); //direct classification of the members of the household int row = 0; @@ -1457,13 +1457,13 @@ private void runIPUbyCityAndCounty(){ municipalities = municipalitiesByCounty.get(county); //weights, values, control totals - Map weightsByMun = Collections.synchronizedMap(new HashMap<>()); - Map minWeightsByMun = Collections.synchronizedMap(new HashMap<>()); - Map valuesByHousehold = Collections.synchronizedMap(new HashMap<>()); - Map totalCounty = Collections.synchronizedMap(new HashMap<>()); - Map> totalMunicipality = Collections.synchronizedMap(new HashMap<>()); - Map> errorByMun = Collections.synchronizedMap(new HashMap<>()); - Map errorByRegion = Collections.synchronizedMap(new HashMap<>()); + Map weightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + Map minWeightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + Map valuesByHousehold = Collections.synchronizedMap(new LinkedHashMap<>()); + Map totalCounty = Collections.synchronizedMap(new LinkedHashMap<>()); + Map> totalMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); + Map> errorByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + Map errorByRegion = Collections.synchronizedMap(new LinkedHashMap<>()); double weightedSum0 = 0f; //parameters of the IPU @@ -1512,10 +1512,10 @@ private void runIPUbyCityAndCounty(){ inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } else { - HashMap inner = new HashMap<>(); + HashMap inner = new LinkedHashMap<>(); inner.put(attribute, (int) marginalsMunicipality.getIndexedValueAt(municipality, attribute)); totalMunicipality.put(municipality, inner); - HashMap inner1 = new HashMap<>(); + HashMap inner1 = new LinkedHashMap<>(); inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } @@ -1580,7 +1580,7 @@ private void runIPUbyCityAndCounty(){ Iterator iterator1 = municipalities.iterator(); while (iterator1.hasNext()){ Integer municipality = iterator1.next(); - Map errorsByMunicipality = Collections.synchronizedMap(new HashMap<>()); + Map errorsByMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); executor1.addTaskToQueue(() ->{ for (String attribute : attributesMunicipality){ double weightedSumMunicipality = SiloUtil.sumProduct(weightsByMun.get(municipality), valuesByHousehold.get(attribute)); @@ -1785,8 +1785,8 @@ private void assignJobs(){ Collections.shuffle(workerArrayList); - HashMap personDistance = new HashMap<>(); - HashMap personHome = new HashMap<>(); + HashMap personDistance = new LinkedHashMap<>(); + HashMap personHome = new LinkedHashMap<>(); //Start the selection of the jobs in random order to avoid geographical bias logger.info(" Started assigning workplaces"); @@ -1884,7 +1884,7 @@ private void generateHouseholdsPersonsDwellings(){ int previousPersons = 0; generateCountersForValidation(); - occupiedDwellingsByZone = new HashMap<>(); + occupiedDwellingsByZone = new LinkedHashMap<>(); RealEstateDataManager realEstate = dataContainer.getRealEstateDataManager(); HouseholdDataManager householdDataManager = dataContainer.getHouseholdDataManager(); @@ -1988,7 +1988,7 @@ private void generateHouseholdsPersonsDwellings(){ if (occupiedDwellingsByZone.containsKey(taz)) { occupiedDwellingsByZone.get(taz).put(dwell.getId(), dwell); } else { - Map dd = new HashMap<>(); + Map dd = new LinkedHashMap<>(); dd.put(dwell.getId(), dwell); occupiedDwellingsByZone.put(taz,dd); } @@ -2208,13 +2208,13 @@ private void identifyVacantJobsByZoneType() { logger.info(" Identifying vacant jobs by zone"); Collection jobs = dataContainer.getJobDataManager().getJobs(); - idVacantJobsByZoneType = new HashMap<>(); - numberVacantJobsByType = new HashMap<>(); - idZonesVacantJobsByType = new HashMap<>(); - numberZonesByType = new HashMap<>(); - numberVacantJobsByZoneByType = new HashMap<>(); + idVacantJobsByZoneType = new LinkedHashMap<>(); + numberVacantJobsByType = new LinkedHashMap<>(); + idZonesVacantJobsByType = new LinkedHashMap<>(); + numberZonesByType = new LinkedHashMap<>(); + numberVacantJobsByZoneByType = new LinkedHashMap<>(); jobStringTypes = ResourceUtil.getArray(rb, PROPERTIES_JOB_TYPES); - jobIntTypes = new HashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < jobStringTypes.length; i++) { jobIntTypes.put(jobStringTypes[i], i); } @@ -2573,7 +2573,7 @@ private HashMap> updateInnerMap(HashMap inner = outer.get(key); if (inner == null){ - inner = new HashMap(); + inner = new LinkedHashMap(); outer.put(key, inner); } inner.put(row, age); @@ -2729,7 +2729,7 @@ private void updateInnerMap(HashMap> map, Strin innerMap.put(valueString, valueCode); map.put(label, innerMap); } else { - HashMap innerMap = new HashMap<>(); + HashMap innerMap = new LinkedHashMap<>(); innerMap.put(valueString, valueCode); map.put(label, innerMap); } @@ -2743,7 +2743,7 @@ private Map> updateInnerMap(Map innerMap = new HashMap<>(); + Map innerMap = new LinkedHashMap<>(); innerMap.put(valueString, valueCode); map.put(label, innerMap); } @@ -2757,7 +2757,7 @@ private void updateInnerMap(HashMap> map, Stri innerMap.put(valueInt, valueCode); map.put(label, innerMap); } else { - HashMap innerMap = new HashMap<>(); + HashMap innerMap = new LinkedHashMap<>(); innerMap.put(valueInt, valueCode); map.put(label, innerMap); } @@ -2770,7 +2770,7 @@ private void updatePersonsInHousehold(int hhId, int id, HashMap inner.put(id, attributeMap); personsInHouseholds.put(hhId, inner); } else { - HashMap> inner = new HashMap<>(); + HashMap> inner = new LinkedHashMap<>(); inner.put(id, attributeMap); personsInHouseholds.put(hhId, inner); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMito.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMito.java index d54f3d591..3e67685fa 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMito.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMito.java @@ -155,9 +155,9 @@ private void summarizeMitoData(DataContainerWithSchools dataContainer){ private void writeMultipleFilesForHouseholdsAndPersons(DataContainerWithSchools dataContainer){ - Map householdWriter = new HashMap<>(); - Map personWriter = new HashMap<>(); - Map dwellingWriter = new HashMap<>(); + Map householdWriter = new LinkedHashMap<>(); + Map personWriter = new LinkedHashMap<>(); + Map dwellingWriter = new LinkedHashMap<>(); String outputFolder = properties.main.baseDirectory + PropertiesSynPop.get().main.pathSyntheticPopulationFiles + "/subPopulations/" + PropertiesSynPop.get().main.state + "/"; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMitoByState.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMitoByState.java index 0ef86a323..6eaf53e6a 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMitoByState.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/SyntheticPopGermanyMitoByState.java @@ -29,10 +29,7 @@ import org.apache.logging.log4j.Logger; import java.io.PrintWriter; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; +import java.util.*; /** @@ -248,9 +245,9 @@ private void summarizeJobs(DataContainerWithSchools dataContainer){ private void writeMultipleFilesForHouseholdsAndPersons(DataContainerWithSchools dataContainer){ - Map householdWriter = new HashMap<>(); - Map personWriter = new HashMap<>(); - Map dwellingWriter = new HashMap<>(); + Map householdWriter = new LinkedHashMap<>(); + Map personWriter = new LinkedHashMap<>(); + Map dwellingWriter = new LinkedHashMap<>(); String outputFolder = properties.main.baseDirectory + PropertiesSynPop.get().main.pathSyntheticPopulationFiles + "/subPopulations/" + PropertiesSynPop.get().main.state + "/"; @@ -383,9 +380,9 @@ private void writeMultipleFilesForHouseholdsAndPersons(DataContainerWithSchools private void writesubsample(DataContainerWithSchools dataContainer, int samplingRate){ - Map householdWriter = new HashMap<>(); - Map personWriter = new HashMap<>(); - Map dwellingWriter = new HashMap<>(); + Map householdWriter = new LinkedHashMap<>(); + Map personWriter = new LinkedHashMap<>(); + Map dwellingWriter = new LinkedHashMap<>(); String outputFolder = properties.main.baseDirectory + PropertiesSynPop.get().main.pathSyntheticPopulationFiles + "/subPopulations00/" ; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobs.java index 6f777c9e9..d4700a87a 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobs.java @@ -159,18 +159,18 @@ private void identifyVacantJobsByZoneType() { TableDataSet jobsByTaz = PropertiesSynPop.get().main.jobsByTaz; jobStringTypes = PropertiesSynPop.get().main.jobStringType; - jobIntTypes = new HashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++) { jobIntTypes.put(PropertiesSynPop.get().main.jobStringType[i], i); } tazIds = dataSetSynPop.getTazs().stream().mapToInt(i -> i).toArray(); - idVacantJobsByZoneType = new HashMap<>(); - numberVacantJobsByType = new HashMap<>(); - idZonesVacantJobsByType = new HashMap<>(); - numberZonesByType = new HashMap<>(); - numberVacantJobsByZoneByType = new HashMap<>(); - numberTotalJobsByZoneByType = new HashMap<>(); + idVacantJobsByZoneType = new LinkedHashMap<>(); + numberVacantJobsByType = new LinkedHashMap<>(); + idZonesVacantJobsByType = new LinkedHashMap<>(); + numberZonesByType = new LinkedHashMap<>(); + numberVacantJobsByZoneByType = new LinkedHashMap<>(); + numberTotalJobsByZoneByType = new LinkedHashMap<>(); //create the counter hashmaps for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++){ diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobsBySubpopulation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobsBySubpopulation.java index 932d07a23..160acd1a4 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobsBySubpopulation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignJobsBySubpopulation.java @@ -101,7 +101,7 @@ public void run() { } private Map calculateDistanceProbabilityByJobType(String jobType, int origin, double alpha_ld, double beta_ld) { - Map probabilityByTypeAndZone = new HashMap<>(); + Map probabilityByTypeAndZone = new LinkedHashMap<>(); TableDataSet jobsByTaz = PropertiesSynPop.get().main.jobsByTaz; for (int destination : dataSetSynPop.getVacantJobsByTypeAndZone().get(jobType).keySet()) { float distance = dataSetSynPop.getDistanceTazToTaz().getValueAt(origin, destination); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchools.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchools.java index 4526f9f59..4bae700f6 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchools.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchools.java @@ -102,7 +102,7 @@ private int selectTertiarySchool(int hometaz){ int schooltaz = -2; if (numberOfVacantPlacesByType.get(3) > 0) { - Map probability = new HashMap<>(); + Map probability = new LinkedHashMap<>(); Iterator iterator = schoolCapacityMap.get(3).keySet().iterator(); double alpha1 = 0.3000; //0.2700, 0.3000 @@ -171,8 +171,8 @@ private void shuffleStudents(){ private void initializeSchoolCapacity(){ - schoolCapacityMap = new HashMap<>(); - numberOfVacantPlacesByType = new HashMap<>(); + schoolCapacityMap = new LinkedHashMap<>(); + numberOfVacantPlacesByType = new LinkedHashMap<>(); Table schoolCapacity = dataSetSynPop.getSchoolCapacity(); Iterator iteratorRow = schoolCapacity.rowKeySet().iterator(); while (iteratorRow.hasNext()){ @@ -182,7 +182,7 @@ private void initializeSchoolCapacity(){ int schoolType = iteratorCol.next(); int places = schoolCapacity.get(zone, schoolType); if (places > 0) { - Map prevPlaces = new HashMap<>(); + Map prevPlaces = new LinkedHashMap<>(); if (schoolCapacityMap.get(schoolType)!= null) { prevPlaces = schoolCapacityMap.get(schoolType); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchoolsBySubpopulation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchoolsBySubpopulation.java index 2301eaa68..3714863e4 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchoolsBySubpopulation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/AssignSchoolsBySubpopulation.java @@ -17,6 +17,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class AssignSchoolsBySubpopulation { @@ -116,7 +117,7 @@ public void run() { } private Map calculateDistanceProbabilityBySchoolType(int schoolType, int origin, double alpha_ld, double beta_ld) { - Map probabilityByTypeAndZone = new HashMap<>(); + Map probabilityByTypeAndZone = new LinkedHashMap<>(); TableDataSet jobsByTaz = PropertiesSynPop.get().main.jobsByTaz; if (schoolType == 3) { float minDistance = 10000; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateHouseholdsPersons.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateHouseholdsPersons.java index 3b87ad8fd..e94c6716a 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateHouseholdsPersons.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateHouseholdsPersons.java @@ -163,7 +163,7 @@ private int initializeMunicipalityData(int municipality){ totalHouseholds = (int) PropertiesSynPop.get().main.marginalsBorough.getIndexedValueAt(municipality, "borough_hhTotal"); } probTAZ = dataSetSynPop.getProbabilityZone().get(municipality); - probMicroData = new HashMap<>(); + probMicroData = new LinkedHashMap<>(); probabilityId = new double[dataSetSynPop.getWeights().getRowCount()]; ids = new int[probabilityId.length]; sumProbabilities = 0; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobCounters.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobCounters.java index 5e1a95a79..e00ab7c8f 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobCounters.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobCounters.java @@ -37,13 +37,13 @@ public void run() { private void generateJobCounters(){ logger.info(" Generating counters with vacant jobs by zone"); - Map> vacantJobsByTypeAndZone = new HashMap<>(); - Map> assignedJobsByTypeAndZone = new HashMap<>(); + Map> vacantJobsByTypeAndZone = new LinkedHashMap<>(); + Map> assignedJobsByTypeAndZone = new LinkedHashMap<>(); assignedJobs = 0; TableDataSet jobsByTaz = PropertiesSynPop.get().main.jobsByTaz; for (String jobType : JobType.getJobTypes()) { - //vacantJobsByTypeAndZone.putIfAbsent(jobType, new HashMap<>()); - assignedJobsByTypeAndZone.putIfAbsent(jobType, new HashMap<>()); + //vacantJobsByTypeAndZone.putIfAbsent(jobType, new LinkedHashMap<>()); + assignedJobsByTypeAndZone.putIfAbsent(jobType, new LinkedHashMap<>()); for (int taz : jobsByTaz.getColumnAsInt("taz")) { //int jobs = (int) jobsByTaz.getValueAt(taz, jobType) * (1 + PropertiesSynPop.get().main.vacantJobPercentage / 100); //vacantJobsByTypeAndZone.get(jobType).putIfAbsent(taz, jobs); @@ -52,7 +52,7 @@ private void generateJobCounters(){ } } - vacantJobsByTypeAndZone.putIfAbsent("all", new HashMap<>()); + vacantJobsByTypeAndZone.putIfAbsent("all", new LinkedHashMap<>()); for (int taz : jobsByTaz.getColumnAsInt("taz")) { int jobs = 0; for (String jobType : JobType.getJobTypes()) { diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobs.java index 456be4e8d..3b0f3c31c 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateJobs.java @@ -12,6 +12,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Random; @@ -79,7 +80,7 @@ private void generateJobsByTypeAtMunicipalityWithReplacement(int municipality, S private void initializeTAZprobability(int municipality, String jobType){ - jobsByTaz = new HashMap<>(); + jobsByTaz = new LinkedHashMap<>(); jobsByTaz.clear(); for (int taz : dataSetSynPop.getTazByMunicipality().get(municipality)){ jobsByTaz.put(taz, PropertiesSynPop.get().main.cellsMatrix.getIndexedValueAt(taz, jobType)); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateSchoolMicrolocations.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateSchoolMicrolocations.java index b2533f8f0..50b914548 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateSchoolMicrolocations.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/GenerateSchoolMicrolocations.java @@ -22,6 +22,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateSchoolMicrolocations { @@ -44,13 +45,13 @@ public void run() { private void createSchools() { - Map>> zoneSchoolTypeSchoolLocationCapacity = new HashMap<>(); - Map> zoneSchoolTypeSchoolLocationVacancy = new HashMap<>(); + Map>> zoneSchoolTypeSchoolLocationCapacity = new LinkedHashMap<>(); + Map> zoneSchoolTypeSchoolLocationVacancy = new LinkedHashMap<>(); for (int type = 1 ; type <= 3; type++){ - Map> schoolLocationListForThisSchoolType = new HashMap<>(); - Map schoolLocationListForThisSchoolTypeVacancy = new HashMap<>(); + Map> schoolLocationListForThisSchoolType = new LinkedHashMap<>(); + Map schoolLocationListForThisSchoolTypeVacancy = new LinkedHashMap<>(); for (int zone : dataSetSynPop.getTazs()){ - Map schoolCapacity = new HashMap<>(); + Map schoolCapacity = new LinkedHashMap<>(); schoolLocationListForThisSchoolType.put(zone,schoolCapacity); schoolLocationListForThisSchoolTypeVacancy.put(zone,0); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/Read2011JobsForMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/Read2011JobsForMicrolocation.java index d93c35ae1..edd36d3c6 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/Read2011JobsForMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/Read2011JobsForMicrolocation.java @@ -54,12 +54,12 @@ private void readJobData() { Map>> microlocationsJobsByTypeAndZone = new LinkedHashMap<>(); for (String jobType : JobType.getJobTypes()) { - microlocationsJobsByTypeAndZone.putIfAbsent(jobType, new HashMap<>()); + microlocationsJobsByTypeAndZone.putIfAbsent(jobType, new LinkedHashMap<>()); for (int taz : PropertiesSynPop.get().main.jobsByTaz.getColumnAsInt("taz")) { - Map centroidCoordinates = new HashMap<>(); + Map centroidCoordinates = new LinkedHashMap<>(); int coordX = dataSetSynPop.getZoneCoordinates().get(taz,"coordX"); int coordY = dataSetSynPop.getZoneCoordinates().get(taz,"coordY"); - microlocationsJobsByTypeAndZone.get(jobType).putIfAbsent(taz, new HashMap<>()); + microlocationsJobsByTypeAndZone.get(jobType).putIfAbsent(taz, new LinkedHashMap<>()); microlocationsJobsByTypeAndZone.get(jobType).get(taz).put(0, new Coordinate(coordX, coordY)); } } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/ValidateTripLengthDistributionByState.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/ValidateTripLengthDistributionByState.java index adc08b2a7..f6ba5f998 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/ValidateTripLengthDistributionByState.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/allocation/ValidateTripLengthDistributionByState.java @@ -17,6 +17,7 @@ import java.io.PrintWriter; import java.security.Timestamp; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class ValidateTripLengthDistributionByState { @@ -54,7 +55,7 @@ private void summarizeCommutersTripLength(){ private Map obtainWorkerFlows(){ - Map frequencies = new HashMap<>(); + Map frequencies = new LinkedHashMap<>(); for (String jobType : JobType.getJobTypes()) { Frequency commuteDistance = new Frequency(); frequencies.putIfAbsent(jobType, commuteDistance); @@ -107,7 +108,7 @@ private Map obtainWorkerFlows(){ private void summarizeFlows(Map travelTimes, String fileName){ //to obtain the trip length distribution int[] timeThresholds1 = new int[200]; - Map cumFrequency = new HashMap<>(); + Map cumFrequency = new LinkedHashMap<>(); for (String keyFrequencies : travelTimes.keySet()) { double[] frequencyTT1 = new double[200]; for (int row = 0; row < timeThresholds1.length; row++) { diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/ReadSubPopulations.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/ReadSubPopulations.java index 81c628bfb..7ebb74d39 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/ReadSubPopulations.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/ReadSubPopulations.java @@ -360,9 +360,9 @@ private void readJobData(int year, String state) { private void writeMultipleFilesForHouseholdsAndPersons(DataContainerWithSchools dataContainer){ - Map householdWriter = new HashMap<>(); - Map personWriter = new HashMap<>(); - Map dwellingWriter = new HashMap<>(); + Map householdWriter = new LinkedHashMap<>(); + Map personWriter = new LinkedHashMap<>(); + Map dwellingWriter = new LinkedHashMap<>(); String outputFolder = Properties.get().main.baseDirectory + PropertiesSynPop.get().main.pathSyntheticPopulationFiles + "/subPopulations/" + PropertiesSynPop.get().main.state + "/"; @@ -493,20 +493,20 @@ private void writeMultipleFilesForHouseholdsAndPersons(DataContainerWithSchools } private void startCounters(){ - countsPreviousState = new HashMap<>(); - countsPreviousState = new HashMap<>(); - countsPreviousState.putIfAbsent("all", new HashMap<>()); + countsPreviousState = new LinkedHashMap<>(); + countsPreviousState = new LinkedHashMap<>(); + countsPreviousState.putIfAbsent("all", new LinkedHashMap<>()); countsPreviousState.get("all").putIfAbsent("hh", 0); countsPreviousState.get("all").put("pp", 0); countsPreviousState.get("all").put("dd", 0); - countsState = new HashMap<>(); - countsState = new HashMap<>(); + countsState = new LinkedHashMap<>(); + countsState = new LinkedHashMap<>(); for (String state : PropertiesSynPop.get().main.states) { - countsPreviousState.put(state, new HashMap<>()); + countsPreviousState.put(state, new LinkedHashMap<>()); countsPreviousState.get(state).putIfAbsent("hh", 0); countsPreviousState.get(state).put("pp", 0); countsPreviousState.get(state).put("dd", 0); - countsState.put(state, new HashMap<>()); + countsState.put(state, new LinkedHashMap<>()); countsState.get(state).putIfAbsent("hh", 0); countsState.get(state).put("pp", 0); countsState.get(state).put("dd", 0); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/WriteSubpopulationsByState.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/WriteSubpopulationsByState.java index 4962c607f..de2359012 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/WriteSubpopulationsByState.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/io/WriteSubpopulationsByState.java @@ -14,10 +14,7 @@ import org.apache.logging.log4j.Logger; import java.io.PrintWriter; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; +import java.util.*; /** @@ -56,9 +53,9 @@ private void createDirectoryForOutput() { private void writeMultipleFilesForHouseholdsAndPersons(DataContainerWithSchools dataContainer){ - Map householdWriter = new HashMap<>(); - Map personWriter = new HashMap<>(); - Map dwellingWriter = new HashMap<>(); + Map householdWriter = new LinkedHashMap<>(); + Map personWriter = new LinkedHashMap<>(); + Map dwellingWriter = new LinkedHashMap<>(); ArrayList householdArrayList = new ArrayList<>(); for (Household hh : dataContainer.getHouseholdDataManager().getHouseholds()){ diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/MicroDataManager.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/MicroDataManager.java index d0a8c1cdc..2d141cfff 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/MicroDataManager.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/MicroDataManager.java @@ -9,6 +9,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class MicroDataManager { @@ -22,7 +23,7 @@ public class MicroDataManager { public HashMap attributesMicroData(){ - HashMap attributesMicroData = new HashMap<>(); + HashMap attributesMicroData = new LinkedHashMap<>(); String[] attributesPerson = {"age", "gender", "occupation", "income", "nationality", "school"}; String[] attributesHousehold = {"workers", "hhSize"}; attributesMicroData.put("person", attributesPerson); @@ -33,34 +34,34 @@ public HashMap attributesMicroData(){ public Map> attributesPersonMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map age = new HashMap<>(); + Map age = new LinkedHashMap<>(); age.put("initial", 50); age.put("end", 52); attributesIPU.put("age", age); - Map gender = new HashMap<>(); + Map gender = new LinkedHashMap<>(); gender.put("initial", 54); gender.put("end", 55); attributesIPU.put("gender", gender); - Map occupation = new HashMap<>(); + Map occupation = new LinkedHashMap<>(); occupation.put("initial", 32); occupation.put("end", 33); attributesIPU.put("occupation", occupation); //Additional attributes - Map income = new HashMap<>(); + Map income = new LinkedHashMap<>(); income.put("initial", 471); income.put("end", 473); attributesIPU.put("income", income); - Map sector = new HashMap<>(); + Map sector = new LinkedHashMap<>(); sector.put("initial", 479); sector.put("end", 482); attributesIPU.put("sector", sector); - Map sectorComplete = new HashMap<>(); + Map sectorComplete = new LinkedHashMap<>(); sectorComplete.put("initial", 479); sectorComplete.put("end", 482); attributesIPU.put("sectorComplete", sectorComplete); - Map school = new HashMap<>(); + Map school = new LinkedHashMap<>(); school.put("initial", 307); school.put("end", 309); attributesIPU.put("school", school); @@ -70,14 +71,14 @@ public Map> attributesPersonMicroData(){ public Map> attributesHouseholdMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map hhSize = new HashMap<>(); + Map hhSize = new LinkedHashMap<>(); hhSize.put("initial", 26); hhSize.put("end", 28); attributesIPU.put("hhSize", hhSize); //Additional attributes - Map workers = new HashMap<>(); + Map workers = new LinkedHashMap<>(); workers.put("initial", 572); workers.put("end", 574); attributesIPU.put("workers", workers); @@ -87,13 +88,13 @@ public Map> attributesHouseholdMicroData(){ public Map> exceptionsMicroData(String stateString){ - Map> exceptionsMicroData = new HashMap<>(); - Map LivingInQuarter = new HashMap<>(); + Map> exceptionsMicroData = new LinkedHashMap<>(); + Map LivingInQuarter = new LinkedHashMap<>(); LivingInQuarter.put("initial", 34); LivingInQuarter.put("end", 35); LivingInQuarter.put("exceptionIf", 2); exceptionsMicroData.put("quarter", LivingInQuarter); - Map noIncome = new HashMap<>(); + Map noIncome = new LinkedHashMap<>(); noIncome.put("initial", 658); noIncome.put("end", 660); noIncome.put("exceptionIf", 99); @@ -107,7 +108,7 @@ public Map> exceptionsMicroData(String stateString) for (int i = 1; i < 16; i++ ) { if (i!=state) { String nameState = "State" + i; - Map key = new HashMap<>(); + Map key = new LinkedHashMap<>(); key.put("initial", 0); key.put("end", 2); key.put("exceptionIf", i); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadMicroData.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadMicroData.java index 7492b640e..cef91dbf7 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadMicroData.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadMicroData.java @@ -14,6 +14,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class ReadMicroData { @@ -22,10 +23,10 @@ public class ReadMicroData { private final DataSetSynPop dataSetSynPop; private final MicroDataManager microDataManager; - private Map> exceptionsMicroData = new HashMap<>(); - private HashMap attributesMicroData = new HashMap<>(); - private Map> attributesPersonMicroData = new HashMap<>(); - private Map> attributesHouseholdMicroData = new HashMap<>(); + private Map> exceptionsMicroData = new LinkedHashMap<>(); + private HashMap attributesMicroData = new LinkedHashMap<>(); + private Map> attributesPersonMicroData = new LinkedHashMap<>(); + private Map> attributesHouseholdMicroData = new LinkedHashMap<>(); private Table personTable = HashBasedTable.create(); private Table householdTable = HashBasedTable.create(); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadZonalData.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadZonalData.java index a157c3849..627e36d7b 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadZonalData.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/germany/preparation/ReadZonalData.java @@ -46,7 +46,7 @@ private void readCities() { //List of municipalities and counties that are used for IPU and allocation ArrayList municipalities = new ArrayList<>(); ArrayList counties = new ArrayList<>(); - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); ArrayList municipalitiesWithZero = new ArrayList<>(); for (int row = 1; row <= PropertiesSynPop.get().main.selectedMunicipalities.getRowCount(); row++) { if (PropertiesSynPop.get().main.selectedMunicipalities.getValueAt(row, "Select") == 1f) { @@ -77,7 +77,7 @@ private void readCities() { dataSetSynPop.setMunicipalitiesWithZeroPopulation(municipalitiesWithZero); if (PropertiesSynPop.get().main.boroughIPU) { - HashMap boroughsByCounty = new HashMap<>(); + HashMap boroughsByCounty = new LinkedHashMap<>(); ArrayList boroughs = new ArrayList<>(); ArrayList countieswithBoroughs = new ArrayList<>(); for (int row = 1; row <= PropertiesSynPop.get().main.selectedBoroughs.getRowCount(); row++) { @@ -106,11 +106,11 @@ private void readCities() { private void readZones(){ //TAZ attributes logger.info(" Started to read TAZ 100 by 100 m"); - HashMap cityTAZ = new HashMap<>(); - Map> probabilityZone = new HashMap<>(); + HashMap cityTAZ = new LinkedHashMap<>(); + Map> probabilityZone = new LinkedHashMap<>(); Table schoolCapacity = HashBasedTable.create(); Table zoneCoordinates = HashBasedTable.create(); - Map universityByZone = new HashMap<>(); + Map universityByZone = new LinkedHashMap<>(); ArrayList tazs = new ArrayList<>(); TableDataSet zoneAttributes; if (!PropertiesSynPop.get().main.boroughIPU){ @@ -139,7 +139,7 @@ private void readZones(){ } else { int[] previousTaz = {taz}; cityTAZ.put(city,previousTaz); - Map probabilities = new HashMap<>(); + Map probabilities = new LinkedHashMap<>(); probabilities.put(taz, probability); probabilityZone.put(city, probabilities); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/ExtractMicroDataJP.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/ExtractMicroDataJP.java index e9d5603a4..7d1beeee8 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/ExtractMicroDataJP.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/ExtractMicroDataJP.java @@ -10,6 +10,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.ResourceBundle; @@ -170,7 +171,7 @@ private void setInputData() { private void setAttributesToCopyFromMicroData() { //method to set the attributesControlTotal to read - attributesMicroData = new HashMap<>(); + attributesMicroData = new LinkedHashMap<>(); for (int i = 1; i <= variables.getRowCount(); i++){ String key = variables.getStringValueAt(i,"Type"); String value = variables.getStringValueAt(i,"VariableNameMicroData"); @@ -396,7 +397,7 @@ private void initializeAttributesMunicipality() { frequencyMatrix = new TableDataSet(); frequencyMatrix.appendColumn(microHouseholds.getColumnAsInt("id"),"id"); - attributesDictionary = new HashMap<>(); + attributesDictionary = new LinkedHashMap<>(); for (int i = 0; i < attributesControlTotal.length; i++){ int finish = 0; @@ -793,10 +794,10 @@ private void initialize(){ SiloUtil.addIntegerColumnToTableDataSet(microDataPerson, "rearrangedRole"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold,"nonClassifiedMales"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold, "nonClassifiedFemales"*//*);*/ - childrenInHousehold = new HashMap<>(); - noClass = new HashMap<>(); - singles = new HashMap<>(); - married = new HashMap<>(); + childrenInHousehold = new LinkedHashMap<>(); + noClass = new LinkedHashMap<>(); + singles = new LinkedHashMap<>(); + married = new LinkedHashMap<>(); } @@ -815,7 +816,7 @@ private HashMap> updateInnerMap(HashMap inner = outer.get(key); if (inner == null){ - inner = new HashMap(); + inner = new LinkedHashMap(); outer.put(key, inner); } inner.put(row, age); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/IPUbyCityWithSubsample.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/IPUbyCityWithSubsample.java index d5bc40262..c9833ce62 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/IPUbyCityWithSubsample.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/IPUbyCityWithSubsample.java @@ -200,11 +200,11 @@ public void initializeErrorsandTotals(int municipality){ startTime = System.nanoTime(); //weights, values, control totals - weightsByMun = Collections.synchronizedMap(new HashMap<>()); - minWeightsByMun = Collections.synchronizedMap(new HashMap<>()); - valuesByHousehold = Collections.synchronizedMap(new HashMap<>()); - totalMunicipality = Collections.synchronizedMap(new HashMap<>()); - errorsByMunicipality = Collections.synchronizedMap(new HashMap<>()); + weightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + minWeightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + valuesByHousehold = Collections.synchronizedMap(new LinkedHashMap<>()); + totalMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); + errorsByMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); finish = 0; @@ -240,7 +240,7 @@ public void initializeErrorsandTotals(int municipality){ errorsByMunicipality.put(attribute, 0.); } else { - HashMap inner = new HashMap<>(); + HashMap inner = new LinkedHashMap<>(); inner.put(attribute, (int) PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, attribute)); totalMunicipality.put(municipality, inner); errorsByMunicipality.put(attribute, 0.); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/SyntheticPopJP.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/SyntheticPopJP.java index 5f6d17b22..99fe3e464 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/SyntheticPopJP.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/kagawa/SyntheticPopJP.java @@ -130,7 +130,7 @@ public class SyntheticPopJP implements SyntheticPopI { protected TableDataSet odCountyFlow; private DataContainer dataContainer; - private HashMap jobTypeByWorker= new HashMap<>(); + private HashMap jobTypeByWorker= new LinkedHashMap<>(); static Logger logger = LogManager.getLogger(String.valueOf(SyntheticPopJP.class)); private Properties properties; @@ -202,7 +202,7 @@ private void readInputData() { ArrayList municipalities = new ArrayList<>(); ArrayList counties = new ArrayList<>(); HashMap municipalitiesByCounty; - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); for (int row = 1; row <= selectedMunicipalities.getRowCount(); row++){ if (selectedMunicipalities.getValueAt(row,"Select") == 1f){ int city = (int) selectedMunicipalities.getValueAt(row,"V1"); @@ -237,7 +237,7 @@ private void readInputData() { //TAZ attributes cellsMatrix = SiloUtil.readCSVfile(rb.getString(PROPERTIES_RASTER_CELLS)); cellsMatrix.buildIndex(cellsMatrix.getColumnPosition("ID_cell")); - cityTAZ = new HashMap<>(); + cityTAZ = new LinkedHashMap<>(); for (int i = 1; i <= cellsMatrix.getRowCount(); i++){ int city = (int) cellsMatrix.getValueAt(i,"ID_city"); int taz = (int) cellsMatrix.getValueAt(i,"ID_cell"); @@ -280,14 +280,14 @@ private void readInputData() { regionsforFrequencyMatrix = SiloUtil.readCSVfile(rb.getString(PROPERTIES_ATRIBUTES_ZONAL_DATA)); regionsforFrequencyMatrix.buildIndex(regionsforFrequencyMatrix.getColumnPosition("V1")); - householdsForFrequencyMatrix = new HashMap<>(); + householdsForFrequencyMatrix = new LinkedHashMap<>(); for (int i = 1; i <= microDataDwelling.getRowCount();i++){ int v2Zone = (int) microDataDwelling.getValueAt(i,"PtResCode"); int ddID = (int) microDataDwelling.getValueAt(i,"id"); if (householdsForFrequencyMatrix.containsKey(v2Zone)) { householdsForFrequencyMatrix.get(v2Zone).put(ddID, 1); } else { - HashMap map = new HashMap<>(); + HashMap map = new LinkedHashMap<>(); map.put(ddID, 1); householdsForFrequencyMatrix.put(v2Zone, map); } @@ -318,14 +318,14 @@ private void runIPUbyCity(){ regionsforFrequencyMatrix = SiloUtil.readCSVfile(rb.getString(PROPERTIES_ATRIBUTES_ZONAL_DATA)); regionsforFrequencyMatrix.buildIndex(regionsforFrequencyMatrix.getColumnPosition("V1")); - householdsForFrequencyMatrix = new HashMap<>(); + householdsForFrequencyMatrix = new LinkedHashMap<>(); for (int i = 1; i <= microDataDwelling.getRowCount();i++){ int v2Zone = (int) microDataDwelling.getValueAt(i,"PtResCode"); int ddID = (int) microDataDwelling.getValueAt(i,"id"); if (householdsForFrequencyMatrix.containsKey(v2Zone)) { householdsForFrequencyMatrix.get(v2Zone).put(ddID, 1); } else { - HashMap map = new HashMap<>(); + HashMap map = new LinkedHashMap<>(); map.put(ddID, 1); householdsForFrequencyMatrix.put(v2Zone, map); } @@ -1037,7 +1037,7 @@ private void generateHouseholdsPersonsDwellings(){ //Create a map to store the household IDs by municipality - HashMap> householdByMunicipality = new HashMap<>(); + HashMap> householdByMunicipality = new LinkedHashMap<>(); generateCountersForValidation(); @@ -1047,14 +1047,14 @@ private void generateHouseholdsPersonsDwellings(){ regionsforFrequencyMatrix = SiloUtil.readCSVfile(rb.getString(PROPERTIES_ATRIBUTES_ZONAL_DATA)); regionsforFrequencyMatrix.buildIndex(regionsforFrequencyMatrix.getColumnPosition("V1")); - householdsForFrequencyMatrix = new HashMap<>(); + householdsForFrequencyMatrix = new LinkedHashMap<>(); for (int i = 1; i <= microDataDwelling.getRowCount();i++){ int v2Zone = (int) microDataDwelling.getValueAt(i,"PtResCode"); int ddID = (int) microDataDwelling.getValueAt(i,"id"); if (householdsForFrequencyMatrix.containsKey(v2Zone)) { householdsForFrequencyMatrix.get(v2Zone).put(ddID, 1); } else { - HashMap map = new HashMap<>(); + HashMap map = new LinkedHashMap<>(); map.put(ddID, 1); householdsForFrequencyMatrix.put(v2Zone, map); } @@ -1104,7 +1104,7 @@ private void generateHouseholdsPersonsDwellings(){ HashMap hhs = householdsForFrequencyMatrix.get(v2zone); int[] hhFromV2 = hhs.keySet().stream().mapToInt(Integer::intValue).toArray(); - HashMap generatedHouseholds = new HashMap<>(); + HashMap generatedHouseholds = new LinkedHashMap<>(); //obtain the raster cells of the municipality and their weight within the municipality @@ -1118,7 +1118,7 @@ private void generateHouseholdsPersonsDwellings(){ double hhRemaining = 0; - HashMap prob = new HashMap<>(); + HashMap prob = new LinkedHashMap<>(); for (int row = 0; row < hhFromV2.length; row++){ double value = weightsTable.getIndexedValueAt(hhFromV2[row], Integer.toString(municipalityID)); hhRemaining = hhRemaining + value; @@ -1592,12 +1592,12 @@ private void identifyVacantJobsByZoneType() { logger.info(" Identifying vacant jobs by zone"); Collection jobs = dataContainer.getJobDataManager().getJobs(); - idVacantJobsByZoneType = new HashMap<>(); - numberVacantJobsByType = new HashMap<>(); - idZonesVacantJobsByType = new HashMap<>(); - numberZonesByType = new HashMap<>(); - numberVacantJobsByZoneByType = new HashMap<>(); - jobIntTypes = new HashMap<>(); + idVacantJobsByZoneType = new LinkedHashMap<>(); + numberVacantJobsByType = new LinkedHashMap<>(); + idZonesVacantJobsByType = new LinkedHashMap<>(); + numberZonesByType = new LinkedHashMap<>(); + numberVacantJobsByZoneByType = new LinkedHashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < jobStringTypes.length; i++) { jobIntTypes.put(jobStringTypes[i], i); } @@ -1665,10 +1665,10 @@ private void identifyVacantJobsByZoneType() { private void identifyVacantSchoolsByZoneByType(){ logger.info(" Create vacant schools"); - numberVacantSchoolsByZoneByType = new HashMap<>(); - numberZonesWithVacantSchoolsByType = new HashMap<>(); - idZonesVacantSchoolsByType = new HashMap<>(); - schoolCapacityByType = new HashMap<>(); + numberVacantSchoolsByZoneByType = new LinkedHashMap<>(); + numberZonesWithVacantSchoolsByType = new LinkedHashMap<>(); + idZonesVacantSchoolsByType = new LinkedHashMap<>(); + schoolCapacityByType = new LinkedHashMap<>(); schoolTypes = ResourceUtil.getIntegerArray(rb, PROPERTIES_SCHOOL_TYPES_DE); int[] cellsID = cellsMatrix.getColumnAsInt("ID_cell"); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/DataSetSynPopMCR.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/DataSetSynPopMCR.java index 21220914f..4432ca5b3 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/DataSetSynPopMCR.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/DataSetSynPopMCR.java @@ -15,6 +15,7 @@ import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; /** @@ -44,7 +45,7 @@ public class DataSetSynPopMCR extends DataSetSynPop { private int[] countyIDs; private int[] tazIDs; private Map> probabilityZone; - private Map>> probabilityZoneByDdType = new HashMap<>(); + private Map>> probabilityZoneByDdType = new LinkedHashMap<>(); private Map> dwellingPriceByTypeAndZone; private Table schoolCapacity = HashBasedTable.create(); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/Allocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/Allocation.java index 32d1f2517..273db9d2d 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/Allocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/Allocation.java @@ -16,6 +16,7 @@ import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; public class Allocation extends ModuleSynPop{ @@ -57,7 +58,7 @@ public void run(){ } public void generateHouseholdsPersonsDwellings(){ - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new GenerateHouseholdsPersonsDwellings(dataContainer, dataSetSynPop, educationalLevel).run(); } @@ -76,7 +77,7 @@ public void assignSchools(){ public void generateAutos() {new CarOwnership(dataContainer, dataSetSynPop).run();} public void readPopulation(){ - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new ReadPopulation(dataContainer, educationalLevel).run(); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignJobs.java index f5d608fa1..b72b9bd7d 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignJobs.java @@ -167,18 +167,18 @@ private void identifyVacantJobsByZoneType() { Collection jobs = dataContainer.getJobDataManager().getJobs(); jobStringTypes = PropertiesSynPop.get().main.jobStringType; - jobIntTypes = new HashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++) { jobIntTypes.put(PropertiesSynPop.get().main.jobStringType[i], i); } tazIds = dataSetSynPop.getTazs().stream().mapToInt(i -> i).toArray(); - idVacantJobsByZoneType = new HashMap<>(); - numberVacantJobsByType = new HashMap<>(); - idZonesVacantJobsByType = new HashMap<>(); - numberZonesByType = new HashMap<>(); - numberVacantJobsByZoneByType = new HashMap<>(); - jobIntTypes = new HashMap<>(); + idVacantJobsByZoneType = new LinkedHashMap<>(); + numberVacantJobsByType = new LinkedHashMap<>(); + idZonesVacantJobsByType = new LinkedHashMap<>(); + numberZonesByType = new LinkedHashMap<>(); + numberVacantJobsByZoneByType = new LinkedHashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++) { jobIntTypes.put(PropertiesSynPop.get().main.jobStringType[i], i); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignSchools.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignSchools.java index fc69a03f3..9672f646c 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignSchools.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/AssignSchools.java @@ -36,7 +36,7 @@ public class AssignSchools { private Map> schoolCapacityMap; private Map numberOfVacantPlacesByType; - Map>> schoolByZoneByType = new HashMap<>(); + Map>> schoolByZoneByType = new LinkedHashMap<>(); public AssignSchools(DataContainerWithSchools dataContainer, DataSetSynPop dataSetSynPop){ @@ -110,7 +110,7 @@ private int selectTertiarySchool(int hometaz){ int schooltaz = -2; if (numberOfVacantPlacesByType.get(3) > 0) { - Map probability = new HashMap<>(); + Map probability = new LinkedHashMap<>(); Iterator iterator = schoolCapacityMap.get(3).keySet().iterator(); while (iterator.hasNext()) { Integer zone = iterator.next(); @@ -176,8 +176,8 @@ private void shuffleStudents(){ private void initializeSchoolCapacity(){ - schoolCapacityMap = new HashMap<>(); - numberOfVacantPlacesByType = new HashMap<>(); + schoolCapacityMap = new LinkedHashMap<>(); + numberOfVacantPlacesByType = new LinkedHashMap<>(); Table schoolCapacity = dataSetSynPop.getSchoolCapacity(); Iterator iteratorRow = schoolCapacity.rowKeySet().iterator(); while (iteratorRow.hasNext()){ @@ -187,7 +187,7 @@ private void initializeSchoolCapacity(){ int schoolType = iteratorCol.next(); int places = schoolCapacity.get(zone, schoolType); if (places > 0) { - Map prevPlaces = new HashMap<>(); + Map prevPlaces = new LinkedHashMap<>(); if (schoolCapacityMap.get(schoolType)!= null) { prevPlaces = schoolCapacityMap.get(schoolType); } @@ -274,8 +274,8 @@ private void readSchools() { Coordinate coordinate = new Coordinate(xCoordinate,yCoordinate); schoolData.addSchool(SchoolUtils.getFactory().createSchool(id, schoolType, schoolCapacity,0,coordinate, zone)); - schoolByZoneByType.computeIfAbsent(zone, k -> new HashMap<>()) - .computeIfAbsent(schoolType, k -> new HashMap<>()) + schoolByZoneByType.computeIfAbsent(zone, k -> new LinkedHashMap<>()) + .computeIfAbsent(schoolType, k -> new LinkedHashMap<>()) .put(id, schoolCapacity); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateHouseholdsPersonsDwellings.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateHouseholdsPersonsDwellings.java index e95f16d2b..fb7e82344 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateHouseholdsPersonsDwellings.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateHouseholdsPersonsDwellings.java @@ -287,7 +287,7 @@ private void initializeMunicipalityData(int municipality){ totalHouseholds = (int) PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, "hh"); - probMicroData = new HashMap<>(); + probMicroData = new LinkedHashMap<>(); probabilityId = new double[dataSetSynPop.getWeights().getRowCount()]; ids = new int[probabilityId.length]; sumProbabilities = 0; @@ -467,9 +467,9 @@ private void allocationErrorsByZone(int municipality) { private void summaryByCity(int municipality) { - Map householdMap = new HashMap<>(); - Map dwellingMap = new HashMap<>(); - Map personMap = new HashMap<>(); + Map householdMap = new LinkedHashMap<>(); + Map dwellingMap = new LinkedHashMap<>(); + Map personMap = new LinkedHashMap<>(); int ppNumber = 0; for (int hhNumber = 0; hhNumber < totalHouseholds; hhNumber++){ Household hh = householdData.getHouseholdFromId(hhNumber + firstHouseholdMunicipality); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateJobs.java index 77ce3bd02..b26fa22f2 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateJobs.java @@ -12,6 +12,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateJobs { @@ -64,7 +65,7 @@ private void generateJobsByTypeAtMunicipalityWithReplacement(int municipality, S private void initializeTAZprobability(int municipality, String jobType){ - jobsByTaz = new HashMap<>(); + jobsByTaz = new LinkedHashMap<>(); jobsByTaz.clear(); for (int taz : dataSetSynPop.getTazByMunicipality().get(municipality)){ jobsByTaz.put(taz, dataSetSynPop.getTazAttributes().get(taz).get(jobType)); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateVacantDwellings.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateVacantDwellings.java index f7301947f..ae7fd75d3 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateVacantDwellings.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/allocation/GenerateVacantDwellings.java @@ -31,7 +31,7 @@ public class GenerateVacantDwellings { private int highestDwellingIdInUse; private final DataContainer dataContainer; private RealEstateDataManager realEstateData; - private Map> occupiedDwellings = new HashMap<>(); + private Map> occupiedDwellings = new LinkedHashMap<>(); private DwellingFactory dwellingFactory; @@ -108,11 +108,11 @@ private void generateVacantDwellings(){ private void initializeVacantDwellingData(int municipality){ - probVacantFloor = new HashMap<>(); + probVacantFloor = new LinkedHashMap<>(); for (int floor : PropertiesSynPop.get().main.sizeBracketsDwelling) { probVacantFloor.put(floor, PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, "vacantDwellings" + floor)); } - probVacantBuildingSize = new HashMap<>(); + probVacantBuildingSize = new LinkedHashMap<>(); for (int year : PropertiesSynPop.get().main.yearBracketsDwelling){ int sizeYear = year; String label = "vacantSmallDwellings" + year; @@ -149,13 +149,13 @@ private void updateQualityMap(int municipality, int year, int quality){ } ddQuality.put(key, qualities); } else { - Map qualities = new HashMap<>(); + Map qualities = new LinkedHashMap<>(); qualities.put(quality, 1f); ddQuality.put(key, qualities); } } else { - ddQuality = new HashMap<>(); - Map qualities = new HashMap<>(); + ddQuality = new LinkedHashMap<>(); + Map qualities = new LinkedHashMap<>(); qualities.put(quality, 1f); ddQuality.put(key, qualities); } @@ -228,7 +228,7 @@ private DwellingType extractDwellingType (int buildingYear, float ddType1Prob, f private int selectQualityVacant(int municipality, int year){ int result = 0; if (ddQuality.get(year * 10000000 + municipality) == null) { - HashMap qualities = new HashMap<>(); + HashMap qualities = new LinkedHashMap<>(); for (int quality = 1; quality <= PropertiesSynPop.get().main.numberofQualityLevels; quality++){ qualities.put(quality, 1f); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateDwellingMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateDwellingMicrolocation.java index 40fa6fbff..0257844bd 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateDwellingMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateDwellingMicrolocation.java @@ -23,9 +23,9 @@ public class GenerateDwellingMicrolocation { private static final Logger logger = LogManager.getLogger(GenerateDwellingMicrolocation.class); private final DataContainer dataContainer; private final DataSetSynPop dataSetSynPop; - private final Map buildingCoord = new HashMap<>(); - private final Map>> zone2ddType2buildingIdMap = new HashMap<>(); - Map buildingZone = new HashMap<>(); + private final Map buildingCoord = new LinkedHashMap<>(); + private final Map>> zone2ddType2buildingIdMap = new LinkedHashMap<>(); + Map buildingZone = new LinkedHashMap<>(); public GenerateDwellingMicrolocation(DataContainer dataContainer, DataSetSynPop dataSetSynPop){ this.dataContainer = dataContainer; @@ -181,7 +181,7 @@ private void readBuidlingFile(String fileName) { buildingZone.put(id,zone); //put all buildings with the same zoneID into one building list zone2ddType2buildingIdMap.computeIfAbsent(zone, k -> { - Map> typeMap = new HashMap<>(); + Map> typeMap = new LinkedHashMap<>(); for (ManchesterDwellingTypes.DwellingTypeManchester type : ManchesterDwellingTypes.DwellingTypeManchester.values()) { typeMap.put(type.toString(), new ArrayList<>()); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateJobMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateJobMicrolocation.java index 2dd160d0a..acef23f88 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateJobMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateJobMicrolocation.java @@ -25,9 +25,9 @@ public class GenerateJobMicrolocation { private final DataContainer dataContainer; private final DataSetSynPop dataSetSynPop; - private final Map jobCoord = new HashMap<>(); - private final Map> zone2JobId2WeightMap = new HashMap<>(); - private final Map zoneLocationJobFactor = new HashMap<>(); + private final Map jobCoord = new LinkedHashMap<>(); + private final Map> zone2JobId2WeightMap = new LinkedHashMap<>(); + private final Map zoneLocationJobFactor = new LinkedHashMap<>(); public GenerateJobMicrolocation(DataContainer dataContainer, DataSetSynPop dataSetSynPop){ this.dataSetSynPop = dataSetSynPop; @@ -73,7 +73,7 @@ public void run() { private void calculateLocationJobFactor() { //total jobs in zone - Map zoneJobCounts = new HashMap<>(); + Map zoneJobCounts = new LinkedHashMap<>(); for(Job jj : dataContainer.getJobDataManager().getJobs()){ zoneJobCounts.merge(jj.getZoneId(), 1, Integer::sum); } @@ -153,7 +153,7 @@ private void readJobFile(String fileName) { jobCoord.put(id,coordinate); //put all buildings with the same zoneID into one building list - zone2JobId2WeightMap.computeIfAbsent(zone, k -> new HashMap<>()).put(id, weight); + zone2JobId2WeightMap.computeIfAbsent(zone, k -> new LinkedHashMap<>()).put(id, weight); } if(noCoordCounter > 0) { diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateSchoolMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateSchoolMicrolocation.java index dbdc2686d..e5cdf2691 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateSchoolMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/microlocation/GenerateSchoolMicrolocation.java @@ -16,6 +16,7 @@ import org.locationtech.jts.geom.Coordinate; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateSchoolMicrolocation { @@ -24,7 +25,7 @@ public class GenerateSchoolMicrolocation { private final DataContainerWithSchools dataContainer; private final DataSetSynPop dataSetSynPop; - Map>> zoneSchoolTypeSchoolLocationCapacity = new HashMap<>(); + Map>> zoneSchoolTypeSchoolLocationCapacity = new LinkedHashMap<>(); public GenerateSchoolMicrolocation(DataContainerWithSchools dataContainer, DataSetSynPop dataSetSynPop){ @@ -74,9 +75,9 @@ public void run() { private void createSchools() { for (int zone : dataSetSynPop.getTazs()){ - Map> schoolLocationListForThisSchoolType = new HashMap<>(); + Map> schoolLocationListForThisSchoolType = new LinkedHashMap<>(); for (int type = 1 ; type <= 3; type++){ - Map schoolCapacity = new HashMap<>(); + Map schoolCapacity = new LinkedHashMap<>(); schoolLocationListForThisSchoolType.put(type,schoolCapacity); } zoneSchoolTypeSchoolLocationCapacity.put(zone,schoolLocationListForThisSchoolType); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/CheckHouseholdRelationship.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/CheckHouseholdRelationship.java index 7365a3e8e..677dfe3d7 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/CheckHouseholdRelationship.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/CheckHouseholdRelationship.java @@ -7,6 +7,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class CheckHouseholdRelationship { @@ -322,10 +323,10 @@ private void initialize(){ SiloUtil.addIntegerColumnToTableDataSet(microDataPerson, "rearrangedRole"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold,"nonClassifiedMales"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold, "nonClassifiedFemales"*//*);*/ - childrenInHousehold = new HashMap<>(); - noClass = new HashMap<>(); - singles = new HashMap<>(); - married = new HashMap<>(); + childrenInHousehold = new LinkedHashMap<>(); + noClass = new LinkedHashMap<>(); + singles = new LinkedHashMap<>(); + married = new LinkedHashMap<>(); } @@ -344,7 +345,7 @@ private HashMap> updateInnerMap(HashMap inner = outer.get(key); if (inner == null){ - inner = new HashMap(); + inner = new LinkedHashMap(); outer.put(key, inner); } inner.put(row, age); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/MicroDataManager.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/MicroDataManager.java index 9dec49dad..2a8a743af 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/MicroDataManager.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/MicroDataManager.java @@ -13,6 +13,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class MicroDataManager { @@ -26,7 +27,7 @@ public class MicroDataManager { public HashMap attributesMicroData(){ - HashMap attributesMicroData = new HashMap<>(); + HashMap attributesMicroData = new LinkedHashMap<>(); String[] attributesPerson = {"age", "gender", "occupation", "income", "nationality", "telework", "ppPrivate", "educationDegree", "personStatus", "spouseInHousehold", "marriage", "relationship", "school"}; String[] attributesHousehold = {"workers", "hhSize"}; String[] attributesDwelling = {"ddUse", "ddYear", "ddFloor", "ddSize", "ddHeatingEnergy", "ddHeatingType", "ddAdHeating"}; @@ -39,62 +40,62 @@ public HashMap attributesMicroData(){ public Map> attributesPersonMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map age = new HashMap<>(); + Map age = new LinkedHashMap<>(); age.put("initial", 50); age.put("end", 52); attributesIPU.put("age", age); - Map gender = new HashMap<>(); + Map gender = new LinkedHashMap<>(); gender.put("initial", 54); gender.put("end", 55); attributesIPU.put("gender", gender); - Map occupation = new HashMap<>(); + Map occupation = new LinkedHashMap<>(); occupation.put("initial", 32); occupation.put("end", 33); attributesIPU.put("occupation", occupation); - Map nationality = new HashMap<>(); + Map nationality = new LinkedHashMap<>(); nationality.put("initial", 370); nationality.put("end", 372); attributesIPU.put("nationality", nationality); //Additional attributes - Map income = new HashMap<>(); + Map income = new LinkedHashMap<>(); income.put("initial", 471); income.put("end", 473); attributesIPU.put("income", income); - Map telework = new HashMap<>(); + Map telework = new LinkedHashMap<>(); telework.put("initial", 198); telework.put("end", 200); attributesIPU.put("telework", telework); - Map ppPrivate = new HashMap<>(); + Map ppPrivate = new LinkedHashMap<>(); ppPrivate.put("initial", 34); ppPrivate.put("end", 35); attributesIPU.put("ppPrivate", ppPrivate); - Map educationDegree = new HashMap<>(); + Map educationDegree = new LinkedHashMap<>(); educationDegree.put("initial", 323); educationDegree.put("end", 325); attributesIPU.put("educationDegree", educationDegree); - Map status = new HashMap<>(); + Map status = new LinkedHashMap<>(); status.put("initial", 40); status.put("end", 42); attributesIPU.put("personStatus", status); - Map spouse = new HashMap<>(); + Map spouse = new LinkedHashMap<>(); spouse.put("initial", 36); spouse.put("end", 38); attributesIPU.put("spouseInHousehold", spouse); - Map marriage = new HashMap<>(); + Map marriage = new LinkedHashMap<>(); marriage.put("initial", 59); marriage.put("end", 60); attributesIPU.put("marriage", marriage); - Map relationship = new HashMap<>(); + Map relationship = new LinkedHashMap<>(); relationship.put("initial", 566); relationship.put("end", 568); attributesIPU.put("relationship", relationship); - Map school = new HashMap<>(); + Map school = new LinkedHashMap<>(); school.put("initial", 307); school.put("end", 309); attributesIPU.put("school", school); - Map disability = new HashMap<>(); + Map disability = new LinkedHashMap<>(); disability.put("initial", 237); disability.put("end", 239); attributesIPU.put("disability", disability); @@ -104,14 +105,14 @@ public Map> attributesPersonMicroData(){ public Map> attributesHouseholdMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map hhSize = new HashMap<>(); + Map hhSize = new LinkedHashMap<>(); hhSize.put("initial", 26); hhSize.put("end", 28); attributesIPU.put("hhSize", hhSize); //Additional attributes - Map workers = new HashMap<>(); + Map workers = new LinkedHashMap<>(); workers.put("initial", 572); workers.put("end", 574); attributesIPU.put("workers", workers); @@ -121,34 +122,34 @@ public Map> attributesHouseholdMicroData(){ public Map> attributesDwellingMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map ddUse = new HashMap<>(); + Map ddUse = new LinkedHashMap<>(); ddUse.put("initial", 493); ddUse.put("end", 495); attributesIPU.put("ddUse", ddUse); - Map ddYear = new HashMap<>(); + Map ddYear = new LinkedHashMap<>(); ddYear.put("initial", 500); ddYear.put("end", 502); attributesIPU.put("ddYear", ddYear); - Map ddFloor = new HashMap<>(); + Map ddFloor = new LinkedHashMap<>(); ddFloor.put("initial", 495); ddFloor.put("end", 498); attributesIPU.put("ddFloor", ddFloor); - Map ddSize = new HashMap<>(); + Map ddSize = new LinkedHashMap<>(); ddSize.put("initial", 491); ddSize.put("end", 493); attributesIPU.put("ddSize", ddSize); //Additional attributes - Map ddHeatingEnergy = new HashMap<>(); + Map ddHeatingEnergy = new LinkedHashMap<>(); ddHeatingEnergy.put("initial", 506); ddHeatingEnergy.put("end", 508); attributesIPU.put("ddHeatingEnergy", ddHeatingEnergy); - Map ddHeatingType = new HashMap<>(); + Map ddHeatingType = new LinkedHashMap<>(); ddHeatingType.put("initial", 504); ddHeatingType.put("end", 506); attributesIPU.put("ddHeatingType", ddHeatingType); - Map ddAdHeating = new HashMap<>(); + Map ddAdHeating = new LinkedHashMap<>(); ddAdHeating.put("initial", 1017); ddAdHeating.put("end", 1019); attributesIPU.put("ddAdHeating", ddAdHeating); @@ -157,108 +158,108 @@ public Map> attributesDwellingMicroData(){ public Map> exceptionsMicroData(){ - Map> exceptionsMicroData = new HashMap<>(); - Map LivingInQuarter = new HashMap<>(); + Map> exceptionsMicroData = new LinkedHashMap<>(); + Map LivingInQuarter = new LinkedHashMap<>(); LivingInQuarter.put("initial", 34); LivingInQuarter.put("end", 35); LivingInQuarter.put("exceptionIf", 2); exceptionsMicroData.put("quarter", LivingInQuarter); - Map noIncome = new HashMap<>(); + Map noIncome = new LinkedHashMap<>(); noIncome.put("initial", 658); noIncome.put("end", 660); noIncome.put("exceptionIf", 99); exceptionsMicroData.put("noIncome", noIncome); - Map movingOutInFiveYears = new HashMap<>(); + Map movingOutInFiveYears = new LinkedHashMap<>(); movingOutInFiveYears.put("initial", 491); movingOutInFiveYears.put("end", 493); movingOutInFiveYears.put("exceptionIf", -5); exceptionsMicroData.put("movedOut", movingOutInFiveYears); - Map noBuildingSize = new HashMap<>(); + Map noBuildingSize = new LinkedHashMap<>(); noBuildingSize.put("initial", 491); noBuildingSize.put("end", 493); noBuildingSize.put("exceptionIf", 9); exceptionsMicroData.put("noSize", noBuildingSize); - Map noDwellingUsage = new HashMap<>(); + Map noDwellingUsage = new LinkedHashMap<>(); noDwellingUsage.put("initial", 493); noDwellingUsage.put("end", 495); noDwellingUsage.put("exceptionIf", 9); exceptionsMicroData.put("noUsage", noDwellingUsage); - Map noBuildingYear = new HashMap<>(); + Map noBuildingYear = new LinkedHashMap<>(); noBuildingYear.put("initial", 500); noBuildingYear.put("end", 502); noBuildingYear.put("exceptionIf", 99); exceptionsMicroData.put("noYear", noBuildingYear); - Map SchleswigHolstein = new HashMap<>(); + Map SchleswigHolstein = new LinkedHashMap<>(); SchleswigHolstein.put("initial", 0); SchleswigHolstein.put("end", 2); SchleswigHolstein.put("exceptionIf", 1); exceptionsMicroData.put("out1", SchleswigHolstein); - Map Hamburg = new HashMap<>(); + Map Hamburg = new LinkedHashMap<>(); Hamburg.put("initial", 0); Hamburg.put("end", 2); Hamburg.put("exceptionIf", 2); exceptionsMicroData.put("out2", Hamburg); - Map Niedersachsen = new HashMap<>(); + Map Niedersachsen = new LinkedHashMap<>(); Niedersachsen.put("initial", 0); Niedersachsen.put("end", 2); Niedersachsen.put("exceptionIf", 3); exceptionsMicroData.put("out3", Niedersachsen); - Map Bremen = new HashMap<>(); + Map Bremen = new LinkedHashMap<>(); Bremen.put("initial", 0); Bremen.put("end", 2); Bremen.put("exceptionIf", 4); exceptionsMicroData.put("out4", Bremen); - Map NordrheinWestfalen = new HashMap<>(); + Map NordrheinWestfalen = new LinkedHashMap<>(); NordrheinWestfalen.put("initial", 0); NordrheinWestfalen.put("end", 2); NordrheinWestfalen.put("exceptionIf", 5); exceptionsMicroData.put("out5", NordrheinWestfalen); - Map Hessen = new HashMap<>(); + Map Hessen = new LinkedHashMap<>(); Hessen.put("initial", 0); Hessen.put("end", 2); Hessen.put("exceptionIf", 6); exceptionsMicroData.put("out6", Hessen); - Map RheinlandPfalz = new HashMap<>(); + Map RheinlandPfalz = new LinkedHashMap<>(); RheinlandPfalz.put("initial", 0); RheinlandPfalz.put("end", 2); RheinlandPfalz.put("exceptionIf", 7); exceptionsMicroData.put("out7", RheinlandPfalz); - Map BadenWuerttemberg = new HashMap<>(); + Map BadenWuerttemberg = new LinkedHashMap<>(); BadenWuerttemberg.put("initial", 0); BadenWuerttemberg.put("end", 2); BadenWuerttemberg.put("exceptionIf", 8); exceptionsMicroData.put("out8", BadenWuerttemberg); - Map Saarland = new HashMap<>(); + Map Saarland = new LinkedHashMap<>(); Saarland.put("initial", 0); Saarland.put("end", 2); Saarland.put("exceptionIf", 10); exceptionsMicroData.put("out10", Saarland); - Map Berlin = new HashMap<>(); + Map Berlin = new LinkedHashMap<>(); Berlin.put("initial", 0); Berlin.put("end", 2); Berlin.put("exceptionIf", 11); exceptionsMicroData.put("out11", Berlin); - Map Brandenburg = new HashMap<>(); + Map Brandenburg = new LinkedHashMap<>(); Brandenburg.put("initial", 0); Brandenburg.put("end", 2); Brandenburg.put("exceptionIf", 12); exceptionsMicroData.put("out12", Brandenburg); - Map MecklenburgVorpommern = new HashMap<>(); + Map MecklenburgVorpommern = new LinkedHashMap<>(); MecklenburgVorpommern.put("initial", 0); MecklenburgVorpommern.put("end", 2); MecklenburgVorpommern.put("exceptionIf", 13); exceptionsMicroData.put("out13", MecklenburgVorpommern); - Map Sachsen = new HashMap<>(); + Map Sachsen = new LinkedHashMap<>(); Sachsen.put("initial", 0); Sachsen.put("end", 2); Sachsen.put("exceptionIf", 14); exceptionsMicroData.put("out14", Sachsen); - Map SachsenAnhalt = new HashMap<>(); + Map SachsenAnhalt = new LinkedHashMap<>(); SachsenAnhalt.put("initial", 0); SachsenAnhalt.put("end", 2); SachsenAnhalt.put("exceptionIf", 15); exceptionsMicroData.put("out15", SachsenAnhalt); - Map Thueringen = new HashMap<>(); + Map Thueringen = new LinkedHashMap<>(); Thueringen.put("initial", 0); Thueringen.put("end", 2); Thueringen.put("exceptionIf", 16); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/ReadZonalData.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/ReadZonalData.java index 63be301b1..913481f30 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/ReadZonalData.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/manchester/preparation/ReadZonalData.java @@ -21,6 +21,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class ReadZonalData { @@ -54,17 +55,17 @@ private void readCities() { //List of municipalities and counties that are used for IPU and allocation ArrayList municipalities = new ArrayList<>(); ArrayList counties = new ArrayList<>(); - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); ArrayList municipalitiesWithZero = new ArrayList<>(); - HashMap> attributesLSOA = new HashMap<>(); + HashMap> attributesLSOA = new LinkedHashMap<>(); for (int row = 1; row <= PropertiesSynPop.get().main.selectedMunicipalities.getRowCount(); row++) { int city = (int) PropertiesSynPop.get().main.selectedMunicipalities.getValueAt(row, "lsoaID"); float totalJobs = PropertiesSynPop.get().main.selectedMunicipalities.getValueAt(row, "tot"); float percentageVacantDwellings = PropertiesSynPop.get().main.selectedMunicipalities.getValueAt(row, "percentageVacantDwellings"); - HashMap attributes = new HashMap<>(); + HashMap attributes = new LinkedHashMap<>(); attributes.put("tot", totalJobs); attributes.put("percentageVacantDwellings", percentageVacantDwellings); @@ -111,17 +112,17 @@ private void readCities() { private void readZones(){ //TAZ attributes - HashMap cityTAZ = new HashMap<>(); - Map> probabilityZone = new HashMap<>(); - Map>> probabilityZoneByDdType = new HashMap<>(); + HashMap cityTAZ = new LinkedHashMap<>(); + Map> probabilityZone = new LinkedHashMap<>(); + Map>> probabilityZoneByDdType = new LinkedHashMap<>(); Table schoolCapacity = HashBasedTable.create(); - Map> dwellingPriceByTypeAndZone = new HashMap<>(); + Map> dwellingPriceByTypeAndZone = new LinkedHashMap<>(); ArrayList tazs = new ArrayList<>(); ArrayList areas = new ArrayList<>(); TableDataSet zoneAttributes = PropertiesSynPop.get().main.cellsMatrix; - HashMap> attributesZone = new HashMap<>(); - HashMap tazCity = new HashMap<>(); + HashMap> attributesZone = new LinkedHashMap<>(); + HashMap tazCity = new LinkedHashMap<>(); for (int i = 1; i <= zoneAttributes.getRowCount(); i++){ int city = (int) zoneAttributes.getValueAt(i,"lsoaID"); int taz = (int) zoneAttributes.getValueAt(i,"oaID"); @@ -155,15 +156,15 @@ private void readZones(){ } else { int[] previousTaz = {taz}; cityTAZ.put(city,previousTaz); - Map probabilities = new HashMap<>(); + Map probabilities = new LinkedHashMap<>(); probabilities.put(taz, population); probabilityZone.put(city, probabilities); } if(!probabilityZoneByDdType.containsKey(city)){ - probabilityZoneByDdType.put(city, new HashMap<>() ); + probabilityZoneByDdType.put(city, new LinkedHashMap<>() ); for(ManchesterDwellingTypes.DwellingTypeManchester ddType : ManchesterDwellingTypes.DwellingTypeManchester.values()){ - probabilityZoneByDdType.get(city).put(ddType, new HashMap<>()); + probabilityZoneByDdType.get(city).put(ddType, new LinkedHashMap<>()); } } @@ -176,7 +177,7 @@ private void readZones(){ schoolCapacity.put(taz,2,capacitySecondarySchool); schoolCapacity.put(taz,3,capacityHigherEducation); - HashMap Attributes = new HashMap<>(); + HashMap Attributes = new LinkedHashMap<>(); Attributes.put("households", households); Attributes.put("tot",commuteInflow); Attributes.put("popCentroid_x",popCentroid_x); @@ -218,7 +219,7 @@ private void readCarOwnershipMatrix(){ //Read the commuteFlow logger.info(" Starting to read CSV matrix for car ownership"); TableDataSet carOwnership = SiloUtil.readCSVfile(((ManchesterPropertiesSynPop)PropertiesSynPop.get().main).carOwnershipFile); - Map>> probability = new HashMap<>(); + Map>> probability = new LinkedHashMap<>(); @@ -228,8 +229,8 @@ private void readCarOwnershipMatrix(){ int car = (int) carOwnership.getValueAt(row, "carCode"); float value = carOwnership.getValueAt(row, "Observation"); - probability.computeIfAbsent(lsoaID, k -> new HashMap<>()) - .computeIfAbsent(hhsize, k -> new HashMap<>()) + probability.computeIfAbsent(lsoaID, k -> new LinkedHashMap<>()) + .computeIfAbsent(hhsize, k -> new LinkedHashMap<>()) .put(car, value); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/CreateFreeFlowCarSkim.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/CreateFreeFlowCarSkim.java index d98002838..61a96d0eb 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/CreateFreeFlowCarSkim.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/CreateFreeFlowCarSkim.java @@ -62,7 +62,7 @@ // }); // // -// final Map zoneCalculationNodesMap = new HashMap<>(); +// final Map zoneCalculationNodesMap = new LinkedHashMap<>(); // for (Zone zone : zones) { // Coordinate coordinate = zone.getRandomCoordinate(); // Coord originCoord = new Coord(coordinate.x, coordinate.y); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/SyntheticPopUs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/SyntheticPopUs.java index 6458657cb..1bd5b63ae 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/SyntheticPopUs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/maryland/SyntheticPopUs.java @@ -158,7 +158,7 @@ public void runSP () { private void identifyUniquePUMAzones() { // walk through list of zones and collect unique PUMA zone IDs within the study area - tazByPuma = new HashMap<>(); + tazByPuma = new LinkedHashMap<>(); ArrayList alHomePuma = new ArrayList<>(); ArrayList alWorkPuma = new ArrayList<>(); for (Zone zone: geoData.getZones().values()) { @@ -189,7 +189,7 @@ private void readControlTotals () { logger.info(" Reading control total data for households and dwellings"); // TableDataSet pop = SiloUtil.readCSVfile(Properties.get().main.baseDirectory + ResourceUtil.getProperty(rb, PROPERTIES_HOUSEHOLD_CONTROL_TOTAL)); - householdTarget = new HashMap<>(); + householdTarget = new LinkedHashMap<>(); // for (int row = 1; row <= pop.getRowCount(); row++) { // String fips = String.valueOf(pop.getValueAt(row, "Fips")); // // note: doesn't make much sense to store these data in a HashMap. It's legacy code. @@ -211,7 +211,7 @@ private void createJobs () { // jobInventory by [industry][taz] final int highestZoneId = geoData.getZones().keySet().stream().max(Comparator.naturalOrder()).get(); float[][] jobInventory = new float[JobType.getNumberOfJobTypes()][highestZoneId + 1]; - tazByWorkZonePuma = new HashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined + tazByWorkZonePuma = new LinkedHashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined // read employment data // For reasons that are not explained in the documentation, some of the PUMA work zones were aggregated to the @@ -255,7 +255,7 @@ private void identifyVacantJobsByZone () { // populate HashMap with Jobs by zone logger.info(" Identifying vacant jobs by zone"); - vacantJobsByZone = new HashMap<>(); + vacantJobsByZone = new LinkedHashMap<>(); Collection jobs = jobData.getJobs(); for (Job jj: jobs) { if (jj.getWorkerId() == -1) { @@ -290,11 +290,11 @@ private void processPums() { String[] states = {"md","dc","de","nj","pa","va","wv"}; - jobErrorCounter = new HashMap<>(); + jobErrorCounter = new LinkedHashMap<>(); for (String state : states) { - Map relationsHipsByPerson = new HashMap<>(); - Map> households = new HashMap<>(); + Map relationsHipsByPerson = new LinkedHashMap<>(); + Map> households = new LinkedHashMap<>(); String pumsHhFileName = baseDirectory + ResourceUtil.getProperty(rb, PROPERTIES_PUMS_FILES) + "ss16h" + state + ".csv"; @@ -778,7 +778,7 @@ private int selectWorkplaceByTripLengthFrequencyDistribution (int workPumaZone, return -2; // person does work in puma zone outside of study area } - Map zoneProbabilities = new HashMap<>(); + Map zoneProbabilities = new LinkedHashMap<>(); for (Zone zone: geoData.getZones().values()) { if (vacantJobsByZone.containsKey(zone.getZoneId())) { int numberOfJobsInThisZone = vacantJobsByZone.get(zone.getZoneId()).length; @@ -943,7 +943,7 @@ private void generateAutoOwnership (DataContainer dataContainer) { // select number of cars for every household dataContainer.getJobDataManager().setup(); MaryLandUpdateCarOwnershipModel ao = new MaryLandUpdateCarOwnershipModel(dataContainer, accessibility, Properties.get(), SiloUtil.provideNewRandom()); // calculate auto-ownership probabilities - Map households = new HashMap<>(); + Map households = new LinkedHashMap<>(); for (Household hh: householdData.getHouseholds()) { households.put(hh.getId(), null); } @@ -956,7 +956,7 @@ private void addVacantDwellings () { logger.info(" Adding empty dwellings to match vacancy rate"); List dwellingTypes = realEstateData.getDwellingTypes().getTypes(); - HashMap> ddPointer = new HashMap<>(); + HashMap> ddPointer = new LinkedHashMap<>(); // summarize vacancy final int highestZoneId = geoData.getZones().keySet().stream().max(Comparator.naturalOrder()).get(); int[][][] ddCount = new int [highestZoneId + 1][DefaultDwellingTypes.DefaultDwellingTypeImpl.values().length][2]; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/Allocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/Allocation.java index ce7474fbd..fdae8175b 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/Allocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/Allocation.java @@ -11,6 +11,7 @@ import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; public class Allocation extends ModuleSynPop{ @@ -54,7 +55,7 @@ public void generateHouseholdsPersonsDwellings(){ addBoroughsAsCities(county); } } - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new GenerateHouseholdsPersonsDwellings(dataContainer, dataSetSynPop, educationalLevel).run(); if (PropertiesSynPop.get().main.boroughIPU){ for (int county : dataSetSynPop.getBoroughsByCounty().keySet()){ @@ -76,7 +77,7 @@ public void assignSchools(){ } public void readPopulation(){ - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new ReadPopulation(dataContainer, educationalLevel).run(); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignJobs.java index 785075db1..19320101e 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignJobs.java @@ -138,18 +138,18 @@ private void identifyVacantJobsByZoneType() { Collection jobs = dataContainer.getJobDataManager().getJobs(); jobStringTypes = PropertiesSynPop.get().main.jobStringType; - jobIntTypes = new HashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++) { jobIntTypes.put(PropertiesSynPop.get().main.jobStringType[i], i); } tazIds = dataSetSynPop.getTazs().stream().mapToInt(i -> i).toArray(); - idVacantJobsByZoneType = new HashMap<>(); - numberVacantJobsByType = new HashMap<>(); - idZonesVacantJobsByType = new HashMap<>(); - numberZonesByType = new HashMap<>(); - numberVacantJobsByZoneByType = new HashMap<>(); - jobIntTypes = new HashMap<>(); + idVacantJobsByZoneType = new LinkedHashMap<>(); + numberVacantJobsByType = new LinkedHashMap<>(); + idZonesVacantJobsByType = new LinkedHashMap<>(); + numberZonesByType = new LinkedHashMap<>(); + numberVacantJobsByZoneByType = new LinkedHashMap<>(); + jobIntTypes = new LinkedHashMap<>(); for (int i = 0; i < PropertiesSynPop.get().main.jobStringType.length; i++) { jobIntTypes.put(PropertiesSynPop.get().main.jobStringType[i], i); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignPropertiesToJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignPropertiesToJobs.java index d50db91ea..6ed4e654a 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignPropertiesToJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignPropertiesToJobs.java @@ -96,10 +96,10 @@ private void setDurationAndStartTime(Person pp){ private void readCoefficients() { /*coefficients = PropertiesSynPop.get().main.fullTimeProbabilityTable; coefficients.buildStringIndex(1);*/ - coefficientsFullTime = new HashMap<>(); - coefficientsDuration = new HashMap<>(); - coefficientsStartTimeWeekend = new HashMap<>(); - coefficientsStartTimeWorkday = new HashMap<>(); + coefficientsFullTime = new LinkedHashMap<>(); + coefficientsDuration = new LinkedHashMap<>(); + coefficientsStartTimeWeekend = new LinkedHashMap<>(); + coefficientsStartTimeWorkday = new LinkedHashMap<>(); for (String jobType : PropertiesSynPop.get().main.jobStringType) { Map coefficientsByJobType = diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignSchools.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignSchools.java index 2e2c0318b..cabf00075 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignSchools.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/AssignSchools.java @@ -96,7 +96,7 @@ private int selectTertiarySchool(int hometaz){ int schooltaz = -2; if (numberOfVacantPlacesByType.get(3) > 0) { - Map probability = new HashMap<>(); + Map probability = new LinkedHashMap<>(); Iterator iterator = schoolCapacityMap.get(3).keySet().iterator(); while (iterator.hasNext()) { Integer zone = iterator.next(); @@ -160,8 +160,8 @@ private void shuffleStudents(){ private void initializeSchoolCapacity(){ - schoolCapacityMap = new HashMap<>(); - numberOfVacantPlacesByType = new HashMap<>(); + schoolCapacityMap = new LinkedHashMap<>(); + numberOfVacantPlacesByType = new LinkedHashMap<>(); Table schoolCapacity = dataSetSynPop.getSchoolCapacity(); Iterator iteratorRow = schoolCapacity.rowKeySet().iterator(); while (iteratorRow.hasNext()){ @@ -171,7 +171,7 @@ private void initializeSchoolCapacity(){ int schoolType = iteratorCol.next(); int places = schoolCapacity.get(zone, schoolType); if (places > 0) { - Map prevPlaces = new HashMap<>(); + Map prevPlaces = new LinkedHashMap<>(); if (schoolCapacityMap.get(schoolType)!= null) { prevPlaces = schoolCapacityMap.get(schoolType); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateHouseholdsPersonsDwellings.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateHouseholdsPersonsDwellings.java index 47ac84531..c67d7e8f0 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateHouseholdsPersonsDwellings.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateHouseholdsPersonsDwellings.java @@ -15,6 +15,7 @@ import java.util.Arrays; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateHouseholdsPersonsDwellings { @@ -174,7 +175,7 @@ private void initializeMunicipalityData(int municipality){ ddTypeProbOfSFAorSFD = PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality,"ddProbSFAorSFD"); ddTypeProbOfMF234orMF5plus = PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality,"ddProbMF234orMF5plus"); probTAZ = dataSetSynPop.getProbabilityZone().get(municipality); - probMicroData = new HashMap<>(); + probMicroData = new LinkedHashMap<>(); probabilityId = new double[dataSetSynPop.getWeights().getRowCount()]; ids = new int[probabilityId.length]; sumProbabilities = 0; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateJobs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateJobs.java index 82c8460ea..e0f14982c 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateJobs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateJobs.java @@ -10,6 +10,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateJobs { @@ -58,7 +59,7 @@ private void generateJobsByTypeAtMunicipalityWithReplacement(int municipality, S private void initializeTAZprobability(int municipality, String jobType){ - jobsByTaz = new HashMap<>(); + jobsByTaz = new LinkedHashMap<>(); jobsByTaz.clear(); for (int taz : dataSetSynPop.getTazByMunicipality().get(municipality)){ jobsByTaz.put(taz, PropertiesSynPop.get().main.cellsMatrix.getIndexedValueAt(taz, jobType)); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateVacantDwellings.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateVacantDwellings.java index 43602a00d..388fcd47e 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateVacantDwellings.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/allocation/GenerateVacantDwellings.java @@ -11,6 +11,7 @@ import java.util.Arrays; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateVacantDwellings { @@ -92,11 +93,11 @@ private void generateVacantDwellings(){ private void initializeVacantDwellingData(int municipality){ - probVacantFloor = new HashMap<>(); + probVacantFloor = new LinkedHashMap<>(); for (int floor : PropertiesSynPop.get().main.sizeBracketsDwelling) { probVacantFloor.put(floor, PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, "vacantDwellings" + floor)); } - probVacantBuildingSize = new HashMap<>(); + probVacantBuildingSize = new LinkedHashMap<>(); for (int year : PropertiesSynPop.get().main.yearBracketsDwelling){ int sizeYear = year; String label = "vacantSmallDwellings" + year; @@ -133,13 +134,13 @@ private void updateQualityMap(int municipality, int year, int quality){ } ddQuality.put(key, qualities); } else { - Map qualities = new HashMap<>(); + Map qualities = new LinkedHashMap<>(); qualities.put(quality, 1f); ddQuality.put(key, qualities); } } else { - ddQuality = new HashMap<>(); - Map qualities = new HashMap<>(); + ddQuality = new LinkedHashMap<>(); + Map qualities = new LinkedHashMap<>(); qualities.put(quality, 1f); ddQuality.put(key, qualities); } @@ -212,7 +213,7 @@ private DwellingType extractDwellingType (int buildingYear, float ddType1Prob, f private int selectQualityVacant(int municipality, int year){ int result = 0; if (ddQuality.get(year * 10000000 + municipality) == null) { - HashMap qualities = new HashMap<>(); + HashMap qualities = new LinkedHashMap<>(); for (int quality = 1; quality <= PropertiesSynPop.get().main.numberofQualityLevels; quality++){ qualities.put(quality, 1f); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateDwellingMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateDwellingMicrolocation.java index 2a9f8e63e..9dbb33f43 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateDwellingMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateDwellingMicrolocation.java @@ -12,6 +12,7 @@ import java.util.Collection; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateDwellingMicrolocation { @@ -20,13 +21,13 @@ public class GenerateDwellingMicrolocation { private static final double PENALTY = 0.5; private final DataContainer dataContainer; private final DataSetSynPop dataSetSynPop; - private HashMap buildingX = new HashMap<>(); - private HashMap buildingY = new HashMap<>(); - private HashMap> zoneBuildingMap = new HashMap<>(); - Map buildingZone = new HashMap(); - Map buildingArea = new HashMap<>(); - Map zoneDensity = new HashMap<>(); - Map dwellingsInTAZ = new HashMap(); + private HashMap buildingX = new LinkedHashMap<>(); + private HashMap buildingY = new LinkedHashMap<>(); + private HashMap> zoneBuildingMap = new LinkedHashMap<>(); + Map buildingZone = new LinkedHashMap(); + Map buildingArea = new LinkedHashMap<>(); + Map zoneDensity = new LinkedHashMap<>(); + Map dwellingsInTAZ = new LinkedHashMap(); public GenerateDwellingMicrolocation(DataContainer dataContainer, DataSetSynPop dataSetSynPop){ this.dataSetSynPop = dataSetSynPop; @@ -79,7 +80,7 @@ private void readBuidlingFile() { buildingZone.put(id,zone); //put all buildings with the same zoneID into one building list if (zoneBuildingMap.get(zone) == null){ - HashMap buildingAreaList = new HashMap(); + HashMap buildingAreaList = new LinkedHashMap(); zoneBuildingMap.put(zone,buildingAreaList); } zoneBuildingMap.get(zone).put(id,area); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateJobMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateJobMicrolocation.java index a23864ac8..0f0baf9be 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateJobMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateJobMicrolocation.java @@ -14,6 +14,7 @@ import java.util.Collection; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateJobMicrolocation { @@ -22,12 +23,12 @@ public class GenerateJobMicrolocation { private final DataContainer dataContainer; private final DataSetSynPop dataSetSynPop; - private Map jobX = new HashMap<>(); - private Map jobY = new HashMap<>(); - Map jobZone = new HashMap(); - Map>> zoneJobTypeJobLocationArea = new HashMap<>(); - Map> zoneJobTypeDensity = new HashMap<>(); - Map> jobsByJobTypeInTAZ = new HashMap<>(); + private Map jobX = new LinkedHashMap<>(); + private Map jobY = new LinkedHashMap<>(); + Map jobZone = new LinkedHashMap(); + Map>> zoneJobTypeJobLocationArea = new LinkedHashMap<>(); + Map> zoneJobTypeDensity = new LinkedHashMap<>(); + Map> jobsByJobTypeInTAZ = new LinkedHashMap<>(); public GenerateJobMicrolocation(DataContainer dataContainer, DataSetSynPop dataSetSynPop){ this.dataSetSynPop = dataSetSynPop; @@ -69,9 +70,9 @@ public void run() { private void readJobFile() { for (int zone : dataSetSynPop.getTazs()){ - Map> jobLocationListForThisJobType = new HashMap<>(); + Map> jobLocationListForThisJobType = new LinkedHashMap<>(); for (String jobType : PropertiesSynPop.get().main.jobStringType){ - Map jobLocationAndArea = new HashMap<>(); + Map jobLocationAndArea = new LinkedHashMap<>(); jobLocationListForThisJobType.put(jobType,jobLocationAndArea); } zoneJobTypeJobLocationArea.put(zone,jobLocationListForThisJobType); @@ -121,8 +122,8 @@ private void readJobFile() { private void calculateDensity() { for (int zone : dataSetSynPop.getTazs()){ - Map jobsByJobType = new HashMap<>(); - Map densityByJobType = new HashMap<>(); + Map jobsByJobType = new LinkedHashMap<>(); + Map densityByJobType = new LinkedHashMap<>(); jobsByJobTypeInTAZ.put(zone,jobsByJobType); zoneJobTypeDensity.put(zone,densityByJobType); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateSchoolMicrolocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateSchoolMicrolocation.java index 98ce9d81a..42463e789 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateSchoolMicrolocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/GenerateSchoolMicrolocation.java @@ -13,6 +13,7 @@ import org.locationtech.jts.geom.Coordinate; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateSchoolMicrolocation { @@ -21,7 +22,7 @@ public class GenerateSchoolMicrolocation { private final DataContainerWithSchools dataContainer; private final DataSetSynPop dataSetSynPop; - Map>> zoneSchoolTypeSchoolLocationCapacity = new HashMap<>(); + Map>> zoneSchoolTypeSchoolLocationCapacity = new LinkedHashMap<>(); public GenerateSchoolMicrolocation(DataContainerWithSchools dataContainer, DataSetSynPop dataSetSynPop){ @@ -79,9 +80,9 @@ public void run() { private void createSchools() { for (int zone : dataSetSynPop.getTazs()){ - Map> schoolLocationListForThisSchoolType = new HashMap<>(); + Map> schoolLocationListForThisSchoolType = new LinkedHashMap<>(); for (int type = 1 ; type <= 3; type++){ - Map schoolCapacity = new HashMap<>(); + Map schoolCapacity = new LinkedHashMap<>(); schoolLocationListForThisSchoolType.put(type,schoolCapacity); } zoneSchoolTypeSchoolLocationCapacity.put(zone,schoolLocationListForThisSchoolType); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/Microlocation.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/Microlocation.java index 3489c209c..ec747133f 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/Microlocation.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/microlocation/Microlocation.java @@ -12,6 +12,7 @@ import org.matsim.core.utils.gis.ShapeFileReader; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class Microlocation extends ModuleSynPop { @@ -28,7 +29,7 @@ public void run(){ logger.info(" Started microlocation model."); String zoneShapeFile = Properties.get().geo.zoneShapeFile; - Map zoneFeatureMap = new HashMap<>(); + Map zoneFeatureMap = new LinkedHashMap<>(); for (SimpleFeature feature: ShapeFileReader.getAllFeatures(zoneShapeFile)) { int zoneId = Integer.parseInt(feature.getAttribute("id").toString()); zoneFeatureMap.put(zoneId,feature); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/CheckHouseholdRelationship.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/CheckHouseholdRelationship.java index 4799d4a3f..135b05bd9 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/CheckHouseholdRelationship.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/CheckHouseholdRelationship.java @@ -7,6 +7,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class CheckHouseholdRelationship { @@ -312,10 +313,10 @@ private void initialize(){ SiloUtil.addIntegerColumnToTableDataSet(microDataPerson, "rearrangedRole"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold,"nonClassifiedMales"); SiloUtil.addIntegerColumnToTableDataSet(microDataHousehold, "nonClassifiedFemales"*//*);*/ - childrenInHousehold = new HashMap<>(); - noClass = new HashMap<>(); - singles = new HashMap<>(); - married = new HashMap<>(); + childrenInHousehold = new LinkedHashMap<>(); + noClass = new LinkedHashMap<>(); + singles = new LinkedHashMap<>(); + married = new LinkedHashMap<>(); } @@ -334,7 +335,7 @@ private HashMap> updateInnerMap(HashMap inner = outer.get(key); if (inner == null){ - inner = new HashMap(); + inner = new LinkedHashMap(); outer.put(key, inner); } inner.put(row, age); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/MicroDataManager.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/MicroDataManager.java index ba4bc03de..dc6c7454e 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/MicroDataManager.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/MicroDataManager.java @@ -15,6 +15,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class MicroDataManager { @@ -28,7 +29,7 @@ public class MicroDataManager { public HashMap attributesMicroData(){ - HashMap attributesMicroData = new HashMap<>(); + HashMap attributesMicroData = new LinkedHashMap<>(); String[] attributesPerson = {"age", "gender", "occupation", "income", "nationality", "telework", "ppPrivate", "educationDegree", "personStatus", "spouseInHousehold", "marriage", "relationship", "school"}; String[] attributesHousehold = {"workers", "hhSize"}; String[] attributesDwelling = {"ddUse", "ddYear", "ddFloor", "ddSize", "ddHeatingEnergy", "ddHeatingType", "ddAdHeating"}; @@ -41,62 +42,62 @@ public HashMap attributesMicroData(){ public Map> attributesPersonMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map age = new HashMap<>(); + Map age = new LinkedHashMap<>(); age.put("initial", 50); age.put("end", 52); attributesIPU.put("age", age); - Map gender = new HashMap<>(); + Map gender = new LinkedHashMap<>(); gender.put("initial", 54); gender.put("end", 55); attributesIPU.put("gender", gender); - Map occupation = new HashMap<>(); + Map occupation = new LinkedHashMap<>(); occupation.put("initial", 32); occupation.put("end", 33); attributesIPU.put("occupation", occupation); - Map nationality = new HashMap<>(); + Map nationality = new LinkedHashMap<>(); nationality.put("initial", 370); nationality.put("end", 372); attributesIPU.put("nationality", nationality); //Additional attributes - Map income = new HashMap<>(); + Map income = new LinkedHashMap<>(); income.put("initial", 471); income.put("end", 473); attributesIPU.put("income", income); - Map telework = new HashMap<>(); + Map telework = new LinkedHashMap<>(); telework.put("initial", 198); telework.put("end", 200); attributesIPU.put("telework", telework); - Map ppPrivate = new HashMap<>(); + Map ppPrivate = new LinkedHashMap<>(); ppPrivate.put("initial", 34); ppPrivate.put("end", 35); attributesIPU.put("ppPrivate", ppPrivate); - Map educationDegree = new HashMap<>(); + Map educationDegree = new LinkedHashMap<>(); educationDegree.put("initial", 323); educationDegree.put("end", 325); attributesIPU.put("educationDegree", educationDegree); - Map status = new HashMap<>(); + Map status = new LinkedHashMap<>(); status.put("initial", 40); status.put("end", 42); attributesIPU.put("personStatus", status); - Map spouse = new HashMap<>(); + Map spouse = new LinkedHashMap<>(); spouse.put("initial", 36); spouse.put("end", 38); attributesIPU.put("spouseInHousehold", spouse); - Map marriage = new HashMap<>(); + Map marriage = new LinkedHashMap<>(); marriage.put("initial", 59); marriage.put("end", 60); attributesIPU.put("marriage", marriage); - Map relationship = new HashMap<>(); + Map relationship = new LinkedHashMap<>(); relationship.put("initial", 566); relationship.put("end", 568); attributesIPU.put("relationship", relationship); - Map school = new HashMap<>(); + Map school = new LinkedHashMap<>(); school.put("initial", 307); school.put("end", 309); attributesIPU.put("school", school); - Map disability = new HashMap<>(); + Map disability = new LinkedHashMap<>(); disability.put("initial", 237); disability.put("end", 239); attributesIPU.put("disability", disability); @@ -106,14 +107,14 @@ public Map> attributesPersonMicroData(){ public Map> attributesHouseholdMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map hhSize = new HashMap<>(); + Map hhSize = new LinkedHashMap<>(); hhSize.put("initial", 26); hhSize.put("end", 28); attributesIPU.put("hhSize", hhSize); //Additional attributes - Map workers = new HashMap<>(); + Map workers = new LinkedHashMap<>(); workers.put("initial", 572); workers.put("end", 574); attributesIPU.put("workers", workers); @@ -123,34 +124,34 @@ public Map> attributesHouseholdMicroData(){ public Map> attributesDwellingMicroData(){ - Map> attributesIPU = new HashMap<>(); + Map> attributesIPU = new LinkedHashMap<>(); //IPU attributes - Map ddUse = new HashMap<>(); + Map ddUse = new LinkedHashMap<>(); ddUse.put("initial", 493); ddUse.put("end", 495); attributesIPU.put("ddUse", ddUse); - Map ddYear = new HashMap<>(); + Map ddYear = new LinkedHashMap<>(); ddYear.put("initial", 500); ddYear.put("end", 502); attributesIPU.put("ddYear", ddYear); - Map ddFloor = new HashMap<>(); + Map ddFloor = new LinkedHashMap<>(); ddFloor.put("initial", 495); ddFloor.put("end", 498); attributesIPU.put("ddFloor", ddFloor); - Map ddSize = new HashMap<>(); + Map ddSize = new LinkedHashMap<>(); ddSize.put("initial", 491); ddSize.put("end", 493); attributesIPU.put("ddSize", ddSize); //Additional attributes - Map ddHeatingEnergy = new HashMap<>(); + Map ddHeatingEnergy = new LinkedHashMap<>(); ddHeatingEnergy.put("initial", 506); ddHeatingEnergy.put("end", 508); attributesIPU.put("ddHeatingEnergy", ddHeatingEnergy); - Map ddHeatingType = new HashMap<>(); + Map ddHeatingType = new LinkedHashMap<>(); ddHeatingType.put("initial", 504); ddHeatingType.put("end", 506); attributesIPU.put("ddHeatingType", ddHeatingType); - Map ddAdHeating = new HashMap<>(); + Map ddAdHeating = new LinkedHashMap<>(); ddAdHeating.put("initial", 1017); ddAdHeating.put("end", 1019); attributesIPU.put("ddAdHeating", ddAdHeating); @@ -159,108 +160,108 @@ public Map> attributesDwellingMicroData(){ public Map> exceptionsMicroData(){ - Map> exceptionsMicroData = new HashMap<>(); - Map LivingInQuarter = new HashMap<>(); + Map> exceptionsMicroData = new LinkedHashMap<>(); + Map LivingInQuarter = new LinkedHashMap<>(); LivingInQuarter.put("initial", 34); LivingInQuarter.put("end", 35); LivingInQuarter.put("exceptionIf", 2); exceptionsMicroData.put("quarter", LivingInQuarter); - Map noIncome = new HashMap<>(); + Map noIncome = new LinkedHashMap<>(); noIncome.put("initial", 658); noIncome.put("end", 660); noIncome.put("exceptionIf", 99); exceptionsMicroData.put("noIncome", noIncome); - Map movingOutInFiveYears = new HashMap<>(); + Map movingOutInFiveYears = new LinkedHashMap<>(); movingOutInFiveYears.put("initial", 491); movingOutInFiveYears.put("end", 493); movingOutInFiveYears.put("exceptionIf", -5); exceptionsMicroData.put("movedOut", movingOutInFiveYears); - Map noBuildingSize = new HashMap<>(); + Map noBuildingSize = new LinkedHashMap<>(); noBuildingSize.put("initial", 491); noBuildingSize.put("end", 493); noBuildingSize.put("exceptionIf", 9); exceptionsMicroData.put("noSize", noBuildingSize); - Map noDwellingUsage = new HashMap<>(); + Map noDwellingUsage = new LinkedHashMap<>(); noDwellingUsage.put("initial", 493); noDwellingUsage.put("end", 495); noDwellingUsage.put("exceptionIf", 9); exceptionsMicroData.put("noUsage", noDwellingUsage); - Map noBuildingYear = new HashMap<>(); + Map noBuildingYear = new LinkedHashMap<>(); noBuildingYear.put("initial", 500); noBuildingYear.put("end", 502); noBuildingYear.put("exceptionIf", 99); exceptionsMicroData.put("noYear", noBuildingYear); - Map SchleswigHolstein = new HashMap<>(); + Map SchleswigHolstein = new LinkedHashMap<>(); SchleswigHolstein.put("initial", 0); SchleswigHolstein.put("end", 2); SchleswigHolstein.put("exceptionIf", 1); exceptionsMicroData.put("out1", SchleswigHolstein); - Map Hamburg = new HashMap<>(); + Map Hamburg = new LinkedHashMap<>(); Hamburg.put("initial", 0); Hamburg.put("end", 2); Hamburg.put("exceptionIf", 2); exceptionsMicroData.put("out2", Hamburg); - Map Niedersachsen = new HashMap<>(); + Map Niedersachsen = new LinkedHashMap<>(); Niedersachsen.put("initial", 0); Niedersachsen.put("end", 2); Niedersachsen.put("exceptionIf", 3); exceptionsMicroData.put("out3", Niedersachsen); - Map Bremen = new HashMap<>(); + Map Bremen = new LinkedHashMap<>(); Bremen.put("initial", 0); Bremen.put("end", 2); Bremen.put("exceptionIf", 4); exceptionsMicroData.put("out4", Bremen); - Map NordrheinWestfalen = new HashMap<>(); + Map NordrheinWestfalen = new LinkedHashMap<>(); NordrheinWestfalen.put("initial", 0); NordrheinWestfalen.put("end", 2); NordrheinWestfalen.put("exceptionIf", 5); exceptionsMicroData.put("out5", NordrheinWestfalen); - Map Hessen = new HashMap<>(); + Map Hessen = new LinkedHashMap<>(); Hessen.put("initial", 0); Hessen.put("end", 2); Hessen.put("exceptionIf", 6); exceptionsMicroData.put("out6", Hessen); - Map RheinlandPfalz = new HashMap<>(); + Map RheinlandPfalz = new LinkedHashMap<>(); RheinlandPfalz.put("initial", 0); RheinlandPfalz.put("end", 2); RheinlandPfalz.put("exceptionIf", 7); exceptionsMicroData.put("out7", RheinlandPfalz); - Map BadenWuerttemberg = new HashMap<>(); + Map BadenWuerttemberg = new LinkedHashMap<>(); BadenWuerttemberg.put("initial", 0); BadenWuerttemberg.put("end", 2); BadenWuerttemberg.put("exceptionIf", 8); exceptionsMicroData.put("out8", BadenWuerttemberg); - Map Saarland = new HashMap<>(); + Map Saarland = new LinkedHashMap<>(); Saarland.put("initial", 0); Saarland.put("end", 2); Saarland.put("exceptionIf", 10); exceptionsMicroData.put("out10", Saarland); - Map Berlin = new HashMap<>(); + Map Berlin = new LinkedHashMap<>(); Berlin.put("initial", 0); Berlin.put("end", 2); Berlin.put("exceptionIf", 11); exceptionsMicroData.put("out11", Berlin); - Map Brandenburg = new HashMap<>(); + Map Brandenburg = new LinkedHashMap<>(); Brandenburg.put("initial", 0); Brandenburg.put("end", 2); Brandenburg.put("exceptionIf", 12); exceptionsMicroData.put("out12", Brandenburg); - Map MecklenburgVorpommern = new HashMap<>(); + Map MecklenburgVorpommern = new LinkedHashMap<>(); MecklenburgVorpommern.put("initial", 0); MecklenburgVorpommern.put("end", 2); MecklenburgVorpommern.put("exceptionIf", 13); exceptionsMicroData.put("out13", MecklenburgVorpommern); - Map Sachsen = new HashMap<>(); + Map Sachsen = new LinkedHashMap<>(); Sachsen.put("initial", 0); Sachsen.put("end", 2); Sachsen.put("exceptionIf", 14); exceptionsMicroData.put("out14", Sachsen); - Map SachsenAnhalt = new HashMap<>(); + Map SachsenAnhalt = new LinkedHashMap<>(); SachsenAnhalt.put("initial", 0); SachsenAnhalt.put("end", 2); SachsenAnhalt.put("exceptionIf", 15); exceptionsMicroData.put("out15", SachsenAnhalt); - Map Thueringen = new HashMap<>(); + Map Thueringen = new LinkedHashMap<>(); Thueringen.put("initial", 0); Thueringen.put("end", 2); Thueringen.put("exceptionIf", 16); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadMicroData.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadMicroData.java index b9fd1245c..c594b1d30 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadMicroData.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadMicroData.java @@ -14,6 +14,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class ReadMicroData { @@ -22,11 +23,11 @@ public class ReadMicroData { private final DataSetSynPop dataSetSynPop; private final MicroDataManager microDataManager; - private Map> exceptionsMicroData = new HashMap<>(); - private HashMap attributesMicroData = new HashMap<>(); - private Map> attributesPersonMicroData = new HashMap<>(); - private Map> attributesHouseholdMicroData = new HashMap<>(); - private Map> attributesDwellingMicroData = new HashMap<>(); + private Map> exceptionsMicroData = new LinkedHashMap<>(); + private HashMap attributesMicroData = new LinkedHashMap<>(); + private Map> attributesPersonMicroData = new LinkedHashMap<>(); + private Map> attributesHouseholdMicroData = new LinkedHashMap<>(); + private Map> attributesDwellingMicroData = new LinkedHashMap<>(); private Table personTable = HashBasedTable.create(); private Table householdTable = HashBasedTable.create(); private Table dwellingTable = HashBasedTable.create(); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadZonalData.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadZonalData.java index d2437f9e8..a0003cc21 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadZonalData.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/preparation/ReadZonalData.java @@ -19,6 +19,7 @@ import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class ReadZonalData { @@ -46,7 +47,7 @@ private void readCities() { //List of municipalities and counties that are used for IPU and allocation ArrayList municipalities = new ArrayList<>(); ArrayList counties = new ArrayList<>(); - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); ArrayList municipalitiesWithZero = new ArrayList<>(); for (int row = 1; row <= PropertiesSynPop.get().main.selectedMunicipalities.getRowCount(); row++) { if (PropertiesSynPop.get().main.selectedMunicipalities.getValueAt(row, "Select") == 1f) { @@ -77,7 +78,7 @@ private void readCities() { dataSetSynPop.setMunicipalitiesWithZeroPopulation(municipalitiesWithZero); if (PropertiesSynPop.get().main.boroughIPU) { - HashMap boroughsByCounty = new HashMap<>(); + HashMap boroughsByCounty = new LinkedHashMap<>(); ArrayList boroughs = new ArrayList<>(); ArrayList countieswithBoroughs = new ArrayList<>(); for (int row = 1; row <= PropertiesSynPop.get().main.selectedBoroughs.getRowCount(); row++) { @@ -105,9 +106,9 @@ private void readCities() { private void readZones(){ //TAZ attributes - HashMap cityTAZ = new HashMap<>(); - Map> probabilityZone = new HashMap<>(); - Map> dwellingPriceByTypeAndZone = new HashMap<>(); + HashMap cityTAZ = new LinkedHashMap<>(); + Map> probabilityZone = new LinkedHashMap<>(); + Map> dwellingPriceByTypeAndZone = new LinkedHashMap<>(); Table schoolCapacity = HashBasedTable.create(); ArrayList tazs = new ArrayList<>(); TableDataSet zoneAttributes; @@ -139,11 +140,11 @@ private void readZones(){ } else { int[] previousTaz = {taz}; cityTAZ.put(city,previousTaz); - Map probabilities = new HashMap<>(); + Map probabilities = new LinkedHashMap<>(); probabilities.put(taz, probability); probabilityZone.put(city, probabilities); } - Map prices = new HashMap<>(); + Map prices = new LinkedHashMap<>(); prices.put(DefaultDwellingTypes.DefaultDwellingTypeImpl.SFA, priceSFA); prices.put(DefaultDwellingTypes.DefaultDwellingTypeImpl.SFD, priceSFD); prices.put(DefaultDwellingTypes.DefaultDwellingTypeImpl.MF234, priceMF234); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/AllocationTrampa.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/AllocationTrampa.java index 7a16222a7..2c7ea28db 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/AllocationTrampa.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/AllocationTrampa.java @@ -11,6 +11,7 @@ import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; public class AllocationTrampa extends ModuleSynPop { @@ -48,7 +49,7 @@ public void generateHouseholdsPersonsDwellings(){ addBoroughsAsCities(county); } } - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new GenerateHouseholdsPersonsDwellingsTrampa(dataContainer, dataSetSynPop, educationalLevel).run(); if (PropertiesSynPop.get().main.boroughIPU){ for (int county : dataSetSynPop.getBoroughsByCounty().keySet()){ @@ -70,7 +71,7 @@ public void assignSchools(){ } public void readPopulation(){ - educationalLevel = new HashMap<>(); + educationalLevel = new LinkedHashMap<>(); new ReadPopulation(dataContainer, educationalLevel).run(); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateHouseholdsPersonsDwellingsTrampa.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateHouseholdsPersonsDwellingsTrampa.java index cbc213adc..0b8ae6f28 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateHouseholdsPersonsDwellingsTrampa.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateHouseholdsPersonsDwellingsTrampa.java @@ -16,10 +16,7 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; -import java.util.Random; +import java.util.*; public class GenerateHouseholdsPersonsDwellingsTrampa { @@ -145,7 +142,7 @@ private void initializeMunicipalityData(int municipality){ logger.info(" Municipality " + municipality + ". Starting to generate households and persons"); totalHouseholds = (int) PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, "hhTotal"); - probMicroData = new HashMap<>(); + probMicroData = new LinkedHashMap<>(); probabilityId = new double[dataSetSynPop.getWeights().getRowCount()]; ids = new int[probabilityId.length]; for (int id : dataSetSynPop.getWeights().getColumnAsInt("ID")){ diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateJobsTrampa.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateJobsTrampa.java index 615008f06..fe361a50a 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateJobsTrampa.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/munich/synpopTrampa/GenerateJobsTrampa.java @@ -12,6 +12,7 @@ import org.apache.logging.log4j.Logger; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class GenerateJobsTrampa { @@ -62,7 +63,7 @@ private void generateJobsByTypeAtMunicipalityWithReplacement(int municipality, S private void initializeTAZprobability(int municipality, String jobType){ - jobsByTaz = new HashMap<>(); + jobsByTaz = new LinkedHashMap<>(); for (int taz : dataSetSynPop.getTazByMunicipality().get(municipality)){ jobsByTaz.put(taz, PropertiesSynPop.get().main.cellsMatrix.getIndexedValueAt(taz, jobType)); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCity.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCity.java index 876be36bd..569089c32 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCity.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCity.java @@ -182,11 +182,11 @@ public void initializeErrorsandTotals(int municipality){ startTime = System.nanoTime(); //weights, values, control totals - weightsByMun = Collections.synchronizedMap(new HashMap<>()); - minWeightsByMun = Collections.synchronizedMap(new HashMap<>()); - valuesByHousehold = Collections.synchronizedMap(new HashMap<>()); - totalMunicipality = Collections.synchronizedMap(new HashMap<>()); - errorsByMunicipality = Collections.synchronizedMap(new HashMap<>()); + weightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + minWeightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + valuesByHousehold = Collections.synchronizedMap(new LinkedHashMap<>()); + totalMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); + errorsByMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); finish = 0; iteration = 0; @@ -213,7 +213,7 @@ public void initializeErrorsandTotals(int municipality){ errorsByMunicipality.put(attribute, 0.); } else { - HashMap inner = new HashMap<>(); + HashMap inner = new LinkedHashMap<>(); inner.put(attribute, (int) PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, attribute)); totalMunicipality.put(municipality, inner); errorsByMunicipality.put(attribute, 0.); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyAndCity.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyAndCity.java index d7dfcf3cf..9cd27fcf5 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyAndCity.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyAndCity.java @@ -7,10 +7,7 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Map; +import java.util.*; import java.util.stream.IntStream; public class IPUbyCountyAndCity { @@ -130,7 +127,7 @@ public double calculateErrors(int county){ Iterator iterator2 = dataSetSynPop.getMunicipalitiesByCounty().get(county).iterator(); while (iterator2.hasNext()){ Integer municipality = iterator2.next(); - Map errorsByMunicipality = Collections.synchronizedMap(new HashMap<>()); + Map errorsByMunicipality = Collections.synchronizedMap(new LinkedHashMap<>() ); executor1.addTaskToQueue(() ->{ for (String attribute : PropertiesSynPop.get().main.attributesMunicipality){ double weightedSumMunicipality = SiloUtil.sumProduct(weightsByMun.get(municipality), valuesByHousehold.get(attribute)); @@ -244,13 +241,13 @@ public void initializeErrorsandTotals(int county){ startTime = System.nanoTime(); //weights, values, control totals - weightsByMun = Collections.synchronizedMap(new HashMap<>()); - minWeightsByMun = Collections.synchronizedMap(new HashMap<>()); - valuesByHousehold = Collections.synchronizedMap(new HashMap<>()); - totalCounty = Collections.synchronizedMap(new HashMap<>()); - totalMunicipality = Collections.synchronizedMap(new HashMap<>()); - errorByMun = Collections.synchronizedMap(new HashMap<>()); - errorByRegion = Collections.synchronizedMap(new HashMap<>()); + weightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + minWeightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + valuesByHousehold = Collections.synchronizedMap(new LinkedHashMap<>()); + totalCounty = Collections.synchronizedMap(new LinkedHashMap<>()); + totalMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); + errorByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + errorByRegion = Collections.synchronizedMap(new LinkedHashMap<>()); finish = 0; iteration = 0; @@ -294,10 +291,10 @@ public void initializeErrorsandTotals(int county){ inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } else { - HashMap inner = new HashMap<>(); + HashMap inner = new LinkedHashMap<>(); inner.put(attribute, (int) PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, attribute)); totalMunicipality.put(municipality, inner); - HashMap inner1 = new HashMap<>(); + HashMap inner1 = new LinkedHashMap<>(); inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyCityAndBorough.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyCityAndBorough.java index 91f0f891b..b3869a1af 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyCityAndBorough.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/optimizationIPU/optimization/IPUbyCountyCityAndBorough.java @@ -7,10 +7,7 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.Map; +import java.util.*; import java.util.stream.IntStream; public class IPUbyCountyCityAndBorough { @@ -174,7 +171,7 @@ public double calculateErrors(int county){ Iterator iterator2 = dataSetSynPop.getMunicipalitiesByCounty().get(county).iterator(); while (iterator2.hasNext()) { Integer municipality = iterator2.next(); - Map errorMunicipality = Collections.synchronizedMap(new HashMap<>()); + Map errorMunicipality = Collections.synchronizedMap(new LinkedHashMap<>() ); for (String attributeC : PropertiesSynPop.get().main.attributesMunicipality) { double errorByCounty = 0.; double weightedSumCounty = 0.; @@ -202,7 +199,7 @@ public double calculateErrors(int county){ Iterator iterator1 = dataSetSynPop.getBoroughsByCounty().get(county).iterator(); while (iterator1.hasNext()) { Integer borough = iterator1.next(); - Map errorsByBorough1 = Collections.synchronizedMap(new HashMap<>()); + Map errorsByBorough1 = Collections.synchronizedMap(new LinkedHashMap<>()); executor1.addTaskToQueue(() -> { for (String attribute : PropertiesSynPop.get().main.attributesBorough) { double weightedSumMunicipality = SiloUtil.sumProduct(weightsByBorough.get(borough), valuesByHousehold.get(attribute)); @@ -331,15 +328,15 @@ public void initializeErrorsandTotals(int county){ startTime = System.nanoTime(); //weights, values, control totals - weightsByBorough = Collections.synchronizedMap(new HashMap<>()); - minWeightsByBorough = Collections.synchronizedMap(new HashMap<>()); - valuesByHousehold = Collections.synchronizedMap(new HashMap<>()); - totalCounty = Collections.synchronizedMap(new HashMap<>()); - totalMunicipality = Collections.synchronizedMap(new HashMap<>()); - totalBorough = Collections.synchronizedMap(new HashMap<>()); - errorByMun = Collections.synchronizedMap(new HashMap<>()); - errorByRegion = Collections.synchronizedMap(new HashMap<>()); - errorsByBorough = Collections.synchronizedMap(new HashMap<>()); + weightsByBorough = Collections.synchronizedMap(new LinkedHashMap<>()); + minWeightsByBorough = Collections.synchronizedMap(new LinkedHashMap<>()); + valuesByHousehold = Collections.synchronizedMap(new LinkedHashMap<>()); + totalCounty = Collections.synchronizedMap(new LinkedHashMap<>()); + totalMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); + totalBorough = Collections.synchronizedMap(new LinkedHashMap<>()); + errorByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + errorByRegion = Collections.synchronizedMap(new LinkedHashMap<>()); + errorsByBorough = Collections.synchronizedMap(new LinkedHashMap<>()); finish = 0; @@ -382,10 +379,10 @@ public void initializeErrorsandTotals(int county){ inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } else { - HashMap inner = new HashMap<>(); + HashMap inner = new LinkedHashMap<>(); inner.put(attribute, (int) PropertiesSynPop.get().main.marginalsMunicipality.getIndexedValueAt(municipality, attribute)); totalMunicipality.put(municipality, inner); - HashMap inner1 = new HashMap<>(); + HashMap inner1 = new LinkedHashMap<>(); inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } @@ -416,10 +413,10 @@ public void initializeErrorsandTotals(int county){ inner1.put(attribute, 0.); errorsByBorough.put(borough, inner1); } else { - HashMap inner = new HashMap<>(); + HashMap inner = new LinkedHashMap<>(); inner.put(attribute, (int) PropertiesSynPop.get().main.marginalsBorough.getIndexedValueAt(borough, attribute)); totalBorough.put(borough, inner); - HashMap inner1 = new HashMap<>(); + HashMap inner1 = new LinkedHashMap<>(); inner1.put(attribute, 0.); errorsByBorough.put(borough, inner1); } diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/perth/SyntheticPopPerth.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/perth/SyntheticPopPerth.java index dd5600b9a..8f35682f5 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/perth/SyntheticPopPerth.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/perth/SyntheticPopPerth.java @@ -53,8 +53,8 @@ private TableDataSet genderPerArea = null; private TableDataSet dwellUnoccPerArea = null; private ArrayList dwellingList = new ArrayList(); - private HashMap zoneMap = new HashMap<>(); - private HashMap> dwellingsPerZoneMap = new HashMap<>(); + private HashMap zoneMap = new LinkedHashMap<>(); + private HashMap> dwellingsPerZoneMap = new LinkedHashMap<>(); private JobCollection jobCollection = new JobCollection(); long unassignedWorker = 0; long unemployedCount = 0; @@ -225,7 +225,7 @@ private void processMicroData() // for each row in the dwellings file for (int rowDd = 1; rowDd <= pumsDwellings.getRowCount(); rowDd++) { - HashMap familyMap = new HashMap(); + HashMap familyMap = new LinkedHashMap(); // get ABS dwelling id from the DWELLING file String dwellingId = pumsDwellings.getStringValueAt(rowDd, "ABSHID Dwelling Record Identifier"); @@ -429,7 +429,7 @@ private int translateSaZone(int pumaZone, int hhCountM, int hhCountF) and sums their relative price. This will be used to later calculate average for each zone and determine the quality. */ - HashMap qualityMap = new HashMap(); + HashMap qualityMap = new LinkedHashMap(); private void addToQuality(int zone, int ddType, int price, int rooms) { DwellingQuality quality = qualityMap.get(zone); @@ -1092,7 +1092,7 @@ public JobSlot(int jjId, int jjZone, int jjWorker, int jjType) private class JobCollection { ArrayList jobSlots = new ArrayList<>(); - HashMap> jobTypesMap = new HashMap<>(); + HashMap> jobTypesMap = new LinkedHashMap<>(); public JobCollection() { } @@ -1233,7 +1233,7 @@ private class DwellingQuality public int Zone = -1; - HashMap TypeQuality = new HashMap<>(); + HashMap TypeQuality = new LinkedHashMap<>(); public DwellingQuality() { } @@ -1299,7 +1299,7 @@ private void createJobs2() // final int highestZoneId = 100; final int highestZoneId = 4953; float[][] jobInventory = new float[JobType.getNumberOfJobTypes()][highestZoneId + 1]; - tazByWorkZonePuma = new HashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined + tazByWorkZonePuma = new LinkedHashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined // read employment data // For reasons that are not explained in the documentation, some of the PUMA work zones were aggregated to the @@ -1353,7 +1353,7 @@ private void identifyVacantJobsByZone () // populate HashMap with Jobs by zone logger.info(" Identifying vacant jobs by zone"); - vacantJobsByZone = new HashMap<>(); + vacantJobsByZone = new LinkedHashMap<>(); Collection jobs = jobData.getJobs(); for (Job jj: jobs) { if (jj.getWorkerId() == -1) { @@ -1603,7 +1603,7 @@ private void addVacantDwellings () { logger.info(" Adding empty dwellings to match vacancy rate"); - HashMap> ddPointer = new HashMap<>(); + HashMap> ddPointer = new LinkedHashMap<>(); // summarize vacancy final int highestZoneId = geoData.getZones().keySet().stream().max(Comparator.naturalOrder()).get(); int[][][] ddCount = new int [highestZoneId + 1][DwellingType.values().length][2]; diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/CreateSkimFromUber.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/CreateSkimFromUber.java index 5b0709804..8fdd716ee 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/CreateSkimFromUber.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/CreateSkimFromUber.java @@ -13,10 +13,7 @@ import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; -import java.util.Collection; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; public class CreateSkimFromUber { @@ -30,7 +27,7 @@ public static void main(String[] args) throws IOException { final Collection features = ShapeFileReader.getAllFeatures("Z:\\projects\\2019\\TraMPA" + "\\San Francisco\\Data\\TAZ\\censusTractsNineCountiesTaz\\censusTracts_projected_7131_uberId.shp"); - final Map movementId2zoneId = new HashMap<>(); + final Map movementId2zoneId = new LinkedHashMap<>(); features.forEach(simpleFeature -> { final int tractce = Integer.parseInt(String.valueOf(simpleFeature.getAttribute("TRACTCE"))); final int uberId = Integer.parseInt(String.valueOf(simpleFeature.getAttribute("MOVEMENT_I"))); diff --git a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/SyntheticPopUs.java b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/SyntheticPopUs.java index 5a636497f..369ab7129 100644 --- a/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/SyntheticPopUs.java +++ b/synthetic-population/src/main/java/de/tum/bgu/msm/syntheticPopulationGenerator/sanFrancisco/SyntheticPopUs.java @@ -160,8 +160,8 @@ public void runSP() { private void identifyCensusBlockGroups() { - censusBlockGroupsByCensusTracts = new HashMap<>(); - geometryByCensusBlockGroup = new HashMap<>(); + censusBlockGroupsByCensusTracts = new LinkedHashMap<>(); + geometryByCensusBlockGroup = new LinkedHashMap<>(); String filePath =Properties.get().main.baseDirectory + ResourceUtil.getProperty(rb, PROPERTIES_BLOCK_GROUPS_PATH); for (SimpleFeature feature : ShapeFileReader.getAllFeatures(filePath)) { @@ -180,7 +180,7 @@ private void identifyCensusBlockGroups() { private void identifyUniquePUMAzones() { // walk through list of zones and collect unique PUMA zone IDs within the study area - tazByPuma = new HashMap<>(); + tazByPuma = new LinkedHashMap<>(); Set alHomePuma = new HashSet<>(); Set alWorkPuma = new HashSet<>(); for (Zone zone : geoData.getZones().values()) { @@ -223,7 +223,7 @@ private void createJobs() { // jobInventory by [industry][taz] final int highestZoneId = geoData.getZones().keySet().stream().max(Comparator.naturalOrder()).get(); float[][] jobInventory = new float[JobType.getNumberOfJobTypes()][highestZoneId + 1]; - tazByWorkZonePuma = new HashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined + tazByWorkZonePuma = new LinkedHashMap<>(); // this HashMap has same content as "HashMap tazByPuma", though is kept separately in case external workzones will be defined // read employment data // For reasons that are not explained in the documentation, some of the PUMA work zones were aggregated to the @@ -266,7 +266,7 @@ private void createJobs() { private void identifyVacantJobsByZone() { // populate HashMap with Jobs by zone logger.info(" Identifying vacant jobs by zone"); - vacantJobsByZone = new HashMap<>(); + vacantJobsByZone = new LinkedHashMap<>(); Collection jobs = jobData.getJobs(); for (Job jj : jobs) { if (jj.getWorkerId() == -1) { @@ -283,10 +283,10 @@ private void identifyVacantJobsByZone() { private void processPums() { // read PUMS data logger.info(" Reading PUMS data"); - jobErrorCounter = new HashMap<>(); + jobErrorCounter = new LinkedHashMap<>(); - Map relationsHipsByPerson = new HashMap<>(); - Map> households = new HashMap<>(); + Map relationsHipsByPerson = new LinkedHashMap<>(); + Map> households = new LinkedHashMap<>(); logger.info(" Creating synthetic population"); String hhFilePath =Properties.get().main.baseDirectory + ResourceUtil.getProperty(rb, PROPERTIES_PUMS_HH_FILE_NAME); @@ -841,7 +841,7 @@ private Job selectWorkplaceByTripLengthFrequencyDistribution(int workPumaZone, i return null; // person does work in puma zone outside of study area } - Map zoneProbabilities = new HashMap<>(); + Map zoneProbabilities = new LinkedHashMap<>(); Zone homeZone = geoData.getZones().get(homeTaz); for (Zone zone : geoData.getZones().values()) { if (vacantJobsByZone.containsKey(zone.getZoneId())) { diff --git a/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTest.java b/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTest.java index cc52e47f5..e27d31f10 100644 --- a/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTest.java +++ b/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTest.java @@ -11,6 +11,8 @@ import java.io.Reader; import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; + import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -47,7 +49,7 @@ public void setup() { System.arraycopy(attributesCounty1, 1, attributesCounty, 0, attributesCounty.length); ArrayList municipalities = new ArrayList<>(); ArrayList counties = new ArrayList<>(); - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); for (int row = 1; row <= selectedMunicipalities.getRowCount(); row++){ if (selectedMunicipalities.getValueAt(row,"Select") == 1f){ int city = (int) selectedMunicipalities.getValueAt(row,"ID_city"); diff --git a/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTestOpt.java b/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTestOpt.java index b21c1cb4e..3478c4a28 100644 --- a/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTestOpt.java +++ b/synthetic-population/src/test/java/de/tum/bgu/msm/syntheticPopulation/ipuTestOpt.java @@ -51,7 +51,7 @@ public void setup() { for (int i = 0; i < attributesCounty.length; i++){attributesCounty[i] = attributesCounty1[i+1];} municipalities = new ArrayList<>(); counties = new ArrayList<>(); - municipalitiesByCounty = new HashMap<>(); + municipalitiesByCounty = new LinkedHashMap<>(); for (int row = 1; row <= selectedMunicipalities.getRowCount(); row++){ if (selectedMunicipalities.getValueAt(row,"Select") == 1f){ int city = (int) selectedMunicipalities.getValueAt(row,"ID_city"); @@ -99,13 +99,13 @@ public void testModelOne() throws ScriptException { //int position = 0; //weights, values, control totals - Map weightsByMun = Collections.synchronizedMap(new HashMap<>()); - Map minWeightsByMun =Collections.synchronizedMap(new HashMap<>()); - Map valuesByHousehold = Collections.synchronizedMap(new HashMap<>()); - Map totalCounty = Collections.synchronizedMap(new HashMap<>()); - Map> totalMunicipality = Collections.synchronizedMap(new HashMap<>()); - Map> errorByMun = Collections.synchronizedMap(new HashMap<>()); - Map errorByRegion = Collections.synchronizedMap(new HashMap<>()); + Map weightsByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + Map minWeightsByMun =Collections.synchronizedMap(new LinkedHashMap<>()); + Map valuesByHousehold = Collections.synchronizedMap(new LinkedHashMap<>()); + Map totalCounty = Collections.synchronizedMap(new LinkedHashMap<>()); + Map> totalMunicipality = Collections.synchronizedMap(new LinkedHashMap<>()); + Map> errorByMun = Collections.synchronizedMap(new LinkedHashMap<>()); + Map errorByRegion = Collections.synchronizedMap(new LinkedHashMap<>()); double weightedSum0 = 0f; int finish = 0; @@ -156,10 +156,10 @@ public void testModelOne() throws ScriptException { inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } else { - HashMap inner = new HashMap<>(); + HashMap inner = new LinkedHashMap<>(); inner.put(attribute, (int) controlTotalsMun.getIndexedValueAt(municipality, attribute)); totalMunicipality.put(municipality, inner); - HashMap inner1 = new HashMap<>(); + HashMap inner1 = new LinkedHashMap<>(); inner1.put(attribute, 0.); errorByMun.put(municipality, inner1); } @@ -233,7 +233,7 @@ public void testModelOne() throws ScriptException { } HashMap inner = errorByMun.get(municipality); if (inner == null) { - inner = new HashMap(); + inner = new LinkedHashMap(); errorByMun.put(municipality, inner); } inner.put(attribute, error); diff --git a/useCases/bangkok/src/main/java/de/tum/bgu/msm/run/data/jobs/BangkokJobFactory.java b/useCases/bangkok/src/main/java/de/tum/bgu/msm/run/data/jobs/BangkokJobFactory.java index 9bcd442b2..a07e23fc0 100644 --- a/useCases/bangkok/src/main/java/de/tum/bgu/msm/run/data/jobs/BangkokJobFactory.java +++ b/useCases/bangkok/src/main/java/de/tum/bgu/msm/run/data/jobs/BangkokJobFactory.java @@ -12,6 +12,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -47,7 +48,7 @@ public void readWorkingTimeDistributions(Properties properties) { if (startTimeDistributionByJobType.containsKey(header[column])) { startTimeDistributionByJobType.get(header[column]).put(time, Double.parseDouble(row[column])); } else { - Map startTimeDistribution = new HashMap<>(); + Map startTimeDistribution = new LinkedHashMap<>(); startTimeDistribution.put(time, Double.parseDouble(row[column])); startTimeDistributionByJobType.put(header[column], startTimeDistribution); } @@ -70,7 +71,7 @@ public void readWorkingTimeDistributions(Properties properties) { if (workingTimeDistributionByJobType.containsKey(header[column])) { workingTimeDistributionByJobType.get(header[column]).put(time, Double.parseDouble(row[column])); } else { - Map workingTimeDistribution = new HashMap<>(); + Map workingTimeDistribution = new LinkedHashMap<>(); workingTimeDistribution.put(time, Double.parseDouble(row[column])); workingTimeDistributionByJobType.put(header[column], workingTimeDistribution); } diff --git a/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/data/job/JobFactoryBerlinBrandenburg.java b/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/data/job/JobFactoryBerlinBrandenburg.java index 030652f6b..38d60b795 100644 --- a/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/data/job/JobFactoryBerlinBrandenburg.java +++ b/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/data/job/JobFactoryBerlinBrandenburg.java @@ -8,6 +8,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -43,7 +44,7 @@ public void readWorkingTimeDistributions(Properties properties) { if (startTimeDistributionByJobType.containsKey(header[column])) { startTimeDistributionByJobType.get(header[column]).put(time, Double.parseDouble(row[column])); } else { - Map startTimeDistribution = new HashMap<>(); + Map startTimeDistribution = new LinkedHashMap<>(); startTimeDistribution.put(time, Double.parseDouble(row[column])); startTimeDistributionByJobType.put(header[column], startTimeDistribution); } @@ -66,7 +67,7 @@ public void readWorkingTimeDistributions(Properties properties) { if (workingTimeDistributionByJobType.containsKey(header[column])) { workingTimeDistributionByJobType.get(header[column]).put(time, Double.parseDouble(row[column])); } else { - Map workingTimeDistribution = new HashMap<>(); + Map workingTimeDistribution = new LinkedHashMap<>(); workingTimeDistribution.put(time, Double.parseDouble(row[column])); workingTimeDistributionByJobType.put(header[column], workingTimeDistribution); } diff --git a/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelBerlinBrandenburg.java b/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelBerlinBrandenburg.java index f232bd3bd..a5bacb080 100644 --- a/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelBerlinBrandenburg.java +++ b/useCases/berlinBrandenburg/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelBerlinBrandenburg.java @@ -16,6 +16,7 @@ import java.io.InputStreamReader; import java.io.Reader; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Random; import java.util.stream.Collectors; @@ -32,7 +33,7 @@ public class SwitchToAutonomousVehicleModelBerlinBrandenburg extends AbstractMod /** * this variable stores a summary for print out purposes */ - private Map summary = new HashMap<>(); + private Map summary = new LinkedHashMap<>(); public SwitchToAutonomousVehicleModelBerlinBrandenburg(DataContainer dataContainer, Properties properties, InputStream inputStream, Random rnd) { super(dataContainer, properties, rnd); diff --git a/useCases/capeTown/src/main/java/de/tum/bgu/msm/models/relocation/HousingStrategyCapeTown.java b/useCases/capeTown/src/main/java/de/tum/bgu/msm/models/relocation/HousingStrategyCapeTown.java index 65d787d8e..308f5e3ee 100644 --- a/useCases/capeTown/src/main/java/de/tum/bgu/msm/models/relocation/HousingStrategyCapeTown.java +++ b/useCases/capeTown/src/main/java/de/tum/bgu/msm/models/relocation/HousingStrategyCapeTown.java @@ -26,10 +26,7 @@ import org.apache.logging.log4j.Logger; import org.matsim.api.core.v01.TransportMode; -import java.util.EnumMap; -import java.util.HashMap; -import java.util.Map; -import java.util.Objects; +import java.util.*; import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; @@ -70,8 +67,8 @@ private enum Normalizer { private final RegionUtilityStrategy regionUtilityStrategy; private final RegionProbabilityStrategy regionProbabilityStrategy; - private Map> personShareByRaceByRegion = new HashMap<>(); - private Map> personShareByRaceByZone = new HashMap<>(); + private Map> personShareByRaceByRegion = new LinkedHashMap<>(); + private Map> personShareByRaceByZone = new LinkedHashMap<>(); private IndexedDoubleMatrix1D ppByRegion; private IndexedDoubleMatrix1D ppByZone; @@ -218,7 +215,7 @@ private void calculateRegionalUtilities() { for (IncomeCategory incomeCategory : IncomeCategory.values()) { EnumMap> utilityByRegionByRace = new EnumMap<>(RaceCapeTown.class); for (RaceCapeTown race : RaceCapeTown.values()) { - Map utilityByRegion = new HashMap<>(); + Map utilityByRegion = new LinkedHashMap<>(); for (Region region : geoData.getRegions().values()) { if (!rentsByRegion.containsKey(region.getId())) { continue; diff --git a/useCases/fabiland/src/main/java/inputGeneration/CreateShapefile.java b/useCases/fabiland/src/main/java/inputGeneration/CreateShapefile.java index 14ec2b82d..6a66cb18b 100644 --- a/useCases/fabiland/src/main/java/inputGeneration/CreateShapefile.java +++ b/useCases/fabiland/src/main/java/inputGeneration/CreateShapefile.java @@ -20,7 +20,7 @@ public static void main(String[] args) { GeometryFactory geometryFactory = new GeometryFactory(); - Map polygons = new HashMap<>(); + Map polygons = new LinkedHashMap<>(); int sideLengthHorizonal = 5000; int sideLengthVertical = 5000; diff --git a/useCases/fabiland/src/main/java/inputGeneration/PTScheduleCreator.java b/useCases/fabiland/src/main/java/inputGeneration/PTScheduleCreator.java index e4dac55c2..9b0482e50 100644 --- a/useCases/fabiland/src/main/java/inputGeneration/PTScheduleCreator.java +++ b/useCases/fabiland/src/main/java/inputGeneration/PTScheduleCreator.java @@ -379,7 +379,7 @@ private static void createSchedule(String inputNetwork, String outputNetwork, St } // static void setLinkSpeedsToMax(Scenario scenario) { -// Map, Double> linkMaxSpeed = new HashMap<>(); +// Map, Double> linkMaxSpeed = new LinkedHashMap<>(); // // for (Link link : scenario.getNetwork().getLinks().values()) { // linkMaxSpeed.put(link.getId(), 0.); diff --git a/useCases/fabiland/src/test/java/run/RunFabilandTest.java b/useCases/fabiland/src/test/java/run/RunFabilandTest.java index 5d4727988..9a8460fae 100644 --- a/useCases/fabiland/src/test/java/run/RunFabilandTest.java +++ b/useCases/fabiland/src/test/java/run/RunFabilandTest.java @@ -83,6 +83,8 @@ public void testMain(){ PopulationComparison.Result result = PopulationUtils.comparePopulations( expected, actual ); // Assertions.assertEquals( PopulationComparison.Result.equal, result ); } + log.info("############################################"); + log.info("############################################"); { String expected = inputDirectory + "/1.output_events.xml.gz" ; String actual = "scenario/scenOutput/base/matsim/1/1.output_events.xml.gz" ; diff --git a/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopment/CoreCityJobMarketUpdateTak.java b/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopment/CoreCityJobMarketUpdateTak.java index 7f5294346..a3000c256 100644 --- a/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopment/CoreCityJobMarketUpdateTak.java +++ b/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopment/CoreCityJobMarketUpdateTak.java @@ -59,7 +59,7 @@ private void updateJobInventoryMultiThreadedThisYear(int year) { jobsByZone[jobTypeId][jj.getZoneId()]++; } - Map> jobsAvailableForRemoval = new HashMap<>(); + Map> jobsAvailableForRemoval = new LinkedHashMap<>(); for (Job jj : jobDataManager.getJobs()) { String token = jj.getType() + "." + jj.getZoneId() + "." + (jj.getWorkerId() == -1); if (jobsAvailableForRemoval.containsKey(token)) { diff --git a/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdateTak.java b/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdateTak.java index 07ad33982..5a1db39dc 100644 --- a/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdateTak.java +++ b/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdateTak.java @@ -66,7 +66,7 @@ private void updateJobInventoryMultiThreadedThisYear(int year) { logger.info(" Updating job market based on exogenous forecast for " + year + " (multi-threaded step)"); - Map> jobsAvailableForRemoval = new HashMap<>(); + Map> jobsAvailableForRemoval = new LinkedHashMap<>(); for (Job jj : jobDataManager.getJobs()) { String token = jj.getType() + "." + jj.getZoneId() + "." + (jj.getWorkerId() == -1); if (jobsAvailableForRemoval.containsKey(token)) { diff --git a/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/longCommutePenalty/LongCommutePenaltytHousingStrategyTak.java b/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/longCommutePenalty/LongCommutePenaltytHousingStrategyTak.java index b4d67f242..2dea9bb8e 100644 --- a/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/longCommutePenalty/LongCommutePenaltytHousingStrategyTak.java +++ b/useCases/kagawa/src/main/java/de/tum/bgu/msm/scenarios/longCommutePenalty/LongCommutePenaltytHousingStrategyTak.java @@ -31,6 +31,7 @@ import java.util.EnumMap; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import static de.tum.bgu.msm.data.dwelling.RealEstateUtils.RENT_CATEGORIES; @@ -255,7 +256,7 @@ private void calculateRegionalUtilities() { final Map rentsByRegion = dataContainer.getRealEstateDataManager().calculateRegionalPrices(); thisYearRentByRegion = rentsByRegion; for (IncomeCategory incomeCategory : IncomeCategory.values()) { - Map utilityByRegion = new HashMap<>(); + Map utilityByRegion = new LinkedHashMap<>(); for (Region region : geoData.getRegions().values()) { final int averageRegionalRent = rentsByRegion.get(region.getId()).intValue(); final float regAcc = (float) convertAccessToUtility(accessibility.getRegionalAccessibility(region)); diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/DataBuilderHealth.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/DataBuilderHealth.java index 5caa2074f..1e05d0ddd 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/DataBuilderHealth.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/DataBuilderHealth.java @@ -31,6 +31,7 @@ import org.matsim.core.scenario.ScenarioUtils; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class DataBuilderHealth { @@ -126,7 +127,7 @@ static public void read(Properties properties, HealthDataContainerImpl dataConta new PoiReader(dataContainer).readData(properties.main.baseDirectory + properties.geo.poiFileName); Network network = NetworkUtils.readNetwork(config.network().getInputFile()); - Map, LinkInfo> linkInfoMap = new HashMap<>(); + Map, LinkInfo> linkInfoMap = new LinkedHashMap<>(); for(Link link : network.getLinks().values()){ linkInfoMap.put(link.getId(), new LinkInfo(link.getId())); } diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthDataContainerImpl.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthDataContainerImpl.java index f78dc8749..e646668c2 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthDataContainerImpl.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthDataContainerImpl.java @@ -33,13 +33,13 @@ public class HealthDataContainerImpl implements DataContainerWithSchools, DataCo private final DataContainerWithSchools delegate; private final Properties properties; - private Map, LinkInfo> linkInfo = new HashMap<>(); - private Map activityLocationInfo = new HashMap<>(); + private Map, LinkInfo> linkInfo = new LinkedHashMap<>(); + private Map activityLocationInfo = new LinkedHashMap<>(); private Set pollutantSet = new HashSet<>(); private EnumMap>> avgSpeeds; private EnumMap> healthTransitionData; private EnumMap> doseResponseData; - private Map>> healthDiseaseTrackerRemovedPerson = new HashMap<>(); + private Map>> healthDiseaseTrackerRemovedPerson = new LinkedHashMap<>(); public HealthDataContainerImpl(DataContainerWithSchools delegate, Properties properties) { diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthExposureModelMCR.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthExposureModelMCR.java index 2bd71f71f..394fb1adf 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthExposureModelMCR.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/HealthExposureModelMCR.java @@ -70,7 +70,7 @@ public class HealthExposureModelMCR extends AbstractModel implements ModelUpdate private int latestMatsimYear = -1; private int latestMITOYear = -1; private static final Logger logger = LogManager.getLogger(HealthExposureModelMCR.class); - private Map mitoTrips = new HashMap<>(); + private Map mitoTrips = new LinkedHashMap<>(); private final Config initialMatsimConfig; private MutableScenario scenario; private List simulatedDays; diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MatsimTransportModelMCRHealth.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MatsimTransportModelMCRHealth.java index 1554c256c..c4e2decca 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MatsimTransportModelMCRHealth.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MatsimTransportModelMCRHealth.java @@ -246,7 +246,7 @@ private void runBikePedSimulation(int year, Map assembledMultiSce Id vehicleId = Id.createVehicleId(person.getId().toString()); VehicleType vehicleType = matsimScenario.getVehicles().getVehicleTypes().get(Id.create(mode + gender + age, VehicleType.class)); Vehicle veh = fac.createVehicle(vehicleId,vehicleType); - Map> modeToVehicle = new HashMap<>(); + Map> modeToVehicle = new LinkedHashMap<>(); modeToVehicle.put(mode,vehicleId); VehicleUtils.insertVehicleIdsIntoPersonAttributes(person,modeToVehicle); matsimScenario.getVehicles().addVehicle(veh); diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MitoMatsimScenarioAssemblerMCR.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MitoMatsimScenarioAssemblerMCR.java index fd52d9f00..bc45bee96 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MitoMatsimScenarioAssemblerMCR.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/MitoMatsimScenarioAssemblerMCR.java @@ -26,6 +26,7 @@ import uk.cam.mrc.phm.MitoModelMCR; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Objects; @@ -72,9 +73,9 @@ public Map assembleMultiScenarios(Config initialMatsimConfig, int mito.run(); logger.info(" Receiving demand from MITO"); - Map scenarios = new HashMap<>(); + Map scenarios = new LinkedHashMap<>(); - Map populationByDay = new HashMap(); + Map populationByDay = new LinkedHashMap(); for(Person person: dataSet.getPopulation().getPersons().values()){ Day day = Day.valueOf((String)person.getAttributes().getAttribute("day")); diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/PersonHealthMCR.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/PersonHealthMCR.java index 3557913f4..f8fd2ff49 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/PersonHealthMCR.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/PersonHealthMCR.java @@ -26,10 +26,10 @@ public class PersonHealthMCR implements PersonWithSchool, PersonHealth { private float[] weeklyTravelActivityHourOccupied = new float[24*7]; //for exposure model - private Map weeklyMarginalMetHours = new HashMap<>(); + private Map weeklyMarginalMetHours = new LinkedHashMap<>(); private float weeklyMarginalMetHoursSport = 0.f; - private Map weeklyAccidentRisks = new HashMap<>(); - private Map weeklyExposureByPollutantByHour = new HashMap<>(); + private Map weeklyAccidentRisks = new LinkedHashMap<>(); + private Map weeklyExposureByPollutantByHour = new LinkedHashMap<>(); private Map weeklyExposureByPollutantNormalised; private float[] weeklyNoiseExposureByHour = new float[24*7]; @@ -42,9 +42,9 @@ public class PersonHealthMCR implements PersonWithSchool, PersonHealth { //for disease model private EnumMap> relativeRisksByDisease = new EnumMap<>(HealthExposures.class); - private Map> healthDiseaseTracker = new HashMap<>(); + private Map> healthDiseaseTracker = new LinkedHashMap<>(); private List currentDisease = new ArrayList<>(); - private Map currentDiseaseProb = new HashMap<>(); + private Map currentDiseaseProb = new LinkedHashMap<>(); public PersonHealthMCR(int id, int age, diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/SportPAModelMCR.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/SportPAModelMCR.java index 231e33b9f..a498465c4 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/SportPAModelMCR.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/SportPAModelMCR.java @@ -17,7 +17,7 @@ public class SportPAModelMCR extends AbstractModel implements ModelUpdateListener { private static final Logger logger = LogManager.getLogger(SportPAModelMCR.class); - private Map> coef = new HashMap<>(); + private Map> coef = new LinkedHashMap<>(); public SportPAModelMCR(DataContainer dataContainer, Properties properties, Random random) { super(dataContainer, properties, random); diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/diseaseModelOffline/HealthExposuresReader.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/diseaseModelOffline/HealthExposuresReader.java index 42c5facb6..15361264e 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/health/diseaseModelOffline/HealthExposuresReader.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/health/diseaseModelOffline/HealthExposuresReader.java @@ -13,6 +13,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public class HealthExposuresReader { @@ -22,7 +23,7 @@ public class HealthExposuresReader { public Map readData(HealthDataContainerImpl dataContainer, String path) { logger.info("Reading person micro data with health exposures"); PersonFactoryMCRHealth ppFactory = new PersonFactoryMCRHealth(); - Map persons = new HashMap<>(); + Map persons = new LinkedHashMap<>(); String recString = ""; int recCount = 0; @@ -51,7 +52,7 @@ public Map readData(HealthDataContainerImpl dataContainer pp.updateWeeklyMarginalMetHours(Mode.bicycle, Float.parseFloat(lineElements[posMmetCycle])); pp.setWeeklyMarginalMetHoursSport(Float.parseFloat(lineElements[posMmetSport])); - Map exposureMap = new HashMap<>(); + Map exposureMap = new LinkedHashMap<>(); exposureMap.put("pm2.5", Float.parseFloat(lineElements[posPM2_5])); exposureMap.put("no2", Float.parseFloat(lineElements[posNO2])); pp.setWeeklyExposureByPollutantNormalised(exposureMap); diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/models/BirthModelMCR.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/models/BirthModelMCR.java index a6dc5d4f0..283b39478 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/models/BirthModelMCR.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/models/BirthModelMCR.java @@ -128,7 +128,7 @@ void giveBirth(Person person) { ((PersonHealthMCR)child).updateWeeklyMarginalMetHours(Mode.bicycle, 0.f); ((PersonHealthMCR)child).setWeeklyMarginalMetHoursSport(0.f); - Map exposureMap = new HashMap<>(); + Map exposureMap = new LinkedHashMap<>(); exposureMap.put("pm2.5", 0.f); exposureMap.put("no2", 0.f); diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMCRImpl.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMCRImpl.java index 8771ed760..b8fa69de9 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMCRImpl.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMCRImpl.java @@ -80,7 +80,7 @@ private void readOverwriteFile() { String fileName = properties.main.baseDirectory + properties.realEstate.constructionOverwriteDwellingFile; TableDataSet overwrite = SiloUtil.readCSVfile(fileName); - plannedDwellings = new HashMap<>(); + plannedDwellings = new LinkedHashMap<>(); for (int row = 1; row <= overwrite.getRowCount(); row++) { int year = (int) overwrite.getValueAt(row, "year"); diff --git a/useCases/manchester/src/main/java/de/tum/bgu/msm/models/MovesModelMCR.java b/useCases/manchester/src/main/java/de/tum/bgu/msm/models/MovesModelMCR.java index f12ab3ada..ce28ae2ce 100644 --- a/useCases/manchester/src/main/java/de/tum/bgu/msm/models/MovesModelMCR.java +++ b/useCases/manchester/src/main/java/de/tum/bgu/msm/models/MovesModelMCR.java @@ -57,8 +57,8 @@ public class MovesModelMCR extends AbstractModel implements MovesModel { private final Map averageHousingSatisfaction = new ConcurrentHashMap<>(); private final Map satisfactionByHousehold = new ConcurrentHashMap<>(); - private final Map householdsByZone = new HashMap<>(); - private final Map sumOfSatisfactionsByZone = new HashMap<>(); + private final Map householdsByZone = new LinkedHashMap<>(); + private final Map sumOfSatisfactionsByZone = new LinkedHashMap<>(); private YearByYearCsvModelTracker relocationTracker; public MovesModelMCR(DataContainer dataContainer, Properties properties, MovesStrategy movesStrategy, diff --git a/useCases/maryland/src/main/java/de/tum/bgu/msm/data/HouseholdDataManagerMstm.java b/useCases/maryland/src/main/java/de/tum/bgu/msm/data/HouseholdDataManagerMstm.java index d1be09d87..21843a725 100644 --- a/useCases/maryland/src/main/java/de/tum/bgu/msm/data/HouseholdDataManagerMstm.java +++ b/useCases/maryland/src/main/java/de/tum/bgu/msm/data/HouseholdDataManagerMstm.java @@ -19,7 +19,7 @@ public class HouseholdDataManagerMstm implements HouseholdDataManager { - private final Map medianIncomeByMsa = new HashMap<>(); + private final Map medianIncomeByMsa = new LinkedHashMap<>(); private final HouseholdDataManagerImpl delegate; private final GeoData geoData; private final DwellingData dwellingData; @@ -37,7 +37,7 @@ public float getMedianIncome(int msa) { private void calculateMedianHouseholdIncomeByMSA() { - Map> incomesByMsa = new HashMap<>(); + Map> incomesByMsa = new LinkedHashMap<>(); for (Household hh : delegate.getHouseholds()) { int zone = -1; Dwelling dwelling = dwellingData.getDwelling(hh.getDwellingId()); diff --git a/useCases/maryland/src/main/java/de/tum/bgu/msm/data/RealEstateDataManagerMstm.java b/useCases/maryland/src/main/java/de/tum/bgu/msm/data/RealEstateDataManagerMstm.java index 73f23ab95..c13633b3c 100644 --- a/useCases/maryland/src/main/java/de/tum/bgu/msm/data/RealEstateDataManagerMstm.java +++ b/useCases/maryland/src/main/java/de/tum/bgu/msm/data/RealEstateDataManagerMstm.java @@ -30,7 +30,7 @@ public RealEstateDataManagerMstm ( } private void calculateMedianRentByMSA() { - Map> rentHashMap = new HashMap<>(); + Map> rentHashMap = new LinkedHashMap<>(); for (Dwelling dd : delegate.getDwellings()) { int dwellingMSA = ((MstmZone) geoData.getZones().get(dd.getZoneId())).getMsa(); if (rentHashMap.containsKey(dwellingMSA)) { diff --git a/useCases/maryland/src/main/java/de/tum/bgu/msm/data/geo/GeoDataMstm.java b/useCases/maryland/src/main/java/de/tum/bgu/msm/data/geo/GeoDataMstm.java index b6413933f..b88aaef6e 100644 --- a/useCases/maryland/src/main/java/de/tum/bgu/msm/data/geo/GeoDataMstm.java +++ b/useCases/maryland/src/main/java/de/tum/bgu/msm/data/geo/GeoDataMstm.java @@ -5,6 +5,7 @@ import java.util.Collections; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; /** @@ -16,7 +17,7 @@ public class GeoDataMstm extends DefaultGeoData { private final static Logger logger = LogManager.getLogger(GeoDataMstm.class); - private final Map counties = new HashMap<>(); + private final Map counties = new LinkedHashMap<>(); public GeoDataMstm() { super(); diff --git a/useCases/maryland/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMstm.java b/useCases/maryland/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMstm.java index 372c5156e..b33961737 100644 --- a/useCases/maryland/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMstm.java +++ b/useCases/maryland/src/main/java/de/tum/bgu/msm/models/ConstructionOverwriteMstm.java @@ -75,7 +75,7 @@ private void readOverwriteFile() { String fileName = properties.main.baseDirectory + properties.realEstate.constructionOverwriteDwellingFile; TableDataSet overwrite = SiloUtil.readCSVfile(fileName); - plannedDwellings = new HashMap<>(); + plannedDwellings = new LinkedHashMap<>(); for (int row = 1; row <= overwrite.getRowCount(); row++) { int year = (int) overwrite.getValueAt(row, "year"); diff --git a/useCases/maryland/src/main/java/de/tum/bgu/msm/models/MarriageModelMstm.java b/useCases/maryland/src/main/java/de/tum/bgu/msm/models/MarriageModelMstm.java index 6253ae06f..26ddafd4f 100644 --- a/useCases/maryland/src/main/java/de/tum/bgu/msm/models/MarriageModelMstm.java +++ b/useCases/maryland/src/main/java/de/tum/bgu/msm/models/MarriageModelMstm.java @@ -183,7 +183,7 @@ private Person findPartner(MarriageMarket market, Person person) { return null; } - final Map probabilities = new HashMap<>(); + final Map probabilities = new LinkedHashMap<>(); Race personRace = ((PersonMstm) person).getRace(); float sum = 0; @@ -210,7 +210,7 @@ private MarriagePreference defineMarriagePreference(Person person, MarriageMarke final Gender partnerGender = person.getGender().opposite(); final boolean sameRace = random.nextDouble() >= interRacialMarriageShare; - final Map probabilityByAge = new HashMap<>(); + final Map probabilityByAge = new LinkedHashMap<>(); double sum = 0; for (int ageDiff : AGE_DIFF_RANGE) { diff --git a/useCases/maryland/src/main/java/de/tum/bgu/msm/run/MstmMonitor.java b/useCases/maryland/src/main/java/de/tum/bgu/msm/run/MstmMonitor.java index 4835dd416..e577d4085 100644 --- a/useCases/maryland/src/main/java/de/tum/bgu/msm/run/MstmMonitor.java +++ b/useCases/maryland/src/main/java/de/tum/bgu/msm/run/MstmMonitor.java @@ -18,6 +18,7 @@ import java.io.PrintWriter; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; @@ -91,13 +92,13 @@ private void writeOutSocioEconomicDataForMstm(int year) { // TOT: Total employment in zone for (Zone zone : geoData.getZones().values()) { int zoneId = zone.getZoneId(); - int totalEmployment = jobsByTypeByZone.getOrDefault(zoneId, new HashMap<>()).values().stream().mapToInt(list -> list == null ? 0: list.size()).sum(); + int totalEmployment = jobsByTypeByZone.getOrDefault(zoneId, new LinkedHashMap<>() ).values().stream().mapToInt( list -> list == null ? 0: list.size() ).sum(); pw.println(zone.getZoneId() + "," + zone.getArea_sqmi() + "," + hhByZone.getOrDefault(zoneId, EMPTY_LIST).size() + "," + enrollment.getIndexedValueAt(zoneId, "ENR") + "," - + jobsByTypeByZone.getOrDefault(zoneId, new HashMap<>()).getOrDefault("RET",EMPTY_LIST).size() + "," + - jobsByTypeByZone.getOrDefault(zoneId, new HashMap<>()).getOrDefault("OFF", EMPTY_LIST).size() + "," - + jobsByTypeByZone.getOrDefault(zoneId, new HashMap<>()).getOrDefault("OTH", EMPTY_LIST).size() + "," + + jobsByTypeByZone.getOrDefault(zoneId, new LinkedHashMap<>()).getOrDefault("RET",EMPTY_LIST).size() + "," + + jobsByTypeByZone.getOrDefault(zoneId, new LinkedHashMap<>()).getOrDefault("OFF", EMPTY_LIST).size() + "," + + jobsByTypeByZone.getOrDefault(zoneId, new LinkedHashMap<>()).getOrDefault("OTH", EMPTY_LIST).size() + "," + totalEmployment); } pw.close(); @@ -135,8 +136,8 @@ private void writeOutSocioEconomicDataForMstm(int year) { for (int wrk = 0; wrk <= 3; wrk++) { for (int inc = 1; inc <= 5; inc++) { int size = householdsByIncomeByWorkersByZone - .getOrDefault(zone.getZoneId(), new HashMap<>()) - .getOrDefault(wrk, new HashMap<>()) + .getOrDefault(zone.getZoneId(), new LinkedHashMap<>()) + .getOrDefault(wrk, new LinkedHashMap<>()) .getOrDefault(inc, EMPTY_LIST) .size(); pwWrk.print("," + size); @@ -183,8 +184,8 @@ private void writeOutSocioEconomicDataForMstm(int year) { for (int size = 1; size <= 5; size++) { for (int inc = 1; inc <= 5; inc++) { int count = householdsByIncomeBySizeByZone - .getOrDefault(zone.getZoneId(), new HashMap<>()) - .getOrDefault(size, new HashMap<>()) + .getOrDefault(zone.getZoneId(), new LinkedHashMap<>()) + .getOrDefault(size, new LinkedHashMap<>()) .getOrDefault(inc, EMPTY_LIST) .size(); pwSize.print("," + count); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/data/job/JobFactoryMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/data/job/JobFactoryMuc.java index d8e80471c..d5961dc73 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/data/job/JobFactoryMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/data/job/JobFactoryMuc.java @@ -8,6 +8,7 @@ import java.io.FileReader; import java.io.IOException; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -43,7 +44,7 @@ public void readWorkingTimeDistributions(Properties properties) { if (startTimeDistributionByJobType.containsKey(header[column])) { startTimeDistributionByJobType.get(header[column]).put(time, Double.parseDouble(row[column])); } else { - Map startTimeDistribution = new HashMap<>(); + Map startTimeDistribution = new LinkedHashMap<>(); startTimeDistribution.put(time, Double.parseDouble(row[column])); startTimeDistributionByJobType.put(header[column], startTimeDistribution); } @@ -66,7 +67,7 @@ public void readWorkingTimeDistributions(Properties properties) { if (workingTimeDistributionByJobType.containsKey(header[column])) { workingTimeDistributionByJobType.get(header[column]).put(time, Double.parseDouble(row[column])); } else { - Map workingTimeDistribution = new HashMap<>(); + Map workingTimeDistribution = new LinkedHashMap<>(); workingTimeDistribution.put(time, Double.parseDouble(row[column])); workingTimeDistributionByJobType.put(header[column], workingTimeDistribution); } diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelMuc.java index 388eba8ef..cbffc6164 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/models/carOwnership/SwitchToAutonomousVehicleModelMuc.java @@ -17,6 +17,7 @@ import java.io.InputStreamReader; import java.io.Reader; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Random; import java.util.stream.Collectors; @@ -33,7 +34,7 @@ public class SwitchToAutonomousVehicleModelMuc extends AbstractModel implements /** * this variable stores a summary for print out purposes */ - private Map summary = new HashMap<>(); + private Map summary = new LinkedHashMap<>(); public SwitchToAutonomousVehicleModelMuc(DataContainer dataContainer, Properties properties, InputStream inputStream, Random rnd) { super(dataContainer, properties, rnd); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/av/ParkingSimpleMoceChoice.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/av/ParkingSimpleMoceChoice.java index 578a96b29..10abdc884 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/av/ParkingSimpleMoceChoice.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/av/ParkingSimpleMoceChoice.java @@ -19,10 +19,7 @@ import de.tum.bgu.msm.properties.Properties; import org.matsim.api.core.v01.TransportMode; -import java.util.HashMap; -import java.util.Map; -import java.util.Random; -import java.util.TreeMap; +import java.util.*; public class ParkingSimpleMoceChoice implements CommuteModeChoice { private final Properties properties; @@ -64,7 +61,7 @@ public CommuteModeChoiceMapping assignCommuteModeChoice(Location from, TravelTim CommuteModeChoiceMapping commuteModeChoiceMapping = new CommuteModeChoiceMapping(HouseholdUtil.getNumberOfWorkers(household)); - Map> commuteModesByPerson = new HashMap<>(); + Map> commuteModesByPerson = new LinkedHashMap<>(); TreeMap personByProbability = new TreeMap<>(); for (Person pp : household.getPersons().values()) { @@ -97,7 +94,7 @@ public CommuteModeChoiceMapping assignCommuteModeChoice(Location from, TravelTim ptUtility = Math.exp(ptUtility); carUtility = Math.exp(carUtility); - Map utilityByMode = new HashMap<>(); + Map utilityByMode = new LinkedHashMap<>(); utilityByMode.put(TransportMode.car, Math.pow(commutingTimeProbabilityCar, B_EXP_HOUSING_UTILITY)); utilityByMode.put(TransportMode.pt, Math.pow(commutingTimeProbabilityPt, B_EXP_HOUSING_UTILITY)); commuteModesByPerson.put(pp.getId(), utilityByMode); @@ -142,7 +139,7 @@ public CommuteModeChoiceMapping assignRegionalCommuteModeChoice(Region region, T CommuteModeChoiceMapping commuteModeChoiceMapping = new CommuteModeChoiceMapping(HouseholdUtil.getNumberOfWorkers(household)); - Map> commuteModesByPerson = new HashMap<>(); + Map> commuteModesByPerson = new LinkedHashMap<>(); TreeMap personByProbability = new TreeMap<>(); @@ -169,7 +166,7 @@ public CommuteModeChoiceMapping assignRegionalCommuteModeChoice(Region region, T LocationParkingData locationParkingData = (LocationParkingData) region.getAttributes().get("PARKING"); double penaltyDueToParking = 0.1 + 0.3 * locationParkingData.getParkingQuality(); carUtility = carUtility * penaltyDueToParking; - Map utilityByMode = new HashMap<>(); + Map utilityByMode = new LinkedHashMap<>(); utilityByMode.put(TransportMode.car, Math.pow(commutingTimeProbabilityCar, B_EXP_HOUSING_UTILITY)); utilityByMode.put(TransportMode.pt, Math.pow(commutingTimeProbabilityPt, B_EXP_HOUSING_UTILITY)); commuteModesByPerson.put(pp.getId(), utilityByMode); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopmentOnly/CoreCityJobMarketUpdate.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopmentOnly/CoreCityJobMarketUpdate.java index 41c2a7058..1692ba0d6 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopmentOnly/CoreCityJobMarketUpdate.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/coreCityDevelopmentOnly/CoreCityJobMarketUpdate.java @@ -59,7 +59,7 @@ private void updateJobInventoryMultiThreadedThisYear(int year) { jobsByZone[jobTypeId][jj.getZoneId()]++; } - Map> jobsAvailableForRemoval = new HashMap<>(); + Map> jobsAvailableForRemoval = new LinkedHashMap<>(); for (Job jj : jobDataManager.getJobs()) { String token = jj.getType() + "." + jj.getZoneId() + "." + (jj.getWorkerId() == -1); if (jobsAvailableForRemoval.containsKey(token)) { diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdate.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdate.java index 4f98e331d..b6875af6d 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdate.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/draconicResettlement/DraconicResettlementJobMarketUpdate.java @@ -66,7 +66,7 @@ private void updateJobInventoryMultiThreadedThisYear(int year) { logger.info(" Updating job market based on exogenous forecast for " + year + " (multi-threaded step)"); - Map> jobsAvailableForRemoval = new HashMap<>(); + Map> jobsAvailableForRemoval = new LinkedHashMap<>(); for (Job jj : jobDataManager.getJobs()) { String token = jj.getType() + "." + jj.getZoneId() + "." + (jj.getWorkerId() == -1); if (jobsAvailableForRemoval.containsKey(token)) { diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/EVResultMonitor.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/EVResultMonitor.java index b86961cf3..ef1e69191 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/EVResultMonitor.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/EVResultMonitor.java @@ -52,7 +52,7 @@ public void endYear(int year, Multiset> eventCounter int nAutos = 0; int nEVs = 0; - Map dataByZone = new HashMap<>(); + Map dataByZone = new LinkedHashMap<>(); for (Household hh : dataContainer.getHouseholdDataManager().getHouseholds()) { diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/SwitchToElectricVehicleModelMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/SwitchToElectricVehicleModelMuc.java index cd3d0a5ff..bd6044664 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/SwitchToElectricVehicleModelMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/ev/SwitchToElectricVehicleModelMuc.java @@ -30,7 +30,7 @@ public class SwitchToElectricVehicleModelMuc extends AbstractModel implements Mo /** * this variable stores a summary for print out purposes */ - private Map summary = new HashMap<>(); + private Map summary = new LinkedHashMap<>(); public SwitchToElectricVehicleModelMuc(DataContainer dataContainer, Properties properties, Random rnd) { super(dataContainer, properties, rnd); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthDataContainerImpl.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthDataContainerImpl.java index cdf369c51..db4e7dc08 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthDataContainerImpl.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthDataContainerImpl.java @@ -32,7 +32,7 @@ public class HealthDataContainerImpl implements DataContainerWithSchools, DataCo private final DataContainerWithSchools delegate; private final Properties properties; - private Map, LinkInfo> linkInfo = new HashMap<>(); + private Map, LinkInfo> linkInfo = new LinkedHashMap<>(); private Set pollutantSet = new HashSet<>(); private EnumMap>> avgSpeeds; diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthModelMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthModelMuc.java index 0f3409b9b..b4657bf12 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthModelMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/HealthModelMuc.java @@ -76,7 +76,7 @@ public void endYear(int year) { scenario = ScenarioUtils.createMutableScenario(initialMatsimConfig); String networkFile = properties.main.baseDirectory + "/" + scenario.getConfig().network().getInputFile(); new MatsimNetworkReader(scenario.getNetwork()).readFile(networkFile); - Map, LinkInfo> linkInfoMap = new HashMap<>(); + Map, LinkInfo> linkInfoMap = new LinkedHashMap<>(); for(Link link : scenario.getNetwork().getLinks().values()){ linkInfoMap.put(link.getId(), new LinkInfo(link.getId())); } @@ -114,7 +114,7 @@ public void endYear(int year) { scenario = ScenarioUtils.createMutableScenario(initialMatsimConfig); String networkFile = properties.main.baseDirectory + "/" + scenario.getConfig().network().getInputFile(); new MatsimNetworkReader(scenario.getNetwork()).readFile(networkFile); - Map, LinkInfo> linkInfoMap = new HashMap<>(); + Map, LinkInfo> linkInfoMap = new LinkedHashMap<>(); for(Link link : scenario.getNetwork().getLinks().values()){ linkInfoMap.put(link.getId(), new LinkInfo(link.getId())); } @@ -352,12 +352,12 @@ private void calculatePathExposures(Trip trip,LeastCostPathCalculator.Path path, pathExposureNo2 += linkExposureNo2; } - Map accidentRiskMap = new HashMap<>(); + Map accidentRiskMap = new LinkedHashMap<>(); //accidentRiskMap.put("lightInjury", pathLightInjuryRisk); accidentRiskMap.put("severeInjury", (float) pathSevereInjuryRisk); accidentRiskMap.put("fatality", (float) pathFatalityRisk); - Map exposureMap = new HashMap<>(); + Map exposureMap = new LinkedHashMap<>(); exposureMap.put("pm2.5", (float) pathExposurePm25); exposureMap.put("no2", (float) pathExposureNo2); @@ -380,7 +380,7 @@ private void calculateActivityExposures(Trip trip) { } // todo: consider location-specific exposures & occupation-specific METs for work activities - Map exposureMap = new HashMap<>(); + Map exposureMap = new LinkedHashMap<>(); exposureMap.put("pm2.5", (float) PollutionExposure.getActivityExposurePm25(activityDuration)); exposureMap.put("no2", (float) PollutionExposure.getActivityExposureNo2(activityDuration)); @@ -473,7 +473,7 @@ private void calculatePersonHealthExposuresAtHome() { for(Person person : dataContainer.getHouseholdDataManager().getPersons()) { double minutesAtHome = Math.max(0., 10080. - (((PersonHealth) person).getWeeklyTravelSeconds() / 60.) - (((PersonHealth) person).getWeeklyActivityMinutes())); - Map exposureMap = new HashMap<>(); + Map exposureMap = new LinkedHashMap<>(); exposureMap.put("pm2.5", (float) PollutionExposure.getHomeExposurePm25(minutesAtHome)); exposureMap.put("no2", (float) PollutionExposure.getHomeExposureNo2(minutesAtHome)); diff --git a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/PersonHealthMuc.java b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/PersonHealthMuc.java index 7339839cd..639cfb809 100644 --- a/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/PersonHealthMuc.java +++ b/useCases/munich/src/main/java/de/tum/bgu/msm/scenarios/healthMuc/PersonHealthMuc.java @@ -25,9 +25,9 @@ public class PersonHealthMuc implements PersonWithSchool, PersonHealth { private float weeklyHomeMinutes = 0.f; //for health model - private Map weeklyMarginalMetHours = new HashMap<>(); - private Map weeklyAccidentRisks = new HashMap<>(); - private Map weeklyExposureByPollutant = new HashMap<>(); + private Map weeklyMarginalMetHours = new LinkedHashMap<>(); + private Map weeklyAccidentRisks = new LinkedHashMap<>(); + private Map weeklyExposureByPollutant = new LinkedHashMap<>(); private Map relativeRisks; private float allCauseRR; From 9f2022d64d275372a483b721a1417a6e159e0ece Mon Sep 17 00:00:00 2001 From: Kai Nagel Date: Tue, 21 Apr 2026 09:19:28 +0200 Subject: [PATCH 2/5] see if the fabiland test now goes one step further --- useCases/fabiland/src/test/java/run/RunFabilandTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/useCases/fabiland/src/test/java/run/RunFabilandTest.java b/useCases/fabiland/src/test/java/run/RunFabilandTest.java index 9a8460fae..005ed0163 100644 --- a/useCases/fabiland/src/test/java/run/RunFabilandTest.java +++ b/useCases/fabiland/src/test/java/run/RunFabilandTest.java @@ -63,7 +63,7 @@ public void testMain(){ final String expected = inputDirectory + "1.0.plans.xml.gz"; final String actual = "scenario/scenOutput/base/matsim/1/ITERS/it.0/1.0.plans.xml.gz"; PopulationComparison.Result result = PopulationUtils.comparePopulations( expected, actual ); -// Assertions.assertEquals( PopulationComparison.Result.equal, result ); + Assertions.assertEquals( PopulationComparison.Result.equal, result ); } log.info("############################################"); log.info("############################################"); From d44372f076c9f4fbbabe263504a0c4d2e97a3da4 Mon Sep 17 00:00:00 2001 From: Kai Nagel Date: Tue, 21 Apr 2026 09:33:46 +0200 Subject: [PATCH 3/5] switch of threading in MovesModelImpl --- .../tum/bgu/msm/models/relocation/moves/MovesModelImpl.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java index 72c6a7fa7..5c2d8a7f2 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java @@ -51,7 +51,8 @@ public class MovesModelImpl extends AbstractModel implements MovesModel { private final MovesStrategy movesStrategy; private final HousingStrategy housingStrategy; - private final boolean threaded; + private final boolean threaded = false; + // switching this off since we are searching for randomness in regression tests private final Map averageHousingSatisfaction = new ConcurrentHashMap<>(); private final Map satisfactionByHousehold = new ConcurrentHashMap<>(); @@ -72,7 +73,7 @@ public MovesModelImpl(DataContainer dataContainer, Properties properties, MovesS // } this.movesStrategy = movesStrategy; this.housingStrategy = housingStrategy; - this.threaded = properties.transportModel.travelTimeImplIdentifier == TransportModelPropertiesModule.TravelTimeImplIdentifier.MATSIM; +// this.threaded = properties.transportModel.travelTimeImplIdentifier == TransportModelPropertiesModule.TravelTimeImplIdentifier.MATSIM; } @Override From bbd22c7ca21af881cdf99d947961f78d3a06b05e Mon Sep 17 00:00:00 2001 From: Kai Nagel Date: Tue, 21 Apr 2026 09:35:15 +0200 Subject: [PATCH 4/5] make a non-final static variable non-static --- .../de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java index 5c2d8a7f2..6f2e09f6a 100644 --- a/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java +++ b/siloCore/src/main/java/de/tum/bgu/msm/models/relocation/moves/MovesModelImpl.java @@ -43,7 +43,7 @@ public class MovesModelImpl extends AbstractModel implements MovesModel { // public static BufferedWriter fileWriter; - public static boolean track = false; + public boolean track = false; protected final static Logger logger = LogManager.getLogger(MovesModelImpl.class); private static final int MAX_NUMBER_DWELLINGS = 20; From 2897ab349e99b121f2ba65e3851d20d7b1fbd36d Mon Sep 17 00:00:00 2001 From: Kai Nagel Date: Tue, 21 Apr 2026 19:37:10 +0200 Subject: [PATCH 5/5] comment in more assertions --- useCases/fabiland/src/test/java/run/RunFabilandTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/useCases/fabiland/src/test/java/run/RunFabilandTest.java b/useCases/fabiland/src/test/java/run/RunFabilandTest.java index 005ed0163..ef6268f46 100644 --- a/useCases/fabiland/src/test/java/run/RunFabilandTest.java +++ b/useCases/fabiland/src/test/java/run/RunFabilandTest.java @@ -71,7 +71,7 @@ public void testMain(){ String expected = inputDirectory + "/1.0.events.xml.gz" ; String actual = "scenario/scenOutput/base/matsim/1/ITERS/it.0/1.0.events.xml.gz" ; ComparisonResult result = EventsUtils.compareEventsFiles( expected, actual ); -// Assertions.assertEquals( FILES_ARE_EQUAL, result ); + Assertions.assertEquals( FILES_ARE_EQUAL, result ); } log.info("############################################"); @@ -81,7 +81,7 @@ public void testMain(){ final String expected = inputDirectory + "1.output_plans.xml.gz"; final String actual = "scenario/scenOutput/base/matsim/1/1.output_plans.xml.gz"; PopulationComparison.Result result = PopulationUtils.comparePopulations( expected, actual ); -// Assertions.assertEquals( PopulationComparison.Result.equal, result ); + Assertions.assertEquals( PopulationComparison.Result.equal, result ); } log.info("############################################"); log.info("############################################"); @@ -89,7 +89,7 @@ public void testMain(){ String expected = inputDirectory + "/1.output_events.xml.gz" ; String actual = "scenario/scenOutput/base/matsim/1/1.output_events.xml.gz" ; ComparisonResult result = EventsUtils.compareEventsFiles( expected, actual ); -// Assertions.assertEquals( FILES_ARE_EQUAL, result ); + Assertions.assertEquals( FILES_ARE_EQUAL, result ); } log.info("############################################");