new scoring based on distance groups

Makefile

@@ -187,7 +187,7 @@ $p/berlin-initial-$V-25pct.plans.xml.gz: $p/berlin-activities-$V-25pct.plans.xml
 	# For debugging and visualization
 	$(sc) prepare downsample-population $@\
 		 --sample-size 0.25\
-		 --samples 0.1 0.01\
+		 --samples 0.1 0.03 0.01\
 
 
 $p/berlin-longHaulFreight-$V-25pct.plans.xml.gz: $p/berlin-$V-network.xml.gz
@@ -275,7 +275,7 @@ $p/berlin-$V-25pct.plans-initial.xml.gz: $p/berlin-$V-facilities.xml.gz $p/berli
 
 	$(sc) prepare downsample-population $@\
 		 --sample-size 0.25\
-		 --samples 0.1 0.01 0.001\
+		 --samples 0.1 0.03 0.01 0.001\
 
 $p/berlin-$V-25pct.plans.xml.gz:
 	$(sc) prepare clean-population\

input/v6.1/berlin-v6.1.config.xml

@@ -104,7 +104,7 @@
 		<param name="vspDefaultsCheckingLevel" value="abort"/>
 	</module>
 
-	<module name="planCalcScore">
+	<module name="scoring">
 		<param name="fractionOfIterationsToStartScoreMSA" value="0.8"/>
 		<parameterset type="scoringParameters">
 			<param name="marginalUtilityOfMoney" value="1.0"/>
@@ -185,6 +185,24 @@
 		</parameterset>
 	</module>
 
+	<module name="vspScoring">
+
+		<!-- Scored by distance group -->
+		<parameterset type="modeParams">
+			<param name="mode" value="car" />
+		</parameterset>
+		<parameterset type="modeParams">
+			<param name="mode" value="ride" />
+		</parameterset>
+		<parameterset type="modeParams">
+			<param name="mode" value="pt" />
+		</parameterset>
+		<parameterset type="modeParams">
+			<param name="mode" value="bike" />
+		</parameterset>
+
+	</module>
+
 	<module name="counts">
 		<param name="inputCountsFile" value="./berlin-v6.1-counts-vmz.xml.gz"/>
 	</module>

src/main/java/org/matsim/prepare/RunOpenBerlinCalibration.java

@@ -55,6 +55,7 @@
 import org.matsim.prepare.population.*;
 import org.matsim.run.Activities;
 import org.matsim.run.RunOpenBerlinScenario;
+import org.matsim.run.scoring.VspScoringModule;
 import org.matsim.simwrapper.SimWrapperConfigGroup;
 import org.matsim.simwrapper.SimWrapperModule;
 import org.matsim.smallScaleCommercialTrafficGeneration.GenerateSmallScaleCommercialTrafficDemand;
@@ -398,6 +399,7 @@ public void install() {
 		});
 
 		controler.addOverridingModule(new RunOpenBerlinScenario.TravelTimeBinding());
+		controler.addOverridingModule(new VspScoringModule());
 		controler.addOverridingModule(new SimWrapperModule());
 	}
 

src/main/java/org/matsim/run/RunOpenBerlinScenario.java

@@ -16,6 +16,7 @@
 import org.matsim.core.router.costcalculators.TravelDisutilityFactory;
 import org.matsim.core.router.util.TravelTime;
 import org.matsim.prepare.RunOpenBerlinCalibration;
+import org.matsim.run.scoring.VspScoringModule;
 import org.matsim.simwrapper.SimWrapperConfigGroup;
 import org.matsim.simwrapper.SimWrapperModule;
 import picocli.CommandLine;
