Merge pull request #3202 from matsim-org/refactor-parking-cost-handler

Refactor parking cost handler

Author: paulheinr

contribs/vsp/src/main/java/playground/vsp/simpleParkingCostHandler/ParkingCostConfigGroup.java

@@ -36,7 +36,6 @@ public class ParkingCostConfigGroup extends ReflectiveConfigGroup {
 	public ParkingCostConfigGroup() {
 		super(GROUP_NAME);
 	}
-
 	private String mode = "car";
 	private String dailyParkingCostLinkAttributeName = "dailyPCost";
 	private String firstHourParkingCostLinkAttributeName = "oneHourPCost";

contribs/vsp/src/main/java/playground/vsp/simpleParkingCostHandler/ParkingCostHandler.java

@@ -19,12 +19,9 @@
 
 package playground.vsp.simpleParkingCostHandler;
 
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
-import org.apache.commons.lang.StringUtils;
+import com.google.common.annotations.VisibleForTesting;
 import org.matsim.api.core.v01.Id;
 import org.matsim.api.core.v01.Scenario;
 import org.matsim.api.core.v01.events.ActivityEndEvent;
@@ -41,39 +38,39 @@
 import org.matsim.api.core.v01.network.Link;
 import org.matsim.api.core.v01.population.Person;
 import org.matsim.core.api.experimental.events.EventsManager;
-import org.matsim.core.config.groups.QSimConfigGroup;
-import org.matsim.core.controler.events.AfterMobsimEvent;
-import org.matsim.core.controler.listener.AfterMobsimListener;
 import org.matsim.core.router.StageActivityTypeIdentifier;
 
 import com.google.inject.Inject;
+import org.matsim.utils.objectattributes.attributable.Attributes;
 
 /**
 * @author ikaddoura
 */
 
+/**
+ * This class handles parking costs for different types of parking activities.
+ * There are still things to refactor:
+ * - There are lots of magic numbers.
+ * - The method handleEvent(PersonEntersVehicleEvent event) is too long.
+ * - Helpful comments are missing.
+ * At least, there is a test class for this class. (paul april 2024)
+ */
 final class ParkingCostHandler implements TransitDriverStartsEventHandler, ActivityEndEventHandler, PersonDepartureEventHandler, PersonLeavesVehicleEventHandler, PersonEntersVehicleEventHandler {
-	
+
 	private final Map<Id<Person>, Double> personId2lastLeaveVehicleTime = new HashMap<>();
 	private final Map<Id<Person>, String> personId2previousActivity = new HashMap<>();
 	private final Map<Id<Person>, Id<Link>> personId2relevantModeLinkId = new HashMap<>();
-	private final Map<Id<Person>, Id<Link>> personId2homeLinkId = new HashMap<>();
 	private final Set<Id<Person>> ptDrivers = new HashSet<>();
 	private final Set<Id<Person>> hasAlreadyPaidDailyResidentialParkingCosts = new HashSet<>();
-	private double compensationTime = Double.NaN;
-	
+
 	@Inject
 	private ParkingCostConfigGroup parkingCostConfigGroup;
-	
+
 	@Inject
 	private EventsManager events;
-	
-	@Inject
-	private Scenario scenario;
 
 	@Inject
-	private QSimConfigGroup qSimConfigGroup;
-
+	private Scenario scenario;
 
 	@Override
     public void reset(int iteration) {
@@ -84,143 +81,188 @@ public void reset(int iteration) {
        this.ptDrivers.clear();
     }
 
-
 	@Override
 	public void handleEvent(TransitDriverStartsEvent event) {
 		ptDrivers.add(event.getDriverId());
 	}
 
-
 	@Override
-	public void handleEvent(ActivityEndEvent event) {		
+	public void handleEvent(ActivityEndEvent event) {
 		if (ptDrivers.contains(event.getPersonId())) {
-			// skip pt drivers
-		} else {
-			if (!(StageActivityTypeIdentifier.isStageActivity(event.getActType()))) {
-				
-				personId2previousActivity.put(event.getPersonId(), event.getActType());
-				
-				if (personId2relevantModeLinkId.get(event.getPersonId()) != null) {
-					personId2relevantModeLinkId.remove(event.getPersonId());
-				}
-			}
-		}	
+			return;
+		}
+		if ((StageActivityTypeIdentifier.isStageActivity(event.getActType()))) {
+			return;
+		}
+		personId2previousActivity.put(event.getPersonId(), event.getActType());
+
+		if(event.getPersonId()!= null){
+			personId2relevantModeLinkId.remove(event.getPersonId());
+		}
 	}
 
 
 	@Override
 	public void handleEvent(PersonDepartureEvent event) {
-		if (! ptDrivers.contains(event.getPersonId())) {
-			// There might be several departures during a single trip.
-			if (event.getLegMode().equals(parkingCostConfigGroup.getMode())) {
-				personId2relevantModeLinkId.put(event.getPersonId(), event.getLinkId());
-			}
+		if (ptDrivers.contains(event.getPersonId())) {
+			return;
 		}
+
+		// There might be several departures during a single trip.
+		if (!event.getLegMode().equals(parkingCostConfigGroup.getMode())) {
+			return;
+		}
+
+		personId2relevantModeLinkId.put(event.getPersonId(), event.getLinkId());
 	}
 
+	@Override
+	public void handleEvent(PersonLeavesVehicleEvent event) {
+		if (ptDrivers.contains(event.getPersonId())) {
+			return;
+		}
+
+		personId2lastLeaveVehicleTime.put(event.getPersonId(), event.getTime());
+	}
 
 	@Override
 	public void handleEvent(PersonEntersVehicleEvent event) {
-		if (! ptDrivers.contains(event.getPersonId())) {
-			if (personId2relevantModeLinkId.get(event.getPersonId()) != null) {
-
-				Link link = scenario.getNetwork().getLinks().get(personId2relevantModeLinkId.get(event.getPersonId()));
-
-				if (parkingCostConfigGroup.getActivityPrefixesToBeExcludedFromParkingCost().stream()
-						.noneMatch(s -> personId2previousActivity.get(event.getPersonId()).startsWith(s))){
-
-					if (personId2previousActivity.get(event.getPersonId()).startsWith(parkingCostConfigGroup.getActivityPrefixForDailyParkingCosts())) {
-						// daily residential parking costs
-
-						if (! hasAlreadyPaidDailyResidentialParkingCosts.contains(event.getPersonId())){
-							hasAlreadyPaidDailyResidentialParkingCosts.add(event.getPersonId());
-
-							double residentialParkingFeePerDay = 0.;
-							if (link.getAttributes().getAttribute(parkingCostConfigGroup.getResidentialParkingFeeAttributeName()) != null) {
-								residentialParkingFeePerDay = (double) link.getAttributes().getAttribute(parkingCostConfigGroup.getResidentialParkingFeeAttributeName());
-							}
-
-							if (residentialParkingFeePerDay > 0.) {
-								double amount = -1. * residentialParkingFeePerDay;
-								events.processEvent(new PersonMoneyEvent(event.getTime(), event.getPersonId(), amount, "residential parking", "city", "link " + link.getId().toString()));
-							}
-						}
-
-					} else {
-						// other parking cost types
-
-						double parkingStartTime = 0.;
-						if (personId2lastLeaveVehicleTime.get(event.getPersonId()) != null) {
-							parkingStartTime = personId2lastLeaveVehicleTime.get(event.getPersonId());
-						}
-						int parkingDurationHrs = (int) Math.ceil((event.getTime() - parkingStartTime) / 3600.);
-
-						double extraHourParkingCosts = 0.;
-						if (link.getAttributes().getAttribute(parkingCostConfigGroup.getExtraHourParkingCostLinkAttributeName()) != null) {
-							extraHourParkingCosts = (double) link.getAttributes().getAttribute(parkingCostConfigGroup.getExtraHourParkingCostLinkAttributeName());
-						}
-
-						double firstHourParkingCosts = 0.;
-						if (link.getAttributes().getAttribute(parkingCostConfigGroup.getFirstHourParkingCostLinkAttributeName()) != null) {
-							firstHourParkingCosts = (double) link.getAttributes().getAttribute(parkingCostConfigGroup.getFirstHourParkingCostLinkAttributeName());
-						}
-
-						double dailyParkingCosts = firstHourParkingCosts + 29 * extraHourParkingCosts;
-						if (link.getAttributes().getAttribute(parkingCostConfigGroup.getDailyParkingCostLinkAttributeName()) != null) {
-							dailyParkingCosts = (double) link.getAttributes().getAttribute(parkingCostConfigGroup.getDailyParkingCostLinkAttributeName());
-						}
-
-						double maxDailyParkingCosts = dailyParkingCosts;
-						if (link.getAttributes().getAttribute(parkingCostConfigGroup.getMaxDailyParkingCostLinkAttributeName()) != null) {
-							maxDailyParkingCosts = (double) link.getAttributes().getAttribute(parkingCostConfigGroup.getMaxDailyParkingCostLinkAttributeName());
-						}
-
-						double maxParkingDurationHrs = 30;
-						if (link.getAttributes().getAttribute(parkingCostConfigGroup.getMaxParkingDurationAttributeName()) != null) {
-							maxParkingDurationHrs = (double) link.getAttributes().getAttribute(parkingCostConfigGroup.getMaxParkingDurationAttributeName());
-						}
-
-						double parkingPenalty = 0.;
-						if (link.getAttributes().getAttribute(parkingCostConfigGroup.getParkingPenaltyAttributeName()) != null) {
-							parkingPenalty = (double) link.getAttributes().getAttribute(parkingCostConfigGroup.getParkingPenaltyAttributeName());
-						}
-
-						double costs = 0.;
-						if (parkingDurationHrs > 0) {
-							costs += firstHourParkingCosts;
-							costs += (parkingDurationHrs - 1) * extraHourParkingCosts;
-						}
-						if (costs > dailyParkingCosts) {
-							costs = dailyParkingCosts;
-						}
-						if (costs > maxDailyParkingCosts) {
-							costs = maxDailyParkingCosts;
-						}
-						if ((parkingDurationHrs > maxParkingDurationHrs) & (costs < parkingPenalty)) {
-							costs = parkingPenalty;
-						}
-
-						if (costs > 0.) {
-							double amount = -1. * costs;
-							events.processEvent(new PersonMoneyEvent(event.getTime(), event.getPersonId(), amount, "non-residential parking", "city", "link " + link.getId().toString()));
-						}
-
-					}
-
-				}
+		// Preliminaries
+		if (ptDrivers.contains(event.getPersonId())) {
+			return;
+		}
+		if (personId2relevantModeLinkId.get(event.getPersonId()) == null) {
+			return;
+		}
 
+		if (parkingCostConfigGroup.getActivityPrefixesToBeExcludedFromParkingCost().stream()
+				.anyMatch(s -> personId2previousActivity.get(event.getPersonId()).startsWith(s))) {
+			return;
+		}
+
+		Link link = scenario.getNetwork().getLinks().get(personId2relevantModeLinkId.get(event.getPersonId()));
+		Attributes attributes = link.getAttributes();
+
+		if (personId2previousActivity.get(event.getPersonId()).startsWith(parkingCostConfigGroup.getActivityPrefixForDailyParkingCosts())) {
+			// daily residential parking costs
+			if (hasAlreadyPaidDailyResidentialParkingCosts.contains(event.getPersonId())){
+				// has already paid daily residential parking costs
+				return;
+			}
+			hasAlreadyPaidDailyResidentialParkingCosts.add(event.getPersonId());
+
+			double residentialParkingFeePerDay = getResidentialParkingFeePerDay(attributes);
+
+			if (residentialParkingFeePerDay > 0.) {
+				double amount = -1. * residentialParkingFeePerDay;
+				events.processEvent(createPersonMoneyEvent(event, amount, link, "residential parking"));
 			}
+			return;
 		}
 
+		// other parking cost types
+
+		double costs = calculateNonResidentialParkingCosts(event, attributes);
+
+		if (costs <= 0.) {
+			return;
+		}
+		double amount = -1. * costs;
+		events.processEvent(createPersonMoneyEvent(event, amount, link, "non-residential parking"));
 	}
 
+	private PersonMoneyEvent createPersonMoneyEvent(PersonEntersVehicleEvent event, double amount, Link link, String purpose) {
+		return new PersonMoneyEvent(event.getTime(), event.getPersonId(), amount, purpose, "city", "link " + link.getId());
+	}
 
-	@Override
-	public void handleEvent(PersonLeavesVehicleEvent event) {
-		if (! ptDrivers.contains(event.getPersonId())) {
-			personId2lastLeaveVehicleTime.put(event.getPersonId(), event.getTime());
+	private double calculateNonResidentialParkingCosts(PersonEntersVehicleEvent event, Attributes attributes) {
+		double costs = 0.;
+
+		int parkingDurationHrs = (int) Math.ceil((event.getTime() - getParkingStartTime(event)) / 3600.);
+		double firstHourParkingCosts = getFirstHourParkingCosts(attributes);
+		double extraHourParkingCosts = getExtraHourParkingCosts(attributes);
+
+		if (parkingDurationHrs > 0) {
+			costs += firstHourParkingCosts;
+			costs += (parkingDurationHrs - 1) * extraHourParkingCosts;
+		}
+
+		double dailyParkingCosts = getDailyParkingCosts(attributes, firstHourParkingCosts, extraHourParkingCosts);
+
+		if (costs > dailyParkingCosts) {
+			costs = dailyParkingCosts;
+		}
+
+		double maxDailyParkingCosts = getMaxDailyParkingCosts(attributes, dailyParkingCosts);
+
+		if (costs > maxDailyParkingCosts) {
+			costs = maxDailyParkingCosts;
 		}
+
+		double maxParkingDurationHrs = getMaxParkingDurationHrs(attributes);
+		double parkingPenalty = getParkingPenalty(attributes);
+
+		if ((parkingDurationHrs > maxParkingDurationHrs) & (costs < parkingPenalty)) {
+			costs = parkingPenalty;
+		}
+		return costs;
+	}
+
+	private double getResidentialParkingFeePerDay(Attributes attributes) {
+		return (double) Optional.ofNullable(attributes.getAttribute(parkingCostConfigGroup.getResidentialParkingFeeAttributeName())).orElse(0.);
+	}
+
+	private double getParkingStartTime(PersonEntersVehicleEvent event) {
+		return Optional.ofNullable(personId2lastLeaveVehicleTime.get(event.getPersonId())).orElse(0.);
+	}
+
+	private double getExtraHourParkingCosts(Attributes attributes) {
+		return (double) Optional.ofNullable(attributes.getAttribute(parkingCostConfigGroup.getExtraHourParkingCostLinkAttributeName())).orElse(0.);
 	}
 
+	private double getFirstHourParkingCosts(Attributes attributes) {
+		return (double) Optional.ofNullable(attributes.getAttribute(parkingCostConfigGroup.getFirstHourParkingCostLinkAttributeName())).orElse(0.);
+	}
+
+	private double getDailyParkingCosts(Attributes attributes, double firstHourParkingCosts, double extraHourParkingCosts) {
+		return (double) Optional.ofNullable(attributes.getAttribute(parkingCostConfigGroup.getDailyParkingCostLinkAttributeName())).orElse(firstHourParkingCosts + 29 * extraHourParkingCosts);
+	}
+
+	private double getMaxDailyParkingCosts(Attributes attributes, double dailyParkingCosts) {
+		return (double) Optional.ofNullable(attributes.getAttribute(parkingCostConfigGroup.getMaxDailyParkingCostLinkAttributeName())).orElse(dailyParkingCosts);
+	}
+
+	private double getMaxParkingDurationHrs(Attributes attributes) {
+		return (double) Optional.ofNullable(attributes.getAttribute(parkingCostConfigGroup.getMaxParkingDurationAttributeName())).orElse(30.);
+	}
+
+	private double getParkingPenalty(Attributes attributes) {
+		return (double) Optional.ofNullable(attributes.getAttribute(parkingCostConfigGroup.getParkingPenaltyAttributeName())).orElse(0.);
+	}
+
+	@VisibleForTesting
+	Map<Id<Person>, Double> getPersonId2lastLeaveVehicleTime() {
+		return personId2lastLeaveVehicleTime;
+	}
+
+	@VisibleForTesting
+	Map<Id<Person>, String> getPersonId2previousActivity() {
+		return personId2previousActivity;
+	}
+
+	@VisibleForTesting
+	Map<Id<Person>, Id<Link>> getPersonId2relevantModeLinkId() {
+		return personId2relevantModeLinkId;
+	}
+
+	@VisibleForTesting
+	Set<Id<Person>> getPtDrivers() {
+		return ptDrivers;
+	}
+
+	@VisibleForTesting
+	Set<Id<Person>> getHasAlreadyPaidDailyResidentialParkingCosts() {
+		return hasAlreadyPaidDailyResidentialParkingCosts;
+	}
 }
 

contribs/vsp/src/test/java/playground/vsp/simpleParkingCostHandler/ParkingCostHandlerTest.java

@@ -0,0 +1,388 @@
+package playground.vsp.simpleParkingCostHandler;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.junit.jupiter.api.*;
+import org.matsim.api.core.v01.Coord;
+import org.matsim.api.core.v01.Id;
+import org.matsim.api.core.v01.Scenario;
+import org.matsim.api.core.v01.events.*;
+import org.matsim.api.core.v01.network.Link;
+import org.matsim.api.core.v01.network.Network;
+import org.matsim.api.core.v01.network.Node;
+import org.matsim.api.core.v01.population.Person;
+import org.matsim.api.core.v01.population.Plan;
+import org.matsim.core.api.experimental.events.EventsManager;
+import org.matsim.core.config.Config;
+import org.matsim.core.config.ConfigUtils;
+import org.matsim.core.controler.OutputDirectoryHierarchy;
+import org.matsim.core.events.handler.EventHandler;
+import org.matsim.core.network.NetworkUtils;
+import org.matsim.core.scenario.ScenarioUtils;
+import org.matsim.utils.objectattributes.attributable.Attributes;
+
+import java.util.*;
+
+/**
+ * Tests for the ParkingCostHandler class.
+ * The following test cases could be added:
+ * - Test chain of parking events.
+ * - Test activity prefixes excluded from parking.
+ */
+public class ParkingCostHandlerTest {
+	private Injector injector;
+
+	@BeforeEach
+	public void setup() {
+		Config config = ConfigUtils.createConfig();
+		config.controller().setOverwriteFileSetting(OutputDirectoryHierarchy.OverwriteFileSetting.deleteDirectoryIfExists);
+		Scenario scenario = ScenarioUtils.createScenario(config);
+		Network network = NetworkUtils.createNetwork(config);
+
+		TestsEventsManager eventsManager = new TestsEventsManager();
+		ParkingCostConfigGroup configGroup = new ParkingCostConfigGroup();
+
+		injector = Guice.createInjector(new AbstractModule() {
+			@Override
+			public void configure() {
+				bind(ParkingCostConfigGroup.class).toInstance(configGroup);
+				bind(EventsManager.class).toInstance(eventsManager);
+				bind(Scenario.class).toInstance(scenario);
+				bind(Network.class).toInstance(network);
+			}
+		});
+	}
+	// Basic Event Handling Tests
+	@Test
+	public void transitDriverStartsEventTest() {
+		Person ptDriver = new Tester(0);
+		TransitDriverStartsEvent tDSE = new TransitDriverStartsEvent(0, ptDriver.getId(), null, null, null, null);
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+		pch.handleEvent(tDSE);
+		Assertions.assertTrue(pch.getPtDrivers().contains(ptDriver.getId()));
+	}
+
+	@Test
+	public void personLeavesVehicleEventTest() {
+		Person ptDriver = new Tester(0);
+		Person tester = new Tester(1);
+
+		TransitDriverStartsEvent tDSEvent = new TransitDriverStartsEvent(0, ptDriver.getId(), null, null, null, null);
+		PersonLeavesVehicleEvent pLVEventParking = new PersonLeavesVehicleEvent(100, tester.getId(), null);
+		PersonLeavesVehicleEvent pLVEventPtDriver = new PersonLeavesVehicleEvent(100, ptDriver.getId(), null);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+
+		pch.handleEvent(tDSEvent);
+		pch.handleEvent(pLVEventParking);
+		pch.handleEvent(pLVEventPtDriver);
+
+		Assertions.assertTrue(pch.getPtDrivers().contains(ptDriver.getId()));
+		Assertions.assertFalse(pch.getPersonId2lastLeaveVehicleTime().containsKey(ptDriver.getId()));
+		Assertions.assertTrue(pch.getPersonId2lastLeaveVehicleTime().containsKey(tester.getId()));
+		Assertions.assertEquals(100.,pch.getPersonId2lastLeaveVehicleTime().get(tester.getId()));
+	}
+	@Test
+	public void activityEndEventTest() {
+		Person tester1 = new Tester(0);
+		String actType1 = "test";
+
+		Person tester2 = new Tester(1);
+		String actType2 = "test-interaction";
+
+		Person ptDriver = new Tester(2);
+
+		ActivityEndEvent aEEventActivity = new ActivityEndEvent(0, tester1.getId(), null, null,actType1, null);
+		ActivityEndEvent aEEventInteraction = new ActivityEndEvent(0, tester2.getId(), null, null, actType2, null);
+		TransitDriverStartsEvent tDSEvent = new TransitDriverStartsEvent(0, ptDriver.getId(), null, null, null, null);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+
+		pch.handleEvent(tDSEvent);
+		pch.handleEvent(aEEventActivity);
+		pch.handleEvent(aEEventInteraction);
+
+		Assertions.assertNull(pch.getPersonId2previousActivity().get(tester2.getId()));
+		Assertions.assertEquals(actType1, pch.getPersonId2previousActivity().get(tester1.getId()));
+
+		Assertions.assertFalse(pch.getPersonId2previousActivity().containsKey(ptDriver.getId()));
+		Assertions.assertTrue(pch.getPtDrivers().contains(ptDriver.getId()));
+	}
+	@Test
+	public void personDepartureEventTest() {
+		Person testerWithCar = new Tester(0);
+		Person testerWithoutCar = new Tester(1);
+		Person ptDriver = new Tester(2);
+
+		PersonDepartureEvent pDEventCar = new PersonDepartureEvent(0, testerWithCar.getId(),null, "car",null);
+		PersonDepartureEvent pDEventNoCar = new PersonDepartureEvent(0, testerWithoutCar.getId(), null, "pt", null);
+		PersonDepartureEvent pDEventPtDriver = new PersonDepartureEvent(0, ptDriver.getId(),null,"pt",null);
+		TransitDriverStartsEvent tDSEvent = new TransitDriverStartsEvent(0, ptDriver.getId(), null, null, null, null);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+
+		pch.handleEvent(tDSEvent);
+		pch.handleEvent(pDEventCar);
+		pch.handleEvent(pDEventNoCar);
+		pch.handleEvent(pDEventPtDriver);
+
+		Assertions.assertTrue(pch.getPtDrivers().contains(ptDriver.getId()));
+		Assertions.assertFalse(pch.getPersonId2relevantModeLinkId().containsKey(ptDriver.getId()));
+		Assertions.assertFalse(pch.getPersonId2relevantModeLinkId().containsKey(testerWithoutCar.getId()));
+		Assertions.assertTrue(pch.getPersonId2relevantModeLinkId().containsKey(testerWithCar.getId()));
+	}
+	@Test
+	public void personEntersVehicleEventTest() {
+		// tests basic functionality and cost calculation
+		Link link = createNetworkAndSetupLink(10,440,5,15,500,30,30);
+		// Persons construction
+		Person ptDriver = new Tester(0); // should not pay at all
+		Person resident = new Tester(1); // should pay residential parking costs
+		Person shopper = new Tester(2); // should pay non-residential parking costs
+		// Event construction
+			// ptDriver events
+		TransitDriverStartsEvent tDSEvent = new TransitDriverStartsEvent(0, ptDriver.getId(), null, null, null, null);
+		PersonLeavesVehicleEvent pLVEventPtDriver = new PersonLeavesVehicleEvent(1000, ptDriver.getId(), null);
+		PersonEntersVehicleEvent pEVEventPtDriver = new PersonEntersVehicleEvent(11000, ptDriver.getId(),null);
+			// resident events
+		List<Event> residentEvents = createParkingEvents(resident.getId(),link.getId(),"home","car",10);
+			// shopper events
+		List<Event> shopperEvents = createParkingEvents(shopper.getId(),link.getId(),"shopping","car",1);
+
+		// Event handling
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+			// ptDriver handling
+		pch.handleEvent(tDSEvent);
+		pch.handleEvent(pLVEventPtDriver);
+		pch.handleEvent(pEVEventPtDriver);
+			// resident handling
+		handleParkingEvents(pch, residentEvents);
+			// shopper handling
+		handleParkingEvents(pch, shopperEvents);
+
+		// Assertions
+		TestsEventsManager eventsManager = (TestsEventsManager) injector.getInstance(EventsManager.class);
+			// ptDriver assertions
+		Assertions.assertTrue(pch.getPtDrivers().contains(ptDriver.getId()));
+		Assertions.assertNull(eventsManager.getEventByPersonId(ptDriver.getId()));
+			// resident assertions
+		Assertions.assertTrue(pch.getHasAlreadyPaidDailyResidentialParkingCosts().contains(resident.getId()));
+		Assertions.assertEquals(-10.0, eventsManager.getEventByPersonId(resident.getId()).getAmount());
+		Assertions.assertEquals("residential parking", eventsManager.getEventByPersonId(resident.getId()).getPurpose());
+			// shopper assertions
+		Assertions.assertFalse(pch.getHasAlreadyPaidDailyResidentialParkingCosts().contains(shopper.getId()));
+		Assertions.assertEquals(-5, eventsManager.getEventByPersonId(shopper.getId()).getAmount());
+		Assertions.assertEquals("non-residential parking", eventsManager.getEventByPersonId(shopper.getId()).getPurpose());
+
+	}
+	// Parking Cost Calculation Tests
+	@Test
+	public void penaltyParkingCostCalculationsTest() {
+		// Network construction
+		Link link = createNetworkAndSetupLink(0, 200,10,10,200,2,100);
+		// Person construction
+		Person tester1 = new Tester(0);
+		Person tester2 = new Tester(1);
+		// Event construction
+		List<Event> events = createParkingEvents(tester1.getId(),link.getId(),"other","car",3);
+		// Event handling
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+		handleParkingEvents(pch, events);
+		handleParkingEvents(pch, createParkingEvents(tester2.getId(),link.getId(),"other","car",20));
+		// Assertions
+		TestsEventsManager eventsManager = (TestsEventsManager) injector.getInstance(EventsManager.class);
+		Assertions.assertEquals(-100, eventsManager.getEventByPersonId(tester1.getId()).getAmount());
+		Assertions.assertEquals(-200, eventsManager.getEventByPersonId(tester2.getId()).getAmount());
+	}
+	@Test
+	public void firstHourParkingCostCalculationTest() {
+		Link link = createNetworkAndSetupLink(0, 50,10,10,100,10,0);
+
+		Person tester1 = new Tester(0);
+		Person tester2 = new Tester(1);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+		handleParkingEvents(pch, createParkingEvents(tester1.getId(),link.getId(),"other","car",1));
+		handleParkingEvents(pch, createParkingEvents(tester2.getId(),link.getId(),"other","car",0.5)); // rounded up to 1hr
+
+		TestsEventsManager eventsManager = (TestsEventsManager) injector.getInstance(EventsManager.class);
+		Assertions.assertEquals(-10, eventsManager.getEventByPersonId(tester1.getId()).getAmount());
+		Assertions.assertEquals(-10, eventsManager.getEventByPersonId(tester2.getId()).getAmount());
+	}
+	@Test
+	public void hourlyParkingCostCalculationTest() {
+		Link link = createNetworkAndSetupLink(0, 150,10,20,100,10,0);
+
+		Person parking1hr = new Tester(0);
+		Person parking3hr = new Tester(1);
+		Person parking8hr = new Tester(2);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+		handleParkingEvents(pch, createParkingEvents(parking1hr.getId(),link.getId(),"other","car",1));
+		handleParkingEvents(pch, createParkingEvents(parking3hr.getId(),link.getId(),"other","car",3));
+		handleParkingEvents(pch, createParkingEvents(parking8hr.getId(),link.getId(),"other","car",8));
+
+		TestsEventsManager eventsManager = (TestsEventsManager) injector.getInstance(EventsManager.class);
+		Assertions.assertEquals(-10, eventsManager.getEventByPersonId(parking1hr.getId()).getAmount()); // first hour parking cost only
+		Assertions.assertEquals(-50, eventsManager.getEventByPersonId(parking3hr.getId()).getAmount()); // 1x 10 + 2x 20 hourly costs
+		Assertions.assertEquals(-100, eventsManager.getEventByPersonId(parking8hr.getId()).getAmount()); // 150 in hourly costs, capped by maxDailyParkingCosts
+	}
+	@Test
+	public void residentialFeeIsPaidOnceTest() {
+		Link link = createNetworkAndSetupLink(100, 0,0,0,0,0,0);
+
+		Person tester = new Tester(0);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+		handleParkingEvents(pch, createParkingEvents(tester.getId(),link.getId(),"home","car",10));
+		handleParkingEvents(pch, createParkingEvents(tester.getId(),link.getId(),"home","car",2));
+
+		TestsEventsManager eventsManager = (TestsEventsManager) injector.getInstance(EventsManager.class);
+		Assertions.assertEquals(1, eventsManager.getEvents().size());
+		Assertions.assertEquals(-100, eventsManager.getEventByPersonId(tester.getId()).getAmount());
+	}
+
+	@Test
+	public void handlerDefaultsTest() {
+		Network network = injector.getInstance(Scenario.class).getNetwork();
+		Node node1 = NetworkUtils.createAndAddNode(network, Id.createNodeId(1), new Coord(0, 0));
+		Node node2 = NetworkUtils.createAndAddNode(network, Id.createNodeId(2), new Coord(10, 0));
+		Link link = NetworkUtils.createAndAddLink(network, Id.createLinkId(1), node1, node2,10,30,100,3);
+
+		Person tester = new Tester(0);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+		handleParkingEvents(pch, createParkingEvents(tester.getId(),link.getId(),"other","car",10));
+
+		TestsEventsManager eventsManager = (TestsEventsManager) injector.getInstance(EventsManager.class);
+		Assertions.assertTrue(eventsManager.getEvents().isEmpty());
+	}
+	@Test
+	public void testDailyParkingCost() {
+		Link link = createNetworkAndSetupLink(0, 50,10,10,100,10,0);
+
+		Person tester1 = new Tester(0);
+		Person tester2 = new Tester(1);
+
+		ParkingCostHandler pch = injector.getInstance(ParkingCostHandler.class);
+		handleParkingEvents(pch, createParkingEvents(tester1.getId(),link.getId(),"other","car",10));
+		handleParkingEvents(pch, createParkingEvents(tester2.getId(),link.getId(),"other","car",2));
+
+		TestsEventsManager eventsManager = (TestsEventsManager) injector.getInstance(EventsManager.class);
+		Assertions.assertEquals(-50, eventsManager.getEventByPersonId(tester1.getId()).getAmount());
+		Assertions.assertEquals(-20, eventsManager.getEventByPersonId(tester2.getId()).getAmount());
+	}
+
+	// sets up given cost attributes for a given link
+	private Link createNetworkAndSetupLink(double residentialParkingFee, double dailyParkingCost, double firstHourParkingCost,
+										   double extraHourParkingCost, double maxDailyParkingCost, double maxParkingDurationHrs, double parkingPenaltyCost) {
+
+		Network network = injector.getInstance(Scenario.class).getNetwork();
+		Node node1 = NetworkUtils.createAndAddNode(network, Id.createNodeId(1), new Coord(0, 0));
+		Node node2 = NetworkUtils.createAndAddNode(network, Id.createNodeId(2), new Coord(10, 0));
+		Link link = NetworkUtils.createAndAddLink(network, Id.createLinkId(1), node1, node2,10,30,100,3);
+
+		ParkingCostConfigGroup configGroup = injector.getInstance(ParkingCostConfigGroup.class);
+
+		link.getAttributes().putAttribute(configGroup.getResidentialParkingFeeAttributeName(), residentialParkingFee);
+		link.getAttributes().putAttribute(configGroup.getDailyParkingCostLinkAttributeName(), dailyParkingCost);
+		link.getAttributes().putAttribute(configGroup.getFirstHourParkingCostLinkAttributeName(), firstHourParkingCost);
+		link.getAttributes().putAttribute(configGroup.getExtraHourParkingCostLinkAttributeName(), extraHourParkingCost);
+		link.getAttributes().putAttribute(configGroup.getMaxDailyParkingCostLinkAttributeName(), maxDailyParkingCost);
+		link.getAttributes().putAttribute(configGroup.getMaxParkingDurationAttributeName(), maxParkingDurationHrs);
+		link.getAttributes().putAttribute(configGroup.getParkingPenaltyAttributeName(), parkingPenaltyCost);
+
+		return link;
+	}
+
+	private List<Event> createParkingEvents(Id<Person> personId, Id<Link> linkId, String actType, String mode, double durationHrs){
+		List<Event> events = new ArrayList<>();
+		events.add(new PersonLeavesVehicleEvent(0, personId, null));
+		events.add(new ActivityEndEvent(0, personId, linkId,null, actType,null));
+		events.add(new PersonDepartureEvent(0, personId, linkId, mode,null));
+		events.add(new PersonEntersVehicleEvent(durationHrs * 3600, personId,null));
+		return events;
+	}
+
+	private void handleParkingEvents(ParkingCostHandler pch, List<Event> events) {
+		for (Event event : events) {
+			if (event instanceof PersonLeavesVehicleEvent) {
+				pch.handleEvent((PersonLeavesVehicleEvent) event);
+			}
+			if (event instanceof ActivityEndEvent) {
+				pch.handleEvent((ActivityEndEvent) event);
+			}
+			if (event instanceof PersonDepartureEvent) {
+				pch.handleEvent((PersonDepartureEvent) event);
+			}
+			if (event instanceof PersonEntersVehicleEvent) {
+				pch.handleEvent((PersonEntersVehicleEvent) event);
+			}
+		}
+	}
+}
+class TestsEventsManager implements EventsManager {
+	private final List<PersonMoneyEvent> events = new ArrayList<>();
+
+	@Override
+	public void processEvent(Event event) {
+		if (event instanceof PersonMoneyEvent) {
+			events.add((PersonMoneyEvent) event);
+		}
+	}
+	public List<PersonMoneyEvent> getEvents() {
+		return events;
+	}
+
+	public PersonMoneyEvent getEventByPersonId(Id<Person> id) {
+
+		List<PersonMoneyEvent> personMoneyEvents = events.stream().filter(e -> e.getPersonId().equals(id)).toList();
+
+		if (personMoneyEvents.size() > 1) {
+			Assertions.fail("Person has more money events than expected");
+		}
+
+		return personMoneyEvents.stream().findAny().orElse(null);
+	}
+	@Deprecated
+	public void addHandler(EventHandler handler) {}
+	@Deprecated
+	public void removeHandler(EventHandler handler) {}
+	@Deprecated
+	public void resetHandlers(int iteration) {}
+	@Deprecated
+	public void initProcessing() {}
+	@Deprecated
+	public void afterSimStep(double time) {}
+	@Deprecated
+	public void finishProcessing() {}
+}
+
+class Tester implements Person {
+
+	public Tester(long key) {
+		this.id = Id.createPersonId(key);
+	}
+
+	private final Id<Person> id;
+
+	@Override
+	public Id<Person> getId() {return this.id;}
+	@Deprecated
+	public Attributes getAttributes() {return null;}
+	@Deprecated
+	public Map<String, Object> getCustomAttributes() {return null;}
+	@Deprecated
+	public List<? extends Plan> getPlans() {return null;}
+	@Deprecated
+	public boolean addPlan(Plan p) {return false;}
+	@Deprecated
+	public boolean removePlan(Plan p) {return false;}
+	@Deprecated
+	public Plan getSelectedPlan() {return null;}
+	@Deprecated
+	public void setSelectedPlan(Plan selectedPlan) {}
+	@Deprecated
+	public Plan createCopyOfSelectedPlanAndMakeSelected() {return null;}
+}