@@ -103,6 +104,8 @@ protected void prepareControler(Controler controler) {
 
 		controler.addOverridingModule(new TravelTimeBinding());
 
+		controler.addOverridingModule(new VspScoringModule());
+
 	}
 
 	/**

src/main/java/org/matsim/run/scoring/DetailedPersonScoringParameters.java

@@ -0,0 +1,72 @@
+package org.matsim.run.scoring;
+
+import com.google.inject.Inject;
+import org.matsim.api.core.v01.Scenario;
+import org.matsim.api.core.v01.population.Person;
+import org.matsim.core.config.ConfigUtils;
+import org.matsim.core.config.groups.ScoringConfigGroup;
+import org.matsim.core.population.PopulationUtils;
+import org.matsim.core.scoring.functions.ActivityUtilityParameters;
+import org.matsim.core.scoring.functions.ModeUtilityParameters;
+import org.matsim.core.scoring.functions.ScoringParameters;
+import org.matsim.core.scoring.functions.ScoringParametersForPerson;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+public class DetailedPersonScoringParameters implements ScoringParametersForPerson {
+
+	/**
+	 * Cache instances of {@link ActivityUtilityParameters} for each activity type.
+	 * All params are the same for each person.
+	 */
+	private final Map<String, ActivityUtilityParameters> utilParams = new TreeMap<>();
+
+	/**
+	 * Cache instances of {@link ModeUtilityParameters} for each mode.
+	 */
+	private final Map<String, DistanceGroupModeUtilityParameters> modeParams = new TreeMap<>();
+
+	@Inject
+	private Scenario scenario;
+
+	@Override
+	public ScoringParameters getScoringParameters(Person person) {
+
+		ScoringConfigGroup scoring = scenario.getConfig().scoring();
+		String subpopulation = PopulationUtils.getSubpopulation(person);
+
+		ScoringConfigGroup.ScoringParameterSet scoringParameters = scoring.getScoringParameters(subpopulation);
+
+		Map<String, ActivityUtilityParameters> personParams = new TreeMap<>();
+
+		for (ScoringConfigGroup.ActivityParams params : scoringParameters.getActivityParams()) {
+			ActivityUtilityParameters p = utilParams.computeIfAbsent(params.getActivityType(), k -> {
+				ActivityUtilityParameters.Builder factory = new ActivityUtilityParameters.Builder(params);
+				return factory.build();
+			});
+
+			personParams.put(params.getActivityType(), p);
+		}
+
+		ScoringParameters.Builder builder = new ScoringParameters.Builder(scoring, scoringParameters, personParams,
+			scenario.getConfig().scenario());
+
+		// TODO: not configurable at the moment
+		if (subpopulation.equals("person")) {
+
+			VspScoringConfigGroup vspScoring = ConfigUtils.addOrGetModule(scenario.getConfig(), VspScoringConfigGroup.class);
+
+			for (Map.Entry<String, VspScoringConfigGroup.ModeParams> e : vspScoring.getModeParams().entrySet()) {
+
+				ModeUtilityParameters params = builder.getModeParameters(e.getKey());
+				DistanceGroupModeUtilityParameters p = modeParams.computeIfAbsent(e.getKey(),
+					k -> new DistanceGroupModeUtilityParameters(params, vspScoring.getDistGroups(), e.getValue()));
+
+				builder.setModeParameters(e.getKey(), p);
+			}
+		}
+
+		return builder.build();
+	}
+}

src/main/java/org/matsim/run/scoring/DistanceGroupModeUtilityParameters.java

@@ -0,0 +1,88 @@
+package org.matsim.run.scoring;
+
+import org.matsim.core.scoring.functions.ModeUtilityParameters;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Mode utility with separate marginalUtilityOfDistance_m per distance group.
+ */
+public class DistanceGroupModeUtilityParameters extends ModeUtilityParameters {
+
+	private final List<DistanceGroup> groups = new ArrayList<>();
+
+	/**
+	 * Constructor which copies the base params from given modeParams.
+	 */
+	public DistanceGroupModeUtilityParameters(ModeUtilityParameters modeParams,
+											  List<Integer> dists, VspScoringConfigGroup.ModeParams params) {
+		super(modeParams.marginalUtilityOfTraveling_s, modeParams.marginalUtilityOfDistance_m, modeParams.monetaryDistanceCostRate,
+			modeParams.constant, modeParams.dailyMoneyConstant, modeParams.dailyUtilityConstant);
+
+		// Nothing to do if no distance groups are defined.
+		if (dists.isEmpty()) {
+			return;
+		}
+
+		List<Integer> copy = new ArrayList<>(dists);
+
+		if (copy.get(0) != 0)
+			copy.add(0, 0);
+
+		// Effectively no distance groups present
+		if (copy.size() <= 1)
+			return;
+
+		for (int i = 0; i < copy.size() - 1; i++) {
+
+			int dist = copy.get(i);
+			double util = params.getDistUtil(dist).orElseThrow();
+
+			double constant;
+			if (i == 0)
+				constant = 0;
+			else {
+				DistanceGroup prev = groups.get(groups.size() - 1);
+				constant = prev.constant + prev.util_m * (dist - prev.dist);
+			}
+
+			groups.add(new DistanceGroup(dist, constant, util));
+		}
+	}
+
+
+	/**
+	 * Calculate the utility for given distance.
+	 */
+	public double calcDistUtility(double dist) {
+
+		if (groups.isEmpty())
+			return marginalUtilityOfDistance_m * dist;
+
+		DistanceGroup group = groups.get(0);
+		for (int i = 1; i < groups.size(); i++) {
+			if (groups.get(i).dist > dist)
+				break;
+
+			group = groups.get(i);
+		}
+
+		return group.constant + group.util_m * (dist - group.dist);
+	}
+
+	/**
+	 * Store distance group
+	 * @param dist lower bound for distance group
+	 * @param constant added constant
+	 * @param util_m utility per meter, i.e. slope of linear function
+	 */
+	record DistanceGroup(double dist, double constant, double util_m) implements Comparable<DistanceGroup> {
+		@Override
+		public int compareTo(DistanceGroup o) {
+			return Double.compare(dist, o.dist);
+		}
+	}
+
+}