diff --git a/build.gradle b/build.gradle index 647439e202b..aeff6274d98 100755 --- a/build.gradle +++ b/build.gradle @@ -30,6 +30,7 @@ plugins { id 'com.bmuschko.docker-java-application' version '9.4.0' id "cz.alenkacz.gradle.scalafmt" version "1.16.2" id "java-library" + id 'scala' } apply plugin: 'java' @@ -44,7 +45,8 @@ apply plugin: 'ManifestClasspath' apply plugin: 'scalafmt' group = 'beam' -version = '1.0.beta' +version = '1.0.beta.1' +version = '0.9.13-beta-v6' description = """""" @@ -145,13 +147,20 @@ configurations.all { // we need this in order to get Elki library working fine. force 'net.jafama:jafama:2.3.2' // we need this in order to get Elki library working fine. - force 'it.unimi.dsi:fastutil:8.5.4' + force 'it.unimi.dsi:fastutil:8.5.12' force 'org.apache.logging.log4j:log4j-core:2.15.0' force 'org.apache.logging.log4j:log4j-api:2.15.0' + force 'org.apache.parquet:parquet-avro:1.12.3' + force 'org.apache.parquet:parquet-hadoop:1.12.3' + force 'org.apache.parquet:parquet-common:1.12.3' + force 'org.apache.parquet:parquet-column:1.12.3' + force 'org.apache.parquet:parquet-encoding:1.12.3' } exclude group: "log4j", module: "log4j" exclude group: "org.matsim", module: "matsim" + exclude group: 'org.slf4j', module: 'slf4j-log4j12' + exclude group: 'org.slf4j', module: 'slf4j-reload4j' } dependencies { @@ -167,6 +176,13 @@ dependencies { implementation group: 'com.google.inject.extensions', name: 'guice-multibindings', version: '4.1.0' implementation group: 'org.apache.commons', name: 'commons-collections4', version: '4.4' implementation group: 'org.apache.commons', name: 'commons-math3', version: '3.6.1' + implementation 'org.apache.commons:commons-lang3:3.12.0' + implementation 'commons-io:commons-io:2.11.0' + implementation 'org.apache.commons:commons-csv:1.8' + implementation 'org.apache.commons:commons-text:1.10.0' + implementation 'commons-lang:commons-lang:2.6' + implementation 'org.glassfish:javax.el:3.0.0' + implementation 'javax.el:javax.el-api:3.0.0' implementation group: 'org.apache.httpcomponents', name: 'fluent-hc', version: '4.5.13' // Apache 2.0 @@ -208,7 +224,7 @@ dependencies { implementation(group: 'org.matsim.contrib', name: 'decongestion', version: '12.0') - implementation(group: 'com.github.LBNL-UCB-STI.matsim', name: 'matsim', version: '12.0-beam-8') { + implementation(group: 'com.github.LBNL-UCB-STI.matsim', name: 'matsim', version: '12.0-beam-9') { exclude group: 'log4j', module: 'log4j' } @@ -229,6 +245,8 @@ dependencies { implementation("com.github.LBNL-UCB-STI:jsprit-wrapper:v0.5.1") implementation("com.github.LBNL-UCB-STI:omx-java:v2.0.2") + implementation group: 'dev.zarr', name: 'jzarr', version: '0.4.2' + testImplementation group: 'junit', name: 'junit', version: '4.8' testImplementation group: 'org.mockito', name: 'mockito-inline', version: '2.27.0' testImplementation group: "org.mockito", name: "mockito-core", version: "2.28.2" @@ -281,12 +299,12 @@ dependencies { // https://mvnrepository.com/artifact/io.circe/circe-parser_2.12 implementation group: 'io.circe', name: "circe-parser_${scalaBinaryVersion}", version: circeBinaryVersion - implementation group: 'com.typesafe.play', name: "play-json_${scalaBinaryVersion}", version: '2.6.3' + implementation group: 'com.typesafe.play', name: "play-json_${scalaBinaryVersion}", version: '2.8.1' implementation(group: 'com.github.romix.akka', name: "akka-kryo-serialization_${scalaBinaryVersion}", version: '0.5.2') { exclude group: 'com.esotericsoftware', module: 'kryo' } - implementation group: 'com.esotericsoftware', name: 'kryo', version: '4.0.2' + implementation group: 'com.esotericsoftware', name: 'kryo', version: '4.0.3' implementation "com.github.vagmcs:optimus_${scalaBinaryVersion}:3.1.0" implementation "com.github.vagmcs:optimus-solver-oj_${scalaBinaryVersion}:3.1.0" @@ -328,16 +346,19 @@ dependencies { implementation group: 'com.zaxxer', name: 'nuprocess', version: '1.2.4' def parquet = "1.12.3" - implementation group: 'org.apache.parquet', name: 'parquet-hadoop', version: parquet - implementation group: 'org.apache.parquet', name: 'parquet-avro', version: parquet - implementation(group: 'org.apache.hadoop', name: 'hadoop-client', version: '2.7.3') { - exclude group: 'org.slf4j', module: 'slf4j-log4j12' + // Parquet dependencies with shading + implementation 'org.apache.parquet:parquet-avro:1.12.3' + implementation 'org.apache.parquet:parquet-hadoop:1.12.3' + implementation 'org.apache.hadoop:hadoop-common:3.3.4' + implementation 'org.apache.hadoop:hadoop-mapreduce-client-core:3.3.4' + implementation('org.apache.hadoop:hadoop-client:3.3.6') { // Exclude `ASM` because it is binary incompatible with the one which is gotten from `com.conveyal:kryo-tools`: `org.ow2.asm:asm:5.0.4` exclude group: 'asm', module: 'asm' // Exclude jsp-api because it contains an older version of javax.el (Expression Language) which is incompatible // with one that Hibernate-validator uses exclude group: 'javax.servlet.jsp', module: 'jsp-api' } + implementation 'it.unimi.dsi:fastutil:8.5.12' implementation(group: 'com.lihaoyi', name: "sourcecode_${scalaBinaryVersion}", version: '0.1.9') @@ -792,6 +813,9 @@ tasks.register('createDockerfile', Dockerfile) { addFile 'entrypoint.sh', 'entrypoint.sh' runCommand('chmod +x /app/entrypoint.sh') entryPoint('/app/entrypoint.sh') + + mainClassName = 'beam.sim.RunBeam' // Replace with the desired main class + } ext.getDockerTag = { -> @@ -816,17 +840,30 @@ ext.getDockerRepository = { -> } } -tasks.register('buildImageWithoutTags', DockerBuildImage) { dependsOn createDockerfile } +tasks.register('buildImageWithoutTags', DockerBuildImage) { + dependsOn createDockerfile + platform = 'linux/amd64' +} // one can build a docker image with command ./gradlew -Ptag=beammodel/beam:0.9.12 buildImage tasks.register('buildImage', DockerTagImage) { description 'Builds the Docker BEAM image, all code and test data are included into the image.' - group 'Docker' + group 'Docker ' dependsOn buildImageWithoutTags + // Ensure platform compatibility + inputs.property("platform", "linux/amd64") + tag = getDockerTag() repository = getDockerRepository() println("The new image will be tagged '$getDockerRepository:$getDockerTag'. To change use 'tag' project parameter, i.e. '-Ptag='") targetImageId buildImageWithoutTags.getImageId() -} + + // Force OCI format compatibility + doFirst { + if (!project.hasProperty('tag')) { + throw new GradleException("Please specify a tag using -Ptag=repository:version") + } + } +} \ No newline at end of file diff --git a/gcp/src/main/python/createImage/requirements.txt b/gcp/src/main/python/createImage/requirements.txt index d491d51f59c..65aaf1a19ea 100644 --- a/gcp/src/main/python/createImage/requirements.txt +++ b/gcp/src/main/python/createImage/requirements.txt @@ -1,3 +1 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1c868ce84345515e4900fe7e800b6c1e2e5560da5101641c9f1afcd2f81a092c -size 32 +google-api-python-client==2.47.0 \ No newline at end of file diff --git a/gcp/src/main/python/createSnapshot/requirements.txt b/gcp/src/main/python/createSnapshot/requirements.txt index d491d51f59c..65aaf1a19ea 100644 --- a/gcp/src/main/python/createSnapshot/requirements.txt +++ b/gcp/src/main/python/createSnapshot/requirements.txt @@ -1,3 +1 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1c868ce84345515e4900fe7e800b6c1e2e5560da5101641c9f1afcd2f81a092c -size 32 +google-api-python-client==2.47.0 \ No newline at end of file diff --git a/gcp/src/main/python/delete-snapshot/requirements.txt b/gcp/src/main/python/delete-snapshot/requirements.txt index d491d51f59c..65aaf1a19ea 100644 --- a/gcp/src/main/python/delete-snapshot/requirements.txt +++ b/gcp/src/main/python/delete-snapshot/requirements.txt @@ -1,3 +1 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1c868ce84345515e4900fe7e800b6c1e2e5560da5101641c9f1afcd2f81a092c -size 32 +google-api-python-client==2.47.0 \ No newline at end of file diff --git a/gcp/src/main/python/deploy_beam/requirements.txt b/gcp/src/main/python/deploy_beam/requirements.txt index d491d51f59c..65aaf1a19ea 100644 --- a/gcp/src/main/python/deploy_beam/requirements.txt +++ b/gcp/src/main/python/deploy_beam/requirements.txt @@ -1,3 +1 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1c868ce84345515e4900fe7e800b6c1e2e5560da5101641c9f1afcd2f81a092c -size 32 +google-api-python-client==2.47.0 \ No newline at end of file diff --git a/gcp/src/main/python/notify_idle/requirements.txt b/gcp/src/main/python/notify_idle/requirements.txt index eae558c6268..1c152028ad8 100644 --- a/gcp/src/main/python/notify_idle/requirements.txt +++ b/gcp/src/main/python/notify_idle/requirements.txt @@ -1,3 +1 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:83ebe9988d6a14378d99baa36d3e5d8dff875e4b543dd4227bd83f426a6631c7 -size 33 +google-api-python-client==2.47.0 diff --git a/gcp/src/main/python/update-base-image/requirements.txt b/gcp/src/main/python/update-base-image/requirements.txt index 1eab71a063e..cb6b517d4a2 100644 --- a/gcp/src/main/python/update-base-image/requirements.txt +++ b/gcp/src/main/python/update-base-image/requirements.txt @@ -1,3 +1,2 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:0362ceda56a09f8fe3c951e26ba0df00be99de622721a15b8b23c98c61073658 -size 57 +functions-framework==3.* +google-api-python-client==2.47.0 \ No newline at end of file diff --git a/gcp/src/main/python/updateEnvVarsForProvidedFunctionNames/requirements.txt b/gcp/src/main/python/updateEnvVarsForProvidedFunctionNames/requirements.txt index d491d51f59c..65aaf1a19ea 100644 --- a/gcp/src/main/python/updateEnvVarsForProvidedFunctionNames/requirements.txt +++ b/gcp/src/main/python/updateEnvVarsForProvidedFunctionNames/requirements.txt @@ -1,3 +1 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1c868ce84345515e4900fe7e800b6c1e2e5560da5101641c9f1afcd2f81a092c -size 32 +google-api-python-client==2.47.0 \ No newline at end of file diff --git a/production/seattle b/production/seattle index e00e15fe5d9..0e24a673b93 160000 --- a/production/seattle +++ b/production/seattle @@ -1 +1 @@ -Subproject commit e00e15fe5d9cb9f9b57e695201abb0fe334b50e0 +Subproject commit 0e24a673b93b5998d06735fde2edabf07bea3693 diff --git a/production/sfbay b/production/sfbay index e8f7b0da386..6825637d1c8 160000 --- a/production/sfbay +++ b/production/sfbay @@ -1 +1 @@ -Subproject commit e8f7b0da3868f6fab98fb9a6a3775c15501b04af +Subproject commit 6825637d1c8cc2907bda10364746841b306942eb diff --git a/src/main/R/freight/freight-processing.R b/src/main/R/freight/freight-processing.R index 761d19b1869..5f69d092312 100644 --- a/src/main/R/freight/freight-processing.R +++ b/src/main/R/freight/freight-processing.R @@ -30,40 +30,46 @@ isCav <- function(x) { return(x >= 4) } +### Test +# work_folder <- normalizePath("~/Workspace/Data/Scenarios/sfbay/validation_data/BEAM") +# speed <- readCsv(pp(work_folder, "/sfbay_residential_simpl_network.csv.gz")) +# ggplot(speed, aes(x=speed_beam-speed_npmrds)) + geom_histogram() + xlim(0, 100) + + # emission -emfac_sf_file <- normalizePath('~/Workspace/Models/emfac/2018/SF_2018_Annual_fleet_data_population_20240311153419.csv') -emfac_sf <- readCsv(emfac_sf_file) -emfac_sf_normalized <- emfac_sf[,.(sum_population=(sum(population))),by=.(vehicle_class, fuel)] -emfac_sf_normalized$share_population <- emfac_sf_normalized$sum_population/sum(emfac_sf_normalized$sum_population) +# emfac_sf_file <- normalizePath('~/Workspace/Models/emfac/2018/SF_2018_Annual_fleet_data_population_20240311153419.csv') +# emfac_sf <- readCsv(emfac_sf_file) +# emfac_sf_normalized <- emfac_sf[,.(sum_population=(sum(population))),by=.(vehicle_class, fuel)] +# emfac_sf_normalized$share_population <- emfac_sf_normalized$sum_population/sum(emfac_sf_normalized$sum_population) ### # Create a sample data frame -data <- data.frame( - Name = c("John", "Jane", "Bob", "Alice", "John", "Jane", "Bob", "Alice"), - Age = c(25, 30, 35, 40, 27, 32, 38, 42), - City = c("New York", "London", "Paris", "Tokyo", "New York", "London", "Paris", "Tokyo"), - Gender = c("M", "F", "M", "F", "M", "F", "M", "F") -) +# data <- data.frame( +# Name = c("John", "Jane", "Bob", "Alice", "John", "Jane", "Bob", "Alice"), +# Age = c(25, 30, 35, 40, 27, 32, 38, 42), +# City = c("New York", "London", "Paris", "Tokyo", "New York", "London", "Paris", "Tokyo"), +# Gender = c("M", "F", "M", "F", "M", "F", "M", "F") +# ) # Load the required packages -library(dplyr) -library(stringr) +# library(dplyr) +# library(stringr) # Group the data frame by 'City' and 'Gender', and concatenate 'Name' into a new column -grouped <- data %>% - group_by(City, Gender) %>% - summarise(Names = str_c(Name, collapse = ", ")) - -print(grouped) +# grouped <- data %>% +# group_by(City, Gender) %>% +# summarise(Names = str_c(Name, collapse = ", ")) +# +# print(grouped) ### RouteE - -work_folder <- normalizePath("~/Workspace/Data/FREIGHT/seattle") -household <- readCsv(pp(work_folder, "/households.csv.gz")) -ggplot(household, aes(x=income/1000)) + geom_histogram() + xlim(0, 100) +# work_folder <- normalizePath("~/Workspace/Data/FREIGHT/seattle") +# household <- readCsv(pp(work_folder, "/households.csv.gz")) +# ggplot(household, aes(x=income/1000)) + geom_histogram() + xlim(0, 100) +## work_folder <- normalizePath("~/Workspace/Data/FREIGHT/seattle") geo <- geojson_sf(pp(work_folder, "/validation/npmrds/Seattle_counties.geojson")) diff --git a/src/main/R/freight/freight-smart2-plotting.R b/src/main/R/freight/freight-smart2-plotting.R index 4fe6eed3867..6a89929d8dc 100644 --- a/src/main/R/freight/freight-smart2-plotting.R +++ b/src/main/R/freight/freight-smart2-plotting.R @@ -356,6 +356,7 @@ dgb2b_runs <- demand_growth_runs_dir, "all_b2b_growth" ) +dgb2b_runs_2018 <- readCsv(pp(demand_growth_runs_dir,"2018_base/0.events.csv.gz")) dgb2b_runs <- format_path_traversals(dgb2b_runs) dgb2b_summary <- dgb2b_runs[, diff --git a/src/main/java/beam/matsim/CustomPlansDumpingImpl.java b/src/main/java/beam/matsim/CustomPlansDumpingImpl.java index 0df9233fed6..63c6688696a 100644 --- a/src/main/java/beam/matsim/CustomPlansDumpingImpl.java +++ b/src/main/java/beam/matsim/CustomPlansDumpingImpl.java @@ -8,6 +8,7 @@ import org.matsim.api.core.v01.population.PopulationWriter; import org.matsim.core.config.Config; import org.matsim.core.config.groups.ControlerConfigGroup; +import org.matsim.core.controler.Controler; import org.matsim.core.controler.OutputDirectoryHierarchy; import org.matsim.core.controler.corelisteners.PlansDumping; import org.matsim.core.controler.events.BeforeMobsimEvent; @@ -17,6 +18,14 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; + +import java.io.UncheckedIOException; +import java.nio.file.StandardCopyOption; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; + @Singleton public class CustomPlansDumpingImpl implements PlansDumping, BeforeMobsimListener { static final private Logger log = LoggerFactory.getLogger(CustomPlansDumpingImpl.class); @@ -51,27 +60,92 @@ public void notifyBeforeMobsim(final BeforeMobsimEvent event) { final boolean writingPlansAtAll = writePlansInterval() > 0; final boolean regularWritePlans = writePlansInterval() > 0 && (event.getIteration() > 0 && event.getIteration() % writePlansInterval() == 0); final boolean earlyIteration = event.getIteration() <= writeMoreUntilIteration(); + if (writingPlansAtAll && (regularWritePlans || earlyIteration)) { stopwatch.beginOperation("dump all plans"); log.info("dumping plans..."); - final String inputCRS = config.plans().getInputCRS(); - final String internalCRS = config.global().getCoordinateSystem(); - if (inputCRS == null) { - new PopulationWriter(population, network).write(controlerIO.getIterationFilename(event.getIteration(), "plans.xml.gz")); - } else { - log.info("re-projecting population from " + internalCRS + " back to " + inputCRS + " for export"); + String outputFilename = controlerIO.getIterationFilename(event.getIteration(), "plans.xml.gz"); + ensureDirectoryExists(outputFilename); + + try { + writePlans(outputFilename); + log.info("finished plans dump successfully."); + } catch (Exception e) { + log.error("Failed to write plans to {}: {}", outputFilename, e.getMessage()); + throw new RuntimeException("Failed to write plans file", e); + } finally { + stopwatch.endOperation("dump all plans"); + } + } + } + + private void dumpExperiencedPlans() { + if (!config.planCalcScore().isWriteExperiencedPlans()) { + log.debug("Skipping experienced plans dump - disabled in config"); + return; + } + + stopwatch.beginOperation("dump experienced plans"); + log.info("Dumping experienced plans using our BEAM implementation..."); + + try { + String outputFilename = controlerIO.getOutputFilename(Controler.DefaultFiles.experiencedPlans); + String iterationFilename = controlerIO.getIterationFilename( + controlerConfigGroup.getLastIteration(), + Controler.DefaultFiles.experiencedPlans + ); - final CoordinateTransformation transformation = - TransformationFactory.getCoordinateTransformation( - internalCRS, - inputCRS); + ensureDirectoryExists(outputFilename); + Path fromPath = Paths.get(iterationFilename); + Path toPath = Paths.get(outputFilename); - new PopulationWriter(transformation, population, network).write(controlerIO.getIterationFilename(event.getIteration(), "plans.xml.gz")); + if (!Files.exists(fromPath)) { + // Instead of throwing an error, write current plans as experienced plans + log.warn("Experienced plans file not found at {}. Writing current plans instead.", iterationFilename); + writePlans(outputFilename); + return; } - log.info("finished plans dump."); - stopwatch.endOperation("dump all plans"); + + Files.copy(fromPath, toPath, StandardCopyOption.REPLACE_EXISTING); + log.info("Successfully copied experienced plans from {} to {}", iterationFilename, outputFilename); + + } catch (IOException e) { + log.error("Failed to copy/write experienced plans file: {}", e.getMessage()); + throw new UncheckedIOException("Failed to handle experienced plans file", e); + } finally { + stopwatch.endOperation("dump experienced plans"); } } -} + private void writePlans(String outputFilename) { + final String inputCRS = config.plans().getInputCRS(); + final String internalCRS = config.global().getCoordinateSystem(); + + if (inputCRS == null) { + new PopulationWriter(population, network).write(outputFilename); + } else { + log.info("re-projecting population from {} back to {} for export", internalCRS, inputCRS); + + final CoordinateTransformation transformation = + TransformationFactory.getCoordinateTransformation( + internalCRS, + inputCRS); + + new PopulationWriter(transformation, population, network).write(outputFilename); + } + } + + private void ensureDirectoryExists(String filename) { + try { + Path directory = Paths.get(filename).getParent(); + if (directory != null && !Files.exists(directory)) { + Files.createDirectories(directory); + log.info("Created directory: {}", directory); + } + } catch (IOException e) { + log.error("Failed to create directory for {}: {}", filename, e.getMessage()); + throw new RuntimeException("Failed to create output directory", e); + } + } +} \ No newline at end of file diff --git a/src/main/java/beam/physsim/jdeqsim/AgentSimToPhysSimPlanConverter.java b/src/main/java/beam/physsim/jdeqsim/AgentSimToPhysSimPlanConverter.java index f064f7aa95d..7eca4834ac3 100755 --- a/src/main/java/beam/physsim/jdeqsim/AgentSimToPhysSimPlanConverter.java +++ b/src/main/java/beam/physsim/jdeqsim/AgentSimToPhysSimPlanConverter.java @@ -220,7 +220,7 @@ private void setupActorsAndRunPhysSim(IterationEndsEvent iterationEndsEvent) { try { String outPath = controlerIO - .getIterationFilename(iterationNumber, "countscompare.txt"); + .getIterationFilename(iterationNumber, "countsCompare.txt"); double countsError = CountsObjectiveFunction.evaluateFromRun(outPath); log.info("counts Error: " + countsError); } catch (Exception e) { @@ -533,9 +533,10 @@ private Leg createLeg(PathTraversalEvent pte, Leg connectedLeg, Integer departur List objects = pte.linkIdsJava(); // most of the time the last link of previous leg is the first link of current leg - we are avoiding this boolean sameLinkAtTheEnd; + try { sameLinkAtTheEnd = !linkIds.isEmpty() - && pte.linkIds().head().toString().equals(Iterables.getLast(linkIds).toString()); + && String.valueOf(pte.linkIds()[0]).equals(Iterables.getLast(linkIds).toString()); } catch (java.util.NoSuchElementException e) { log.error("Mismatched path traversal in physsim plans: {}, matched leg: {}", pte, connectedLeg); return null; diff --git a/src/main/java/beam/utils/TravelTimeCalculatorHelper.java b/src/main/java/beam/utils/TravelTimeCalculatorHelper.java index 4a7c96d559e..cd682a22818 100644 --- a/src/main/java/beam/utils/TravelTimeCalculatorHelper.java +++ b/src/main/java/beam/utils/TravelTimeCalculatorHelper.java @@ -1,5 +1,6 @@ package beam.utils; +import beam.router.BeamTravelTime; import beam.utils.logging.ExponentialLoggerWrapperImpl; import org.matsim.api.core.v01.Id; import org.matsim.api.core.v01.network.Link; @@ -12,7 +13,7 @@ import java.util.*; public class TravelTimeCalculatorHelper { - public static class TravelTimePerHour implements TravelTime { + public static class TravelTimePerHour implements BeamTravelTime { private final Logger log = LoggerFactory.getLogger(TravelTimePerHour.class); private final double[][] _linkIdToTravelTimeArray; @@ -23,35 +24,35 @@ public TravelTimePerHour(int timeBinSizeInSeconds, final Map l _timeBinSizeInSeconds = timeBinSizeInSeconds; _linkIdToTravelTimeArray = initTravelTime(linkIdToTravelTimeData); } + @Override - public double getLinkTravelTime(Link link, double time, Person person, Vehicle vehicle) { - final int linkId = Integer.parseInt(link.getId().toString()); - if (linkId >= _linkIdToTravelTimeArray.length) { - if(ExponentialLoggerWrapperImpl.isNumberPowerOfTwo(++numWarnings)){ - log.warn("Got linkId {} which is out of `_linkIdToTravelTimeArray` array with length {}", linkId, _linkIdToTravelTimeArray.length); + public double getLinkTravelTime(int linkId, double time) { + if (linkId < 0 || linkId >= _linkIdToTravelTimeArray.length || _linkIdToTravelTimeArray[linkId] == null) { + if (ExponentialLoggerWrapperImpl.isNumberPowerOfTwo(++numWarnings)) { + log.warn("Invalid linkId {} or missing travel time data", linkId); } - return link.getFreespeed(); + return 0d; // Calculate travel time directly } - double[] timePerHour = _linkIdToTravelTimeArray[linkId]; - if (null == timePerHour){ - if(ExponentialLoggerWrapperImpl.isNumberPowerOfTwo(++numWarnings)){ - log.warn("Can't find travel times for link '{}'", linkId); - } - return link.getFreespeed(); - } int idx = getOffset(time); if (idx >= timePerHour.length) { - if(ExponentialLoggerWrapperImpl.isNumberPowerOfTwo(++numWarnings)) { + if (ExponentialLoggerWrapperImpl.isNumberPowerOfTwo(++numWarnings)) { log.warn("Got offset which is out of array for the link {}. Something wrong. idx: {}, time: {}, _timeBinSizeInSeconds: '{}'", linkId, idx, time, _timeBinSizeInSeconds); } - return link.getFreespeed(); + return 0d; } return timePerHour[idx]; } - private int getOffset(double time){ - return (int)Math.round(Math.floor(time / _timeBinSizeInSeconds)); + + @Override + public double getLinkTravelTime(Link link, double time, Person person, Vehicle vehicle) { + final int linkId = Integer.parseInt(link.getId().toString()); + return getLinkTravelTime(linkId, time); + } + + private int getOffset(double time) { + return (int) (time / _timeBinSizeInSeconds); } public static double[][] initTravelTime(final Map linkIdToTravelTimeData) { @@ -70,7 +71,13 @@ public static double[][] initTravelTime(final Map linkIdToTrav }); return linkIdToTravelTimeArray; } + + @Override + public double getLinkTravelTime(int linkId, double time, double linkLengthMeters) { + return getLinkTravelTime(linkId, time); + } } + private static final Logger log = LoggerFactory.getLogger(TravelTimeCalculatorHelper.class); public static Map GetLinkIdToTravelTimeArray(Collection links, TravelTime travelTime, int maxHour) { @@ -121,7 +128,7 @@ public static Map AverageTravelTimesMap(Map return result; } - public static TravelTime CreateTravelTimeCalculator(int timeBinSizeInSeconds, Map linkIdToTravelTimeData) { + public static BeamTravelTime CreateTravelTimeCalculator(int timeBinSizeInSeconds, Map linkIdToTravelTimeData) { return new TravelTimePerHour(timeBinSizeInSeconds, linkIdToTravelTimeData); } } \ No newline at end of file diff --git a/src/main/python/__init__.py b/src/main/python/__init__.py new file mode 100644 index 00000000000..bbb3e1fe3e4 --- /dev/null +++ b/src/main/python/__init__.py @@ -0,0 +1,6 @@ +# python/__init__.py +# exposed key functionality: +from .utils import compare_config_files +from .utils import log_filter_script +from .utils import study_area_config +from .utils import files_utils \ No newline at end of file diff --git a/src/main/python/atlas/process_vehicle_types.py b/src/main/python/atlas/process_vehicle_types.py new file mode 100644 index 00000000000..4f6bd413445 --- /dev/null +++ b/src/main/python/atlas/process_vehicle_types.py @@ -0,0 +1,54 @@ +import os +import re +import pandas as pd + + +def filter_vehicles_by_year(file_path, max_year=2018): + """ + Reads a vehicle types CSV file using pandas and filters out vehicles with IDs + where the year is greater than max_year. + + Args: + file_path (str): Path to the CSV file + max_year (int): Maximum year to include (default: 2018) + + Returns: + pandas.DataFrame: DataFrame containing filtered vehicle data + """ + # Read the CSV file + df = pd.read_csv(file_path) + + # Extract year from vehicleTypeId and create a filter + def extract_year(vehicle_id): + match = re.match(r'^(\d{4})_', str(vehicle_id)) + if match: + return int(match.group(1)) + return None + + # Apply the year extraction to create a new column + df['year'] = df['vehicleTypeId'].apply(extract_year) + + # Filter out vehicles with year > max_year + filtered_df = df[df['year'].isna() | (df['year'] <= max_year)] + + # Drop the temporary year column + filtered_df = filtered_df.drop(columns=['year']) + + return filtered_df + + +if __name__ == "__main__": + file_path = os.path.expanduser( + "~/Workspace/Simulation/sfbay/vehicle-tech/vehicleTypes--atlas--baseline-projection.csv") + filtered_df = filter_vehicles_by_year(file_path, 2023) + print(f"Found {len(filtered_df)} vehicles after filtering") + + # Print some examples of what was kept + for i, (index, row) in enumerate(filtered_df.head().iterrows()): + print(f"{i + 1}. Vehicle ID: {row.get('vehicleTypeId')}") + + # Save the filtered data to a new CSV file + dir_path = os.path.dirname(file_path) + output_path = f"{dir_path}/vehicleTypes--atlas--2023-Baseline.csv" + filtered_df.to_csv(output_path, index=False) + print(f"Filtered data saved to: {output_path}") \ No newline at end of file diff --git a/src/main/python/emissions/_beam_emissions_plotting.py b/src/main/python/emissions/_beam_emissions_plotting.py new file mode 100644 index 00000000000..90e2e3298ed --- /dev/null +++ b/src/main/python/emissions/_beam_emissions_plotting.py @@ -0,0 +1,672 @@ +import gzip +import io +import os +import warnings + +import contextily as cx +import geopandas as gpd +import h3 +import matplotlib.colors as mcolors +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from matplotlib.colors import LogNorm +from shapely.geometry import Polygon +from tqdm import tqdm +from tqdm.auto import tqdm + +# Fuel Color Map +fuel_color_map = { + 'Elec': '#4169E1', # Royal Blue + 'H2fc': '#6495ED', # Cornflower Blue + 'Phe': '#87CEEB', # Sky Blue + 'NG': '#B0E0E6', # Pale Blue + 'BioDsl': '#98FB98', # Pale Green + 'Dsl': '#FFD700', # Gold + 'Gas': '#708090' # Slate Gray +} + +process_color_map = { + 'IDLEX': '#fde725', # Light yellow + 'RUNEX': '#7ad151', # Light green + 'PMBW': '#22a884', # Teal + 'PMTW': '#2a788e', # Blue-green + 'STREX': '#8e0152', # Dark magenta + 'RUNLOSS': '#4b0082', # Indigo + 'HOTSOAK': '#414487', # Purple-blue + 'DIURN': '#440154', # Dark purple +} + + +def remove_outliers_zscore(df, column, threshold=3): + mean = df[column].mean() + std = df[column].std() + z_scores = np.abs((df[column] - mean) / std) + df_filtered = df[z_scores < threshold].copy() + removed_rows = df[~df.index.isin(df_filtered.index)] + summary_df = pd.DataFrame({ + 'column': [column], + 'mean': [mean], + 'std': [std], + 'num_outliers': [len(removed_rows)] + }) + print(summary_df) + print(removed_rows) + return df_filtered + +def darken_color(color, factor=0.8): + rgb = mcolors.to_rgb(color) + return tuple(max(0, c * factor) for c in rgb) + + +def plot_hourly_emissions_by_scenario_class_fuel(emissions_skims, pollutant, output_dir, plot_legend, height_size, font_size): + data = emissions_skims[emissions_skims['pollutant'] == pollutant].copy() + grouped_data = data.groupby(['scenario', 'hour', 'class', 'emfacFuel'])['rate'].sum().reset_index() + + plt.figure(figsize=(20, height_size)) + + grouped_data['fuel_class'] = grouped_data['emfacFuel'].astype(str) + ', ' + grouped_data['class'].astype(str) + scenarios = grouped_data['scenario'].unique() + fuel_classes = sorted(grouped_data['fuel_class'].unique()) + all_hours = sorted(grouped_data['hour'].unique()) + + + # Create color map for fuel_classes + fuel_class_colors = {} + for fc in fuel_classes: + fuel, vehicle_class = fc.split(',') + fuel = fuel.strip() + vehicle_class = vehicle_class.strip() + base_color = fuel_color_map[fuel] # Default to black if fuel not found + if any(c in vehicle_class for c in ['7', '8']): + fuel_class_colors[fc] = darken_color(base_color) + else: + fuel_class_colors[fc] = base_color + + x = np.arange(len(all_hours)) + width = 0.35 / len(scenarios) + + scenarios_labeling = [] + for i, scenario in enumerate(scenarios): + scenarios_labeling.append(scenario) + scenario_data = grouped_data[grouped_data['scenario'] == scenario] + bottom = np.zeros(len(all_hours)) + for fuel_class in fuel_classes: + fuel_class_data = scenario_data[scenario_data['fuel_class'] == fuel_class] + # Create an array of rates for all hours, filling with zeros where data is missing + rates = np.zeros(len(all_hours)) + for _, row in fuel_class_data.iterrows(): + hour_index = all_hours.index(row['hour']) + rates[hour_index] = row['rate'] + + # Add edgecolor and linewidth parameters to create a subtle border + plt.bar(x + i * width, rates, width, bottom=bottom, + label=f"{fuel_class}" if i == 0 else "", + color=fuel_class_colors[fuel_class], + edgecolor='black', # Add black edge color + linewidth=0.5) # Adjust linewidth as needed + bottom += rates + + plt.title( + f'{pollutant.replace("_", ".")} Emissions: {" vs. ".join(scenarios_labeling)}', + fontsize=font_size+4) + plt.xlabel('Hour', fontsize=font_size) + plt.ylabel('Emissions (Metric Tons)', fontsize=font_size) + plt.xticks(x + width * (len(scenarios) - 1) / 2, all_hours, fontsize=font_size) + plt.yticks(fontsize=24) + if plot_legend: + plt.legend(title='Fuel, Class', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=font_size+4, title_fontsize=font_size+4) + plt.grid(axis='y', linestyle='--', alpha=0.7) + + plt.tight_layout() + plt.savefig(f'{output_dir}/{pollutant.lower()}_emissions_by_scenario_hour_class_fuel.png', dpi=300, bbox_inches='tight') + + +def plot_hourly_activity(tours_types, fuel_beam2emfac_map, output_dir, height_size): + # Preprocess data + tours_types['class'] = tours_types['vehicleCategory'].str.replace('Vocational|Tractor', '', regex=True).str.strip() + tours_types['fuel'] = tours_types['primaryFuelType'].str.lower().map(fuel_beam2emfac_map) + tours_types['fuel'] = np.where((tours_types['fuel'] == "Elec") & tours_types['secondaryFuelType'].notna(), 'Phe', + tours_types['fuel']) + tours_types['fuel_class'] = tours_types['fuel'] + '-' + tours_types['class'] + tours_types['departure_hour'] = (tours_types['departureTimeInSec'] / 3600).astype(int) % 24 + # Group by scenario, hour, and fuel_class, count the number of tours + hourly_activity = tours_types.groupby(['scenario', 'departure_hour', 'fuel_class']).size().unstack( + level=[0, 2], fill_value=0 + ) + + scenarios = tours_types['scenario'].unique() + # If the DataFrame is empty, create a default one with all hours + if hourly_activity.empty: + fuel_classes = tours_types['fuel_class'].unique() + index = pd.Index(range(24), name='departure_hour') + columns = pd.MultiIndex.from_product([scenarios, fuel_classes], names=['scenario', 'fuel_class']) + hourly_activity = pd.DataFrame(0, index=index, columns=columns) + else: + # Ensure all hours are present + for hour in range(24): + if hour not in hourly_activity.index: + hourly_activity.loc[hour] = 0 + hourly_activity = hourly_activity.sort_index() + + # Create the plot + plt.figure(figsize=(20, height_size)) + x = np.arange(24) # 24 hours + width = 0.35 # width of the bars + scenarios = hourly_activity.columns.levels[0] + + # Get all unique fuel classes across all scenarios + all_fuel_classes = set() + for scenario in scenarios: + all_fuel_classes.update(hourly_activity[scenario].columns) + + fuel_order = list(fuel_color_map.keys()) + # Sort fuel classes based on the defined order + sorted_fuel_classes = sorted(all_fuel_classes, + key=lambda x: ( + fuel_order.index(x.split('-')[0]) if x.split('-')[0] in fuel_order else len( + fuel_order), x)) + + # Create a color map for all fuel types + #color_map = {fuel: fuel_color_map[fuel] for fuel in fuel_order} + color_map = {} + for fc in sorted_fuel_classes: + fuel, vehicle_class = fc.split('-') + base_color = fuel_color_map[fuel] # Default to black if fuel not found + if any(c in vehicle_class for c in ['7', '8']): + color_map[fc] = darken_color(base_color) + else: + color_map[fc] = base_color + + print("Sorted fuel classes:", sorted_fuel_classes) + print("Color map:", color_map) + + # Plot stacked bars for each scenario + legend_handles = [] + legend_labels = [] + for i, scenario in enumerate(scenarios): + bottom = np.zeros(24) + for fuel_class in sorted_fuel_classes: + color = color_map[fuel_class] + + if fuel_class in hourly_activity[scenario].columns: + values = hourly_activity[scenario][fuel_class] + else: + values = np.zeros(24) + + bar = plt.bar(x + i * width, values, width, bottom=bottom, color=color, edgecolor='black', linewidth=0.5) + bottom += values + + if fuel_class not in legend_labels: + legend_handles.append(bar) + legend_labels.append(fuel_class) + + # plt.title(f'Weekday Tour Activity by Fuel, Class and Scenario: {" vs ".join(scenarios).replace("_", " ")}', fontsize=24) + plt.xlabel('Hour', fontsize=24) + plt.ylabel('Number of Tours Departing', fontsize=24) + plt.xticks(x + width / 2, range(24), fontsize=24) + plt.yticks(fontsize=12) + + # Create legend with ordered fuel classes + plt.legend(legend_handles, legend_labels, fontsize=28, loc='upper left', bbox_to_anchor=(1, 1)) + + plt.grid(axis='y', linestyle='--', alpha=0.7) + + # Adjust layout and save + plt.tight_layout() + plt.savefig(f'{output_dir}/hourly_activity_by_scenario_fuel_class.png', dpi=300, bbox_inches='tight') + plt.close() + + print(f"Plot saved as {output_dir}/hourly_activity_by_scenario_fuel_class.png") + + +def plot_hourly_vmt(df, output_dir, height_size): + # Preprocess the data + df['fuel_class'] = df['beamFuel'].astype(str) + '-' + df['class'].astype(str) + df['hour'] = df['hour'].astype(int) % 24 + df['mvmt'] = df['vmt'] / 1e6 + + scenarios = df['scenario'].unique() + + hourly_vmt = df.groupby(['scenario', 'hour', 'fuel_class'])['mvmt'].sum().unstack( + level=[0, 2], fill_value=0 + ).copy().reset_index() + + # Ensure all hours are present + for hour in range(24): + if hour not in hourly_vmt.index: + hourly_vmt.loc[hour] = 0 + hourly_vmt = hourly_vmt.sort_index() + + # Create the plot + plt.figure(figsize=(20, height_size)) + x = np.arange(24) # 24 hours + width = 0.35 # width of the bars + + # Get all unique fuel classes across all scenarios + all_fuel_classes = set() + for scenario in scenarios: + all_fuel_classes.update(hourly_vmt[scenario].columns) + + fuel_order = list(fuel_color_map.keys()) + # Sort fuel classes based on the defined order + sorted_fuel_classes = sorted(all_fuel_classes, + key=lambda x: ( + fuel_order.index(x.split('-')[0]) if x.split('-')[0] in fuel_order else len( + fuel_order), x)) + + + # Create color map for fuel_classes + color_map = {} + for fc in sorted_fuel_classes: + fuel, vehicle_class = fc.split('-') + base_color = fuel_color_map[fuel] # Default to black if fuel not found + if any(c in vehicle_class for c in ['7', '8']): + color_map[fc] = darken_color(base_color) + else: + color_map[fc] = base_color + + # Plot stacked bars for each scenario + legend_handles = [] + legend_labels = [] + for i, scenario in enumerate(scenarios): + bottom = np.zeros(24) + for fuel_class in sorted_fuel_classes: + if fuel_class in hourly_vmt[scenario].columns: + values = hourly_vmt[scenario][fuel_class] + else: + values = np.zeros(24) + + bar = plt.bar(x + i * width, values, width, bottom=bottom, color=color_map[fuel_class], edgecolor='black', linewidth=0.5) + bottom += values + + if fuel_class not in legend_labels: + legend_handles.append(bar) + legend_labels.append(fuel_class) + + # plt.title(f'Weekday VMT by Fuel, Class and Scenario: {" vs ".join(scenarios).replace("_", " ")}', fontsize=20) + plt.xlabel('Hour', fontsize=24) + plt.ylabel('Million Vehicle Miles Traveled', fontsize=24) + plt.xticks(x + width / 2, range(24), fontsize=24) + plt.yticks(fontsize=24) + + # Create legend with ordered fuel classes + plt.legend(legend_handles, legend_labels, title='Fuel, Class', fontsize=28, loc='upper left', bbox_to_anchor=(1, 1)) + plt.grid(axis='y', linestyle='--', alpha=0.7) + + # Adjust layout and save + plt.tight_layout() + plt.savefig(f'{output_dir}/hourly_vmt_by_scenario_fuel_class.png', dpi=300, bbox_inches='tight') + plt.close() + + print(f"Hourly VMT plot saved as {output_dir}/hourly_vmt_by_scenario_fuel_class.png") + + +def plot_h3_heatmap(df, df_col, scenario, output_dir, is_delta, remove_outliers, in_log_scale): + """Create a heatmap using the H3 grid structure with linear or logarithmic color scale and a base map.""" + subset_df = df[df["scenario"] == scenario] + if remove_outliers: + subset_df = remove_outliers_zscore(subset_df, df_col) + + # Create polygons for all H3 cells in the result + polygons = [Polygon(h3.h3_to_geo_boundary(h3_cell, geo_json=True)) for h3_cell in subset_df['h3_cell']] + + # Create GeoDataFrame + gdf = gpd.GeoDataFrame({ + 'h3_cell': subset_df['h3_cell'], + 'h3_var': subset_df[df_col], + 'geometry': polygons + }) + gdf = gdf.set_crs("EPSG:4326") + + # Convert to Web Mercator projection for compatibility with contextily + gdf_mercator = gdf.to_crs(epsg=3857) + + # Create figure and axis + fig, ax = plt.subplots(figsize=(15, 10)) + + vmin, vmax = gdf_mercator['h3_var'].min(), gdf_mercator['h3_var'].max() + + if in_log_scale: + if is_delta: + norm = mcolors.SymLogNorm(linthresh=1e-5, vmin=vmin, vmax=vmax) + else: + gdf_mercator = gdf_mercator[gdf_mercator['h3_var'] > 0] + vmin, vmax = gdf_mercator['h3_var'].min(), gdf_mercator['h3_var'].max() + norm = LogNorm(vmin=vmin, vmax=vmax) + label_suffix = "in log scale" + file_suffix = "log" + else: + if is_delta: + norm = mcolors.TwoSlopeNorm(vmin=vmin, vcenter=0, vmax=vmax) + else: + norm = None + label_suffix = "" + file_suffix = "linear" + + # Choose colormap based on whether it's a delta calculation + if is_delta: + cmap = mcolors.LinearSegmentedColormap.from_list("", ["blue", "lightblue", "white", "pink", "red"]) + else: + cmap = plt.get_cmap('viridis') + + # Plot cells with data + gdf_mercator.plot(column='h3_var', ax=ax, legend=False, cmap=cmap, edgecolor='none', norm=norm, alpha=0.7) + + # Add base map + cx.add_basemap(ax, source=cx.providers.CartoDB.Positron) + + # Add colorbar + sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + sm.set_array([]) + if is_delta: + cbar = fig.colorbar(sm, ax=ax, extend='both') + else: + cbar = fig.colorbar(sm, ax=ax, extend='max') + + cbar.ax.tick_params(labelsize=14) + cbar.set_label(f'{df_col.replace("_", ".")} {label_suffix}', rotation=270, labelpad=15, fontsize=18) + + # Set title and adjust plot + # plt.title(f'Emissions Distribution of {df_col.replace("_", ".")}, {scenario} ', fontsize=16) + ax.set_axis_off() + plt.tight_layout() + + # Save figure + outlier_status = "no_outliers" if remove_outliers else "with_outliers" + file_name = f'{output_dir}/{df_col.replace(" ", "_").lower()}_{scenario.replace(" ", "_").lower()}_heatmap_{file_suffix}_{outlier_status}_with_basemap.png' + plt.savefig(file_name, dpi=300, bbox_inches='tight') + plt.close() + print(f"Heatmap with base map saved as {file_name}") + + +def create_h3_histogram(df, output_dir, pollutant, scenario, remove_outliers, in_log_scale): + subset_df = df[df["scenario"] == scenario] + if remove_outliers: + subset_df = remove_outliers_zscore(subset_df, pollutant) + # Extract pollutant values + pollutant_values = subset_df[pollutant].values + + # Create the histogram + plt.figure(figsize=(12, 6)) + + if in_log_scale: + # Use log-spaced bins, but with adjustments for potential zero values + bins = np.logspace(np.log10(pollutant_values.min() + 1e-10), + np.log10(pollutant_values.max()), + num=50) + x_label = f'{pollutant.replace("_", ".")} Emissions (log scale)' + title_label = f'Histogram of {pollutant.replace("_", ".")} Emissions by H3 Cell (Log Scale)' + file_name = f'{output_dir}/{pollutant}_{scenario.replace(" ","_").lower()}_emissions_histogram_log.png' + else: + # Use automatic binning based on Sturges' rule + bins = 'sturges' + x_label = f'{pollutant.replace("_", ".")} Emissions' + title_label = f'Histogram of {pollutant.replace("_", ".")} Emissions by H3 Cell' + file_name = f'{output_dir}/{pollutant}_{scenario.replace(" ","_").lower()}_emissions_histogram.png' + + plt.hist(pollutant_values, bins=bins, edgecolor='black') + + # Set x-axis to log scale if specified + if in_log_scale: + plt.xscale('log') + + # Set labels and title + plt.xlabel(x_label, fontsize=12) + plt.ylabel('Frequency', fontsize=12) + plt.title(title_label, fontsize=14) + + # Add grid for better readability + plt.grid(True, linestyle='--', alpha=0.7) + + # Adjust layout and save + plt.tight_layout() + plt.savefig(file_name, dpi=300, bbox_inches='tight') + plt.close() + print(f"Histogram saved as {file_name}/") + + +def fast_df_to_gzip(df, output_file, compression_level=5, chunksize=100000): + """ + Write a pandas DataFrame to a compressed CSV.gz file quickly with a progress bar. + + :param df: pandas DataFrame to write + :param output_file: path to the output .csv.gz file + :param compression_level: gzip compression level (1-9, 9 being highest) + :param chunksize: number of rows to write at a time + """ + total_rows = len(df) + + with gzip.open(output_file, 'wt', compresslevel=compression_level) as gz_file: + # Write header + gz_file.write(','.join(df.columns) + '\n') + + # Write data in chunks + with tqdm(total=total_rows, desc="Writing to gzip", unit="rows") as pbar: + for start in range(0, total_rows, chunksize): + end = min(start + chunksize, total_rows) + chunk = df.iloc[start:end] + + csv_buffer = io.StringIO() + chunk.to_csv(csv_buffer, index=False, header=False) + gz_file.write(csv_buffer.getvalue()) + + pbar.update(end - start) + + +def plot_multi_pie_emfac_famos_vmt(data, plot_dir): + def assign_color(fuel_class): + return fuel_color_map[fuel_class.split('-')[0]] + + models = data["model"].unique() + + emfac_data = data[data['model'] == 'emfac'].sort_values('mvmt', ascending=False) + famos_data = data[data['model'] == 'famos'].sort_values('mvmt', ascending=False) + + all_fuel_classes = set(emfac_data['fuel_class']) | set(famos_data['fuel_class']) + for fuel_class in all_fuel_classes: + if fuel_class not in emfac_data['fuel_class'].values: + emfac_data = pd.concat( + [emfac_data, pd.DataFrame({'fuel_class': [fuel_class], 'model': ['EMFAC'], 'mvmt': [0]})], + ignore_index=True) + if fuel_class not in famos_data['fuel_class'].values: + famos_data = pd.concat( + [famos_data, pd.DataFrame({'fuel_class': [fuel_class], 'model': ['FAMOS'], 'mvmt': [0]})], + ignore_index=True) + + emfac_data = emfac_data.sort_values('fuel_class') + famos_data = famos_data.sort_values('fuel_class') + + if emfac_data['mvmt'].sum() == 0 and famos_data['mvmt'].sum() == 0: + print("Error: All VMT values are zero. Cannot create pie chart.") + return + + fig, ax = plt.subplots(figsize=(14, 10)) + size = 0.3 + outer_radius = 1 + inner_radius = outer_radius - size + outer_colors = [assign_color(fuel_class) for fuel_class in famos_data['fuel_class']] + inner_colors = [assign_color(fuel_class) for fuel_class in emfac_data['fuel_class']] + + def make_autopct(values): + def my_autopct(pct): + return f'{pct:.1f}%' if pct >= 1 else '' + + return my_autopct + + def add_labels(wedges, fuel_classes, autopct, colors, radius, inner=False): + for wedge, fuel_class, color in zip(wedges, fuel_classes, colors): + ang = (wedge.theta2 + wedge.theta1) / 2 + pct = wedge.theta2 - wedge.theta1 + if pct * 100 / 360 >= 1: # Only show labels for slices >= 1% + label = autopct(pct * 100 / 360) + theta = np.deg2rad(ang) + + if inner: + start_point = ((inner_radius - size) * np.cos(theta), (inner_radius - size) * np.sin(theta)) + end_point = (0.4 * np.cos(theta), 0.4 * np.sin(theta)) + + bbox_props = dict(boxstyle="round,pad=0.3", fc=color, ec="k", lw=0.72, alpha=0.7) + arrowprops = dict(arrowstyle="-", connectionstyle=f"arc3,rad=0", color='k') + + ax.annotate(f'{fuel_class}\n{label}', xy=start_point, xytext=end_point, + horizontalalignment='center', + verticalalignment='center', + bbox=bbox_props, arrowprops=arrowprops, + fontsize=16) + else: + x = (radius + size / 2 + 0.05) * np.cos(theta) + y = (radius + size / 2 + 0.05) * np.sin(theta) + + bbox_props = dict(boxstyle="round,pad=0.3", fc=color, ec="k", lw=0.72, alpha=0.7) + ax.annotate(f'{fuel_class}\n{label}', xy=(x, y), xytext=(x, y), + horizontalalignment='center', + verticalalignment='center', + bbox=bbox_props, + fontsize=16) + + wedges_outer, texts_outer, autotexts_outer = ax.pie(famos_data['mvmt'], radius=outer_radius, colors=outer_colors, + labels=None, autopct='', pctdistance=0.85, + labeldistance=1.1, + wedgeprops=dict(width=size, edgecolor='white')) + + add_labels(wedges_outer, famos_data['fuel_class'], make_autopct(famos_data['mvmt']), outer_colors, outer_radius) + + wedges_inner, texts_inner, autotexts_inner = ax.pie(emfac_data['mvmt'], radius=inner_radius, colors=inner_colors, + labels=None, autopct='', pctdistance=0.75, + wedgeprops=dict(width=size, edgecolor='white')) + + add_labels(wedges_inner, emfac_data['fuel_class'], make_autopct(emfac_data['mvmt']), inner_colors, inner_radius, inner=True) + + # ax.set_title('VMT Share by Fuel-Class: FAMOS (outer) vs EMFAC (inner)', fontsize=16) + + # handles = [plt.Rectangle((0, 0), 1, 1, fc="w", ec="k", lw=2, alpha=0.5) for _ in range(2)] + # labels = ['FAMOS (Outer)', 'EMFAC (Inner)'] + # ax.legend(handles, labels, title="Models", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1)) + + plt.tight_layout() + output_file = os.path.join(plot_dir, f"{'_'.join(models)}_vmt_multi_level_pie_chart.png") + plt.savefig(output_file, bbox_inches='tight', dpi=300) + plt.close() + print(f"Chart has been saved as '{output_file}'") + + +def plot_pollution_variability_by_process_vehicle_types(skims, pollutant, scenario, output_dir, height_size, font_size): + warnings.filterwarnings("ignore", category=FutureWarning, module="seaborn") + # Filter data for specified scenario and pollutant + data = skims[(skims['scenario'] == scenario) & (skims['pollutant'] == pollutant)].copy() + processes = sorted(skims["process"].unique().tolist()) + + # Create fuel_class category + data['fuel_class'] = data['emfacFuel'].astype(str) + ', ' + data['class'].astype(str) + data['rate_micro_gram'] = data['rate'] * 1e12 + + # Sort fuel_class by median emission rate + fuel_class_order = data.groupby('fuel_class')['rate_micro_gram'].median().sort_values(ascending=False).index + + # Set up the plot + fig, ax = plt.subplots(figsize=(20, height_size)) + + # Create color map for fuel_classes + fuel_class_colors = {} + for fc in data['fuel_class'].unique(): + fuel, vehicle_class = fc.split(',') + fuel = fuel.strip() + vehicle_class = vehicle_class.strip() + base_color = fuel_color_map[fuel] # Default to black if fuel not found + if any(c in vehicle_class for c in ['7', '8']): + fuel_class_colors[fc] = darken_color(base_color) + else: + fuel_class_colors[fc] = base_color + + # Create the box plot with adjusted parameters + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=FutureWarning) + sns.boxplot(x='process', y='rate_micro_gram', hue='fuel_class', data=data, + order=processes, hue_order=fuel_class_order, + palette=fuel_class_colors, + ax=ax, whis=1.5, fliersize=2, showcaps=True, showfliers=True) + + # Add strip plot for additional data points + sns.stripplot(x='process', y='rate_micro_gram', hue='fuel_class', data=data, + order=processes, hue_order=fuel_class_order, + palette=fuel_class_colors, + ax=ax, size=1, jitter=True, dodge=True, alpha=0.3) + + # Customize the plot + ax.set_title(f'{pollutant.replace("_", ".")} Emissions Variability - {scenario}', fontsize=font_size+4) + ax.set_xlabel('Process', fontsize=font_size) + ax.set_ylabel('Microgram per road link', fontsize=font_size) + ax.tick_params(axis='both', which='major', labelsize=font_size) + + # Rotate x-axis labels if needed + plt.setp(ax.get_xticklabels(), rotation=0, ha='right') + + # Move the legend outside the plot + ax.legend(title='Fuel, Class', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=font_size) + + # Use log scale for y-axis if the range of values is large + min_rate = data['rate_micro_gram'].min() + max_rate = data['rate_micro_gram'].max() + + if min_rate <= 0: + print(f"Warning: Minimum rate is {min_rate}, which is zero or negative. Using log scale by default.") + ax.set_yscale('log') + # Set a small positive value for the bottom of the y-axis + ax.set_ylim(bottom=1e-10) # You might need to adjust this value + scale_label = "log" + elif max_rate / min_rate > 1000: + print(f"Using log scale. Max/min ratio: {max_rate/min_rate}") + ax.set_yscale('log') + scale_label = "log" + else: + print(f"Using linear scale. Max/min ratio: {max_rate/min_rate}") + scale_label = "linear" + + plt.tight_layout() + plt.savefig(f'{output_dir}/{pollutant.lower()}_variability_by_process_fuel_class_{scenario.replace(" ", "_").lower()}_{scale_label}_scale.png', dpi=300, bbox_inches='tight') + plt.close() + + +def plot_pollutants_by_process(skims, scenario, plot_dir, height_size, font_size): + # Define process order and color map based on toxicity + process_order = list(process_color_map.keys()) + # Group by pollutant and process, and sum the rates + grouped = skims[skims["scenario"] == scenario].groupby(['pollutant', 'process'])['rate'].sum().unstack() + + # Reorder columns based on process_order + grouped = grouped.reindex(columns=process_order) + + # Normalize the data + normalized = grouped.div(grouped.sum(axis=1), axis=0) + normalized = normalized * 100 + + # Create the stacked bar plot + fig, ax = plt.subplots(figsize=(20, height_size)) + normalized.plot(kind='bar', stacked=True, ax=ax, color=[process_color_map[col] for col in normalized.columns]) + + # Customize the plot + plt.title(f'Normalized Emissions by Process - {scenario}', fontsize=font_size+4) + plt.xlabel('Pollutant', fontsize=font_size) + plt.ylabel('Relative Emissions (%)', fontsize=font_size) + plt.xticks(rotation=0, ha='center', fontsize=font_size) + plt.yticks(fontsize=font_size) + + ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda y, _: '{:.0f}%'.format(y))) + ax.set_ylim(0, 100) + + legend = plt.legend(title='Process', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=font_size) + plt.setp(legend.get_title(), fontsize=font_size) + plt.tight_layout() + + # Save the plot + plt.savefig( + f'{plot_dir}/pollutant_by_process_{scenario.replace(" ", "_").lower()}.png', + dpi=300, + bbox_inches='tight' + ) + + # Show the plot + plt.show() + diff --git a/src/main/python/emissions/_emfac_and_emissions_rates_processing.py b/src/main/python/emissions/_emfac_and_emissions_rates_processing.py new file mode 100644 index 00000000000..5b48d487a5a --- /dev/null +++ b/src/main/python/emissions/_emfac_and_emissions_rates_processing.py @@ -0,0 +1,935 @@ +import os +import sys +from multiprocessing import Pool + +import numpy as np +import pandas as pd +import pyarrow as pa +import pyarrow.csv as csv +from tqdm import tqdm +from tqdm.auto import tqdm + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +# Now use absolute import +from python.utils.files_utils import check_files + +# Now use absolute import +emissions_processes = [ + "RUNEX", + "IDLEX", + "STREX", + "DIURN", + "HOTSOAK", + "RUNLOSS", + "PMTW", + "PMBW", + "PRDUST" +] + +pollutant_columns = { + 'CH4': 'rate_ch4_gram_float', + 'CO': 'rate_co_gram_float', + 'CO2': 'rate_co2_gram_float', + 'HC': 'rate_hc_gram_float', + 'NH3': 'rate_nh3_gram_float', + 'NOx': 'rate_nox_gram_float', + 'PM': 'rate_pm_gram_float', + 'PM10': 'rate_pm10_gram_float', + 'PM2_5': 'rate_pm2_5_gram_float', + 'ROG': 'rate_rog_gram_float', + 'SOx': 'rate_sox_gram_float', + 'TOG': 'rate_tog_gram_float', + 'BC_V1': 'rate_bc_gram_float', + 'BC_V2': 'rate_bcm_gram_float', + 'BC_V3': 'rate_bch_gram_float' +} + +def calculate_road_dust_emissions(silt_loading, rainy_days): + """ + Calculate road dust emissions based on EPA AP-42 methodology. + + Parameters: + silt_loading (float): Roadway-specific silt loading in grams/square meter + rainy_days (int): Number of wet days in the year + + Returns: + tuple: PM2.5, PM10, and total PM emission factors in grams/vehicle-mile + """ + # Constants + k = 0.0022 # particle size multiplier for PM10 in lb/VMT + W = 2.4 # average weight of vehicles in tons + N = 365 # number of days in annual averaging period + + # Fractions of pollutants among road dust + pm_25_frac = 0.0686 + pm_10_frac = 0.4572 + pm_frac = 0.5428 + + # Calculate PM10 emission factor in lb/VMT + E_10 = k * (silt_loading ** 0.91) * (W ** 1.02) * (1 - rainy_days / N / 4) + + # Calculate total PM emission factor + E_total = E_10 / pm_10_frac + + # Calculate PM2.5 emission factor + E_25 = E_total * pm_25_frac + + # Convert from lb/VMT to g/VMT (1 lb = 453.592 g) + E_25_g = E_25 * 453.592 + E_10_g = E_10 * 453.592 + E_total_g = E_total * 453.592 + + return E_25_g, E_10_g, E_total_g + + +def generate_road_dust_rates(rainy_days_file, silt_loading_file, air_basin_region): + """ + Process rainy days and silt loading data to create road dust emission rates. + + Parameters: + rainy_days_file (str): Path to the rainy days CSV file + silt_loading_file (str): Path to the silt loading CSV file + air_basin_region (list): List of air basins to filter by + + Returns: + pd.DataFrame: DataFrame with road dust emission rates + """ + # Map BEAM/OSM road types to CARB silt loading road categories + silt_beam2carb_map = { + 'motorway': 'Freeway', + 'motorway_link': 'Freeway', + 'trunk': 'Freeway', + 'trunk_link': 'Major', + 'primary': 'Major', + 'primary_link': 'Major', + 'secondary': 'Collector', + 'secondary_link': 'Collector', + 'tertiary': 'Collector', + 'tertiary_link': 'Collector', + 'unclassified': 'Collector', + 'residential': 'Local Urban' + } + + # Load silt loading data + silt_loading_df = pd.read_csv(silt_loading_file) + + # Ensure consistent county names across datasets + silt_loading_df['County'] = silt_loading_df['County'].str.strip().str.lower() + silt_loading_df['Air Basin'] = silt_loading_df['Air Basin'].str.strip() + silt_filtered_df = silt_loading_df[silt_loading_df['Air Basin'].isin(air_basin_region)] + if silt_filtered_df.empty: + raise ValueError(f"No data found in silt loading for the specified air basins: {air_basin_region}") + road_categories = ['Freeway', 'Major', 'Collector', 'Local Urban', 'Local Rural'] + county_averages = silt_filtered_df.groupby('County')[road_categories].mean().reset_index() + county_averages = county_averages.sort_values('County') + + # Load rainy days data + rainy_days_df = pd.read_csv(rainy_days_file) + rainy_days_df['County'] = rainy_days_df['County'].str.strip().str.lower() + rainy_days_df['Air Basin'] = rainy_days_df['Air Basin'].str.strip() + rainy_filtered_df = rainy_days_df[rainy_days_df['Air Basin'].isin(air_basin_region)] + if rainy_filtered_df.empty: + raise ValueError(f"No data found in rainy days for the specified air basins: {air_basin_region}") + rainfall_averages = rainy_filtered_df.groupby('County')['Annual Rainfall Days'].mean().reset_index() + rainfall_averages = rainfall_averages.sort_values('County') + + # Merge county silt loading with rainy days data + merged_data = pd.merge(county_averages, rainfall_averages, on='County', how='inner') + + # Initialize lists to store emissions data for all BEAM/OSM road types + all_rows = [] + + # Calculate road dust emissions for each county and road type + print("Calculating road dust emissions...") + total_iterations = len(merged_data) * len(silt_beam2carb_map) + with tqdm(total=total_iterations, desc="Processing counties and road types") as pbar: + for _, row in merged_data.iterrows(): + county = row['County'] + rainy_days = row['Annual Rainfall Days'] + + # Create a dictionary to map CARB road categories to their silt loading values for this county + carb_road_to_silt = {road_type: row[road_type] for road_type in road_categories} + + # Process each BEAM/OSM road type + for beam_road_type, carb_road_type in silt_beam2carb_map.items(): + silt_loading = carb_road_to_silt[carb_road_type] + + # Calculate emission factors + pm25, pm10, pm_total = calculate_road_dust_emissions(silt_loading, rainy_days) + + # Create a dictionary for this row + row_dict = { + 'county': county, + 'process': 'PRDUST', + 'rate_pm2_5_gram_float': pm25, + 'rate_pm10_gram_float': pm10, + 'rate_pm_gram_float': pm_total, + 'road_category': beam_road_type, + 'carb_road_category': carb_road_type, + 'silt_loading': silt_loading, + 'rainy_days': rainy_days + } + + all_rows.append(row_dict) + pbar.update(1) + + # Create emissions DataFrame + _emissions_df = pd.DataFrame(all_rows) + + # Reorder columns to match required format + column_order = [ + 'county', + 'road_category', + 'process', + 'rate_pm_gram_float', + 'rate_pm10_gram_float', + 'rate_pm2_5_gram_float' + ] + + return _emissions_df[column_order] + +def numerical_column_to_binned_and_pivot(df_raw, numerical_colname, binned_colname, edge_values): + pivot_df = pivot_rates_for_beam(df_raw).sort_values(by='speed_time', ascending=True) + df_raw_last_row = pivot_df.iloc[-1].copy() + df_raw_last_row['speed_time'] = edge_values[1] + pivot_df = pd.concat([pivot_df, pd.DataFrame([df_raw_last_row])], ignore_index=True) + col_sorted = sorted(pivot_df[numerical_colname].unique()) + col_bins = [edge_values[0]] + col_sorted + col_labels = [f"[{col_bins[i]}, {col_bins[i + 1]})" for i in range(len(col_bins) - 1)] + pivot_df[binned_colname] = pd.cut(pivot_df[numerical_colname], bins=col_bins, labels=col_labels, right=True) + return pivot_df + +def pivot_rates_for_beam(df_raw): + unique_speed_time = df_raw.speed_time.unique() + has_non_empty_speed_time = any(len(str(x)) > 0 for x in unique_speed_time) and not pd.isnull( + unique_speed_time).all() + index_ = ["emfacId", 'county', 'process'] + if has_non_empty_speed_time: + index_.append("speed_time") + pivot_df = df_raw.pivot_table(index=index_, columns='pollutant', values='emission_rate', aggfunc='first', + fill_value=0).reset_index() + pivot_df = pivot_df.rename(columns=pollutant_columns) + # Add missing columns with default values + for col in pollutant_columns.values(): + if col not in pivot_df.columns: + pivot_df[col] = 0.0 + pivot_df.insert(0, 'speed_mph_float_bins', "") + pivot_df.insert(1, 'time_minutes_float_bins', "") + return pivot_df + + +def process_rates_group(df, row): + mask = ((df["county"] == row["county"]) & (df["emfacId"] == row["emfacId"])) + df_subset = df[mask] + df_output_list = [] + + # Add progress bar for processing each emissions process + print(f"Processing emissions for county: {row['county']}, emfacId: {row['emfacId']}") + for process in tqdm(emissions_processes, desc="Processing emission processes"): + df_temp = df_subset[df_subset['process'] == process] + if not df_temp.empty: + if process in ['RUNEX', 'PMBW']: + df_temp = numerical_column_to_binned_and_pivot(df_temp, 'speed_time', 'speed_mph_float_bins', + [0.0, 200.0]) + elif process == 'STREX': + df_temp = numerical_column_to_binned_and_pivot(df_temp, 'speed_time', 'time_minutes_float_bins', + [0.0, 3600.0]) + else: + df_temp = pivot_rates_for_beam(df_temp) + df_output_list.append(df_temp) + + return pd.concat(df_output_list, ignore_index=True) if df_output_list else pd.DataFrame() + +# Define this function at module level (outside any other function) +def process_chunk(chunk_data): + chunk, emissions_df = chunk_data + results = [] + # Process each row in the chunk + for _, row in tqdm(chunk.iterrows(), total=len(chunk), + desc=f"Processing chunk with {len(chunk)} rows", + leave=False): + result = process_rates_group(emissions_df, row) + results.append(result) + + return pd.concat(results, ignore_index=True) if results else pd.DataFrame() + + +def process_emfac_rates( + emfac_rates_by_model_year_file, + format_func, + season_month, + calendar_year, + air_basin_area, + temperature, + relative_humidity, + include_nan=True): + """ + Process EMFAC emissions rates with improved air basin filtering. + + Args: + emfac_rates_by_model_year_file: Path to EMFAC rates input file + format_func: Function to format the data + season_month: Season or month to filter by + calendar_year: Calendar year to filter by + air_basin_area: Air basin area(s) to filter by (can be list or single string) + temperature: Temperature to filter by + relative_humidity: Relative humidity to filter by + include_nan: Whether to include NaN values in filtering + + Returns: + DataFrame with processed EMFAC rates + """ + # Process the emissions data + print(f"Reading CSV file: {emfac_rates_by_model_year_file}") + table = csv.read_csv(emfac_rates_by_model_year_file, read_options=pa.csv.ReadOptions(use_threads=True)) + df = table.to_pandas() + print(f"CSV file loaded. Shape: {df.shape}") + + # Apply filters based on config + print("Applying filters...") + if 'season_month' in df.columns: + print(f"Filtering by season_month: {season_month}") + df = df[(df['season_month'] == season_month) | (include_nan & df['season_month'].isna())] + print(f"After season_month filter. Shape: {df.shape}") + + if 'calendar_year' in df.columns: + print(f"Filtering by calendar_year: {calendar_year}") + df = df[(df['calendar_year'] == calendar_year) | (include_nan & df['calendar_year'].isna())] + print(f"After calendar_year filter. Shape: {df.shape}") + + # Improved air basin area filtering to handle partial matches + if 'sub_area' in df.columns: + print(f"Filtering by air_basin_area: {air_basin_area}") + # Create a filter condition for partial matches + sub_area_filter = include_nan & df['sub_area'].isna() + + for area in air_basin_area: + # Look for exact match or area in parentheses (e.g., "Santa Clara (SF)" for "SF") + sub_area_filter = sub_area_filter | df['sub_area'].str.contains(f'\\({area}\\)', regex=True) | ( + df['sub_area'] == area) + + # Apply the filter + df = df[sub_area_filter] + print(f"After sub_area filter. Shape: {df.shape}") + + if 'temperature' in df.columns: + print(f"Filtering by temperature: {temperature}") + df = df[(df['temperature'] == temperature) | (include_nan & df['temperature'].isna())] + print(f"After temperature filter. Shape: {df.shape}") + + if 'relative_humidity' in df.columns: + print(f"Filtering by relative_humidity: {relative_humidity}") + df = df[(df['relative_humidity'] == relative_humidity) | (include_nan & df['relative_humidity'].isna())] + print(f"After relative_humidity filter. Shape: {df.shape}") + + # Group by MY_group and calculate statistics + print("Filling missing values and formatting data...") + df = df.fillna('') + df = df.reset_index(drop=True) + + print("Formatting data with provided format function...") + df_formatted = format_func(df) + + print("Grouping and calculating mean emission rates...") + group_col = ['area', 'county', 'emfacId', 'model_year_group', 'vehicle_class', 'fuel', 'process', 'speed_time', 'pollutant'] + emissions_rates = df_formatted.groupby(group_col)['emission_rate'].mean().reset_index() + print("Getting unique county/emfacId combinations...") + df_unique = emissions_rates[["county", "emfacId"]].drop_duplicates().reset_index(drop=True) + print(f"Found {len(df_unique)} unique county/emfacId combinations") + + # Parallel processing + # Use fewer, larger chunks and match to number of CPU cores + num_cores = min(os.cpu_count() or 4, 8) # Cap at 8 to prevent excessive overhead + chunks = np.array_split(df_unique, num_cores) + print(f"Starting parallel processing with {num_cores} cores...") + + # Use parallel processing with fewer, larger chunks + with Pool(num_cores) as pool: + with tqdm(total=num_cores, desc="Processing chunks") as pbar: + def update_progress(*args): + pbar.update() + return args[0] + + # Use imap to process chunks sequentially with progress updates + df_output_list = [] + for result in pool.imap(process_chunk, [(chunk, emissions_rates) for chunk in chunks]): + df_output_list.append(result) + pbar.update(1) + + # Formatting for merge + print("Combining results and finalizing data...") + df_output = pd.concat(df_output_list, ignore_index=True).drop(["speed_time"], axis=1) + + # Filter out rows where all emission columns are zero + emission_columns = [col for col in df_output.columns if col.startswith('rate_') and col.endswith('_gram_float')] + + # Count rows before filtering + total_rows_before = len(df_output) + filtered_out = df_output[(df_output[emission_columns] == 0).all(axis=1)] + df_output = df_output[~(df_output[emission_columns] == 0).all(axis=1)] + # Count rows after filtering + total_rows_after = len(df_output) + + print(f"Filtered out {total_rows_before - total_rows_after} rows where all emission columns are zero") + print(f"Final dataset has {total_rows_after} rows") + + # Reorder columns to ensure 'county' is at the front + columns = df_output.columns.tolist() + columns = ['county'] + [col for col in columns if col != 'county'] + emfac_rates = df_output[columns] + + return emfac_rates + +def process_emfac_emissions(study_area, scenario_name, work_dir, config, format_func): + # Get file paths + emfac_config = config["rates"]["emfac"] + filters_config = config["rates"]["filters"] + emfac_rates_by_model_year_file = os.path.join(work_dir, emfac_config['emfac_rates_by_model_year_file']) + emfac_emission_rate_output_file = os.path.join( + work_dir, + f"{config["rates"]["output_dir"]}/{study_area}_emfac_rates_{scenario_name}.csv" + ) + + if check_files([emfac_emission_rate_output_file], config["override_rates"]): + emfac_rates = pd.read_csv(emfac_emission_rate_output_file) + else: + emfac_rates = process_emfac_rates( + emfac_rates_by_model_year_file, + format_func, + filters_config['season_month'], + filters_config['calendar_year'], + filters_config['sub_area'], + filters_config['temperature'], + filters_config['relative_humidity'], + include_nan=filters_config["include_nan"]) + + print(f"Writing EMFAC emission rate to: {emfac_emission_rate_output_file}") + emfac_rates.to_csv(emfac_emission_rate_output_file, index=False) + + return emfac_rates + + +def process_black_carbon(study_area, scenario_name, work_dir, config, format_func): + # Get file paths + black_carbon_config = config["rates"]["black_carbon"] + filters_config = config["rates"]["filters"] + bc_rates_by_model_year_file = os.path.join(work_dir, black_carbon_config['black_carbon_rates_file']) + bc_emission_rate_output_file = os.path.join( + work_dir, + f"{config["rates"]["output_dir"]}/{study_area}_black_carbon_rates_{scenario_name}.csv" + ) + + if check_files([bc_emission_rate_output_file], config["override_rates"]): + bc_rates = pd.read_csv(bc_emission_rate_output_file) + else: + bc_rates = process_emfac_rates( + bc_rates_by_model_year_file, + format_func, + filters_config['season_month'], + filters_config['calendar_year'], + filters_config['sub_area'], + filters_config['temperature'], + filters_config['relative_humidity'], + include_nan=filters_config["include_nan"] + ) + + print(f"Writing Black Carbon emission rate to: {bc_emission_rate_output_file}") + bc_rates.to_csv(bc_emission_rate_output_file, index=False) + + return bc_rates + + +def process_road_dust(study_area, scenario_name, work_dir, config, emfac_ids): + """ + Process road dust emission rates for all EMFAC IDs. + + Args: + study_area (str): Study area name + scenario_name (str): Scenario name + work_dir (str): Working directory path + config (dict): Configuration dictionary + emfac_ids (set): Set of EMFAC IDs to process + + Returns: + pd.DataFrame: Road dust emission rates for all EMFAC IDs + """ + road_dust_config = config["rates"]["road_dust"] + filters_config = config["rates"]["filters"] + + # Get road dust file paths + _rainy_days_file = os.path.join(work_dir, road_dust_config['rainy_days_file']) + _silt_loading_file = os.path.join(work_dir, road_dust_config['silt_loading_file']) + road_dust_output_file = os.path.join( + work_dir, + f"{config["rates"]["output_dir"]}/{study_area}_paved_road_dust_rates_{scenario_name}.csv" + ) + + # Check if the output file already exists + if check_files([road_dust_output_file], config["override_rates"]): + print(f"Loading existing road dust rates from: {road_dust_output_file}") + road_dust_rates = pd.read_csv(road_dust_output_file) + print(f"Loaded road dust rates with {len(road_dust_rates)} rows") + else: + try: + # Ensure output directory exists + os.makedirs(os.path.dirname(road_dust_output_file), exist_ok=True) + + print(f"Processing road dust for air basins: {filters_config['sub_area']}") + print(f"Using rainy days file: {_rainy_days_file}") + print(f"Using silt loading file: {_silt_loading_file}") + + # Process road dust emission rates + road_dust_rates = generate_road_dust_rates(_rainy_days_file, _silt_loading_file, filters_config['sub_area']) + + print(f"Generated base road dust rates with {len(road_dust_rates)} rows") + print(f"Duplicating rates for {len(emfac_ids)} EMFAC IDs") + + # Create a list to hold all DataFrames + dfs = [] + + # Use tqdm to show progress of the duplication process + for emfac_id in tqdm(emfac_ids, desc="Creating rates for each EMFAC ID"): + temp_df = road_dust_rates.copy() + temp_df["emfacId"] = emfac_id + dfs.append(temp_df) + + # Concatenate all the DataFrames + print("Concatenating all rates...") + road_dust_rates = pd.concat(dfs, ignore_index=True) + print(f"Final road dust rates shape: {road_dust_rates.shape}") + + # Ensure output directory exists + os.makedirs(os.path.dirname(road_dust_output_file), exist_ok=True) + + print(f"Writing road dust emission rates to: {road_dust_output_file}") + road_dust_rates.to_csv(road_dust_output_file, index=False) + print("Road dust rates saved successfully") + + except Exception as e: + print(f"Error processing road dust for scenario '{scenario_name}': {str(e)}") + print("Returning empty DataFrame due to error") + return pd.DataFrame() + + return road_dust_rates + + +def process_emissions_rates(_study_area, _scenario_name, _work_dir, config, format_func): + """ + Process emissions rates for one or more scenarios based on the provided configuration. + + Args: + _study_area (str): Area for which emissions rates need to be processed + _scenario_name (str): Name of the scenario + _work_dir (str): Working directory path + config (dict): Configuration dictionary containing emission scenarios + format_func: + + Returns: + pd.DataFrame: Combined emissions rates for the scenario + """ + # File paths for outputs + rates_config = config["rates"] + combined_rate_file = os.path.join(_work_dir, f"{rates_config["output_dir"]}/{_study_area}_emissions_rates_{_scenario_name}.csv") + + # Ensure output directory exists + os.makedirs(os.path.dirname(combined_rate_file), exist_ok=True) + + if check_files([combined_rate_file], config["override_rates"]): + print(f"Loading existing combined rates from: {combined_rate_file}") + _combined_rates = pd.read_csv(combined_rate_file, dtype=str) + print(f"Loaded combined rates with {len(_combined_rates)} rows") + else: + print(f"Starting emissions rate processing for {_study_area}, scenario: {_scenario_name}") + dfs = [] + emfac_ids = set() + + # Track processing steps + steps = [] + if 'emfac' in rates_config: + steps.append('EMFAC emissions') + if 'black_carbon' in rates_config: + steps.append('Black Carbon emissions') + if 'road_dust' in rates_config: + steps.append('Road Dust emissions') + + print(f"Will process: {', '.join(steps)}") + + # Use tqdm to show progress of processing steps + with tqdm(total=len(steps), desc="Processing emission types") as pbar: + # Process EMFAC emissions if configured + if 'emfac' in rates_config: + print(f"\nProcessing EMFAC emissions for scenario '{_scenario_name}'") + emfac_rates = process_emfac_emissions(_study_area, _scenario_name, _work_dir, config, format_func) + if not emfac_rates.empty: + dfs.append(emfac_rates) + emfac_ids.update(emfac_rates["emfacId"].unique()) + print(f"Added {len(emfac_rates)} EMFAC emission rows") + else: + print("No EMFAC emissions were processed") + pbar.update(1) + else: + print(f"Skipping EMFAC processing for scenario '{_scenario_name}' as no config is provided.") + + # Process black carbon emissions if configured + if 'black_carbon' in rates_config: + print(f"\nProcessing Black Carbon emissions for scenario '{_scenario_name}'") + black_carbon_rates = process_black_carbon(_study_area, _scenario_name, _work_dir, config, format_func) + if not black_carbon_rates.empty: + dfs.append(black_carbon_rates) + emfac_ids.update(black_carbon_rates["emfacId"].unique()) + print(f"Added {len(black_carbon_rates)} Black Carbon emission rows") + else: + print("No Black Carbon emissions were processed") + pbar.update(1) + else: + print(f"Skipping Black Carbon processing for scenario '{_scenario_name}' as no config is provided.") + + # Process road dust emissions if configured + if 'road_dust' in rates_config: + print(f"\nProcessing Road Dust emissions for scenario '{_scenario_name}'") + road_dust_rates = process_road_dust(_study_area, _scenario_name, _work_dir, config, emfac_ids) + if not road_dust_rates.empty: + dfs.append(road_dust_rates) + print(f"Added {len(road_dust_rates)} Road Dust emission rows") + else: + print("No Road Dust emissions were processed") + pbar.update(1) + else: + print(f"Skipping Paved Road Dust processing for scenario '{_scenario_name}' as no config is provided.") + + if not dfs: + print(f"Warning: No emission rates available for scenario '{_scenario_name}'") + _combined_rates = pd.DataFrame() + else: + print("\nCombining all emission rates...") + + # Get counts for each type of emission + emission_counts = { + f"Source {i + 1}": len(df) for i, df in enumerate(dfs) if df is not None + } + print(f"Emission source row counts: {emission_counts}") + + # Get all unique columns from all dataframes + all_columns = set() + for df in dfs: + if df is not None: # Check that df is not None + all_columns.update(df.columns) + print(f"Total unique columns across all sources: {len(all_columns)}") + + # Filter out None values + valid_dfs = [df for df in dfs if df is not None] + print(f"Processing {len(valid_dfs)} valid dataframes") + + # Add missing columns to each dataframe + print("Adding missing columns to each dataframe...") + for i in tqdm(range(len(valid_dfs)), desc="Standardizing dataframes"): + missing_cols = all_columns - set(valid_dfs[i].columns) + for col in missing_cols: + valid_dfs[i][col] = None + print(f"Added {len(missing_cols)} missing columns to dataframe {i + 1}") + + print("Concatenating all dataframes...") + _combined_rates = pd.concat(valid_dfs, ignore_index=True) + _combined_rates["scenario"] = _scenario_name + + # Report on final combined size + print(f"Combined rates shape: {_combined_rates.shape}") + + # Specify the columns you want to appear first + first_cols = [ + "scenario", "emfacId", "county", "speed_mph_float_bins", "time_minutes_float_bins", "road_category", + "process" + ] + remaining_cols = [col for col in _combined_rates.columns if col not in first_cols] + _combined_rates = _combined_rates[first_cols + remaining_cols] + + print(f"Writing combined emission rates to: {combined_rate_file}") + _combined_rates.to_csv(combined_rate_file, index=False) + print("Combined rates saved successfully") + + return _combined_rates + + +def process_emfac_population(_study_area, _scenario_name, _work_dir, config, format_func): + """ + Process EMFAC population data by model year, adding proportional calculations. + + Args: + _study_area: Study area name + _scenario_name: Scenario name + _work_dir: Working directory path + config: Configuration dictionary containing filtering and file path information + format_func: Function to format the data + + Returns: + pandas.DataFrame: Processed and grouped population data with proportion calculations + """ + _emfac_population_output_file = os.path.join( + _work_dir, + f"{config["rates"]["output_dir"]}/{_study_area}_emfac_population_{_scenario_name}.csv" + ) + + # Ensure output directory exists + os.makedirs(os.path.dirname(_emfac_population_output_file), exist_ok=True) + + if check_files([_emfac_population_output_file], config["override_rates"]): + print(f"Loading existing EMFAC population data from: {_emfac_population_output_file}") + emfac_population = pd.read_csv(_emfac_population_output_file) + print(f"Loaded population data with {len(emfac_population)} rows") + else: + print(f"Processing EMFAC population data for {_study_area}, scenario: {_scenario_name}") + + include_nan = config["rates"]["filters"]["include_nan"] + calendar_year = config["rates"]["filters"]["calendar_year"] + air_basin_area = config["rates"]["filters"]["sub_area"] + _emfac_population_by_model_year_file = os.path.join( + _work_dir, + config["rates"]["emfac"]["emfac_pop_by_model_year_file"] + ) + + print(f"Reading population data from: {_emfac_population_by_model_year_file}") + + table = csv.read_csv(_emfac_population_by_model_year_file, read_options=pa.csv.ReadOptions(use_threads=True)) + df = table.to_pandas() + print(f"Loaded population data with shape: {df.shape}") + + # Create a progress bar for the filtering steps + filtering_steps = [ + "Calendar year", + "Air basin area", + "Convert population", + "Clean data", + "Format data", + "Group data", + "Calculate proportions" + ] + + with tqdm(total=len(filtering_steps), desc="Processing population data") as pbar: + # Filter by calendar year + if 'calendar_year' in df.columns: + print(f"Filtering by calendar year: {calendar_year}") + before_count = len(df) + df = df[(df['calendar_year'] == calendar_year) | (include_nan & df['calendar_year'].isna())] + print(f"After filtering: {len(df)} rows (removed {before_count - len(df)} rows)") + pbar.update(1) + + # Filter by sub area + if 'sub_area' in df.columns: + print(f"Filtering by air basin area: {air_basin_area}") + before_count = len(df) + # Create a filter condition for partial matches + sub_area_filter = include_nan & df['sub_area'].isna() + + for _area in air_basin_area: + # Look for exact match or area in parentheses (e.g., "Santa Clara (SF)" for "SF") + sub_area_filter = sub_area_filter | df['sub_area'].str.contains(f'\\({_area}\\)', regex=True) | ( + df['sub_area'] == _area) + + # Apply the filter + df = df[sub_area_filter] + print(f"After filtering: {len(df)} rows (removed {before_count - len(df)} rows)") + pbar.update(1) + + # Convert population column to float for calculations + if 'population' in df.columns: + print("Converting population to numeric values") + df['population'] = pd.to_numeric(df['population'], errors='coerce') + # Check for NaN values after conversion + nan_count = df['population'].isna().sum() + if nan_count > 0: + print(f"Warning: {nan_count} rows have non-numeric population values") + pbar.update(1) + + # Clean data + print("Cleaning data (filling NaN values and resetting index)") + df = df.fillna('') + df = df.reset_index(drop=True) + pbar.update(1) + + # Format the data + print("Formatting data with provided format function") + df_formatted = format_func(df) + print(f"Formatted data shape: {df_formatted.shape}") + pbar.update(1) + + # Group by relevant columns and sum population + print("Grouping data and calculating total populations") + emfac_population = df_formatted.groupby('emfacId').agg({ + 'vehicle_class': 'first', + 'fuel': 'first', + 'model_year_group': 'first', + 'mappedFuel': 'first', + 'mappedClass': 'first', + 'population': 'sum' + }).reset_index() + print(f"After grouping: {len(emfac_population)} unique vehicle class/fuel/model year combinations") + pbar.update(1) + + # Calculate total population across all groups + total_population = emfac_population['population'].sum() + print(f"Total vehicle population: {total_population:,.0f}") + + # Calculate proportion of each group relative to total + print("Calculating population proportions") + emfac_population['population_proportion'] = emfac_population['population'] / total_population + + # Print the top 5 vehicle categories by population + print("Top 5 vehicle categories by population:") + top_5 = emfac_population.sort_values('population', ascending=False).head(5) + for _, row in top_5.iterrows(): + percent = row['population_proportion'] * 100 + print(f" {row['vehicle_class']}, {row['fuel']}, {row['model_year_group']}: " + f"{row['population']:,.0f} vehicles ({percent:.2f}%)") + pbar.update(1) + + # Save the processed data + print(f"Writing population data to: {_emfac_population_output_file}") + emfac_population.to_csv(_emfac_population_output_file, index=False) + print("Population data saved successfully") + + return emfac_population + + +def process_emfac_vmt(_study_area, _scenario_name, _work_dir, config, format_func): + """ + Process EMFAC VMT data by model year, adding proportional calculations. + + Args: + _study_area: Study area name + _scenario_name: Scenario name + _work_dir: Working directory path + config: Configuration dictionary containing filtering and file path information + format_func: Function to format the data + + Returns: + pandas.DataFrame: Processed and grouped VMT data with proportion calculations + """ + _emfac_vmt_output_file = os.path.join( + _work_dir, + f"{config["rates"]["output_dir"]}/{_study_area}_emfac_vmt_{_scenario_name}.csv" + ) + + # Ensure output directory exists + os.makedirs(os.path.dirname(_emfac_vmt_output_file), exist_ok=True) + + if check_files([_emfac_vmt_output_file], config["override_rates"]): + print(f"Loading existing EMFAC VMT data from: {_emfac_vmt_output_file}") + emfac_vmt = pd.read_csv(_emfac_vmt_output_file) + print(f"Loaded VMT data with {len(emfac_vmt)} rows") + else: + print(f"Processing EMFAC VMT data for {_study_area}, scenario: {_scenario_name}") + + include_nan = config["rates"]["filters"]["include_nan"] + calendar_year = config["rates"]["filters"]["calendar_year"] + air_basin_area = config["rates"]["filters"]["sub_area"] + _emfac_vmt_by_model_year_file = os.path.join( + _work_dir, + config["rates"]["emfac"]["emfac_vmt_by_model_year_file"] + ) + + print(f"Reading VMT data from: {_emfac_vmt_by_model_year_file}") + + table = csv.read_csv(_emfac_vmt_by_model_year_file, read_options=pa.csv.ReadOptions(use_threads=True)) + df = table.to_pandas() + print(f"Loaded VMT data with shape: {df.shape}") + + # Create a progress bar for the filtering steps + filtering_steps = [ + "Calendar year", + "Air basin area", + "Convert numeric columns", + "Format data", + "Clean data", + "Group data", + "Calculate proportions" + ] + + with tqdm(total=len(filtering_steps), desc="Processing VMT data") as pbar: + # Filter by calendar year + if 'calendar_year' in df.columns: + print(f"Filtering by calendar year: {calendar_year}") + before_count = len(df) + df = df[(df['calendar_year'] == calendar_year) | (include_nan & df['calendar_year'].isna())] + print(f"After filtering: {len(df)} rows (removed {before_count - len(df)} rows)") + pbar.update(1) + + # Filter by sub area + if 'sub_area' in df.columns: + print(f"Filtering by air basin area: {air_basin_area}") + before_count = len(df) + # Create a filter condition for partial matches + sub_area_filter = include_nan & df['sub_area'].isna() + + for _area in air_basin_area: + # Look for exact match or area in parentheses (e.g., "Santa Clara (SF)" for "SF") + sub_area_filter = sub_area_filter | df['sub_area'].str.contains(f'\\({_area}\\)', regex=True) | ( + df['sub_area'] == _area) + + # Apply the filter + df = df[sub_area_filter] + print(f"After filtering: {len(df)} rows (removed {before_count - len(df)} rows)") + pbar.update(1) + + # Convert numeric columns to float for calculations + numeric_columns = ['total_vmt', 'cvmt', 'evmt'] + print("Converting numeric columns to float") + for col in numeric_columns: + if col in df.columns: + df[col] = pd.to_numeric(df[col], errors='coerce') + # Check for NaN values after conversion + nan_count = df[col].isna().sum() + if nan_count > 0: + print(f"Warning: {nan_count} rows have non-numeric {col} values") + pbar.update(1) + + # Format the data + print("Formatting data with provided format function") + df_formatted = format_func(df) + print(f"Formatted data shape: {df_formatted.shape}") + pbar.update(1) + + # Clean data + print("Cleaning data (filling NaN values and resetting index)") + df_formatted = df_formatted.fillna('').reset_index(drop=True) + pbar.update(1) + + # Group by relevant columns and sum VMT + print("Grouping data and calculating total VMT") + emfac_vmt = df_formatted.groupby('emfacId').agg({ + 'vehicle_class': 'first', + 'fuel': 'first', + 'model_year_group': 'first', + 'mappedFuel': 'first', + 'mappedClass': 'first', + 'total_vmt': 'sum' + }).reset_index() + print(f"After grouping: {len(emfac_vmt)} unique vehicle class/fuel/model year combinations") + pbar.update(1) + + # Calculate total VMT across all groups + total_vmt = emfac_vmt['total_vmt'].sum() + print(f"Total VMT: {total_vmt:,.0f}") + + # Calculate proportion of each group relative to total + print("Calculating VMT proportions") + emfac_vmt['vmt_proportion'] = emfac_vmt['total_vmt'] / total_vmt + + # Print the top 5 vehicle categories by VMT + print("Top 5 vehicle categories by VMT:") + top_5 = emfac_vmt.sort_values('total_vmt', ascending=False).head(5) + for _, row in top_5.iterrows(): + percent = row['vmt_proportion'] * 100 + print(f" {row['vehicle_class']}, {row['fuel']}, {row['model_year_group']}: " + f"{row['total_vmt']:,.0f} VMT ({percent:.2f}%)") + pbar.update(1) + + # Save the processed data + print(f"Writing VMT data to: {_emfac_vmt_output_file}") + emfac_vmt.to_csv(_emfac_vmt_output_file, index=False) + print("VMT data saved successfully") + + return emfac_vmt \ No newline at end of file diff --git a/src/main/python/emissions/_emfac_beam_ft_matching.py b/src/main/python/emissions/_emfac_beam_ft_matching.py new file mode 100644 index 00000000000..c9519396a05 --- /dev/null +++ b/src/main/python/emissions/_emfac_beam_ft_matching.py @@ -0,0 +1,689 @@ +import os.path +import sys + +import numpy as np +import pandas as pd +from tqdm import tqdm + +from utils.files_utils import sanitize_name + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +# Now use absolute import + + +def calculate_tour_summary_by_vehicle(payloads_raw): + """ + Calculate tour distances and generate vehicle-level VMT summary statistics. + + This function processes raw payload data to compute tour distances based on + sequential coordinates, then aggregates these distances to the vehicle level. + It calculates both absolute VMT values and proportional VMT shares. + + Args: + payloads_raw (pandas.DataFrame): DataFrame containing payload records with + columns: 'tourId', 'sequenceRank', 'locationX', 'locationY', 'payloadId', + 'vehicleId', and 'payloadType'. + + Returns: + pandas.DataFrame: Vehicle-level summary with total VMT and VMT proportion. + The DataFrame is indexed by vehicleId with columns 'total_vmt' and + 'vmt_proportion'. + + Note: + Distances are calculated using Euclidean distance between consecutive + locations within each tour. + """ + # Sort data by tourId and sequenceRank + df = payloads_raw.sort_values(by=['tourId', 'sequenceRank']) + + # Create shifted columns to calculate distances between consecutive points + df['next_x'] = df.groupby('tourId')['locationX'].shift(-1) + df['next_y'] = df.groupby('tourId')['locationY'].shift(-1) + + # Calculate distances (only where next point exists) + # Create arrays from DataFrame columns for faster operations + x1 = df['locationX'].values + y1 = df['locationY'].values + x2 = df['next_x'].values + y2 = df['next_y'].values + mask = ~np.isnan(x2) + + # Calculate distances using NumPy operations + distances = np.zeros(len(df)) + distances[mask] = np.sqrt((x1[mask] - x2[mask]) ** 2 + (y1[mask] - y2[mask]) ** 2) + + # Assign back to DataFrame + df['segment_distance'] = distances + + # Sum up distances by tour + tour_distances = df.groupby('tourId')['segment_distance'].sum().to_dict() + total_distance = sum(tour_distances.values()) + tour_proportions = {tour_id: dist / total_distance for tour_id, dist in tour_distances.items()} + + # Create summary dataframe + payloads = payloads_raw[['tourId', 'payloadType']].copy() + payloads['payloadType'] = payloads['payloadType'].astype(str) + + # Group by tour and add distance metrics + summary = (payloads + .groupby('tourId')['payloadType'] + .agg('|'.join) + .reset_index()) + + # Add distance metrics + summary['total_vmt'] = summary['tourId'].map(tour_distances) + summary['vmt_proportion'] = summary['tourId'].map(tour_proportions) + + return summary + + +def find_best_match(veh_class, veh_fuel, alternatives_mapping, df): + """ + Find the best matching EMFAC vehicle record using a hierarchical matching strategy. + + This function implements a four-tier fallback approach to match BEAM vehicles + with EMFAC vehicles: + 1. Exact match: Same vehicle class AND fuel type + 2. Fuel-only match: Matching fuel type, any vehicle class + 3. Class-only match: Matching vehicle class, any fuel type + 4. Any-match: Random selection if no other matches are found + + The VMT-weighted sampling ensures that more common vehicle configurations + in the EMFAC dataset are more likely to be selected as matches. + + Args: + veh_class (str): BEAM vehicle class to match + veh_fuel (str): EMFAC fuel type to match + df (pandas.DataFrame): DataFrame of EMFAC vehicles with columns: + 'mappedClass', 'fuel', 'model_year_group', 'emfacId', and 'vmt_proportion' + + Returns: + dict: Matching result with the following keys: + 'match': The matched EMFAC vehicle record + 'type': Match type ('exact', 'fuel', 'class', or 'any') + 'composite_key': String key in format "{year},{class},{fuel}" + 'emfacId': EMFAC vehicle ID from the matched record + 'updates': Dictionary of fields that need to be updated in the original record + """ + # Create boolean arrays once + class_mask = df['mappedClass'].values == veh_class + approx_class_mask = df['mappedClass'].isin(alternatives_mapping[veh_class]) + fuel_mask = df['mappedFuel'].values == veh_fuel + approx_fuel_mask = df['mappedFuel'].isin(alternatives_mapping[veh_fuel]) + + # Combine masks with NumPy + full_match_mask = np.logical_and(class_mask, fuel_mask) + full_matches = df[full_match_mask] + match_type = "type" + if full_matches.empty: + full_matches = df[np.logical_and(class_mask, approx_fuel_mask)] + match_type = "exact-approx-fuel" + if full_matches.empty: + full_matches = df[np.logical_and(approx_class_mask, fuel_mask)] + match_type = "exact-approx-class" + if full_matches.empty: + full_matches = df[np.logical_and(approx_class_mask, approx_fuel_mask)] + match_type = "approx-class-fuel" + + if not full_matches.empty: + match = full_matches.sample(n=1, weights='vmt_proportion').iloc[0] + return { + 'match': match, + 'type': match_type, + 'composite_key': f"{match['model_year_group']},{match['mappedClass']},{match['mappedFuel']}", + 'emfacId': match['emfacId'], + 'updates': {} + } + + # Try fuel match only + fuel_matches = df[fuel_mask] + match_type = "fuel" + if fuel_matches.empty: + fuel_matches = df[approx_fuel_mask] + match_type = "approx-fuel" + + if not fuel_matches.empty: + match = fuel_matches.sample(n=1, weights='vmt_proportion').iloc[0] + return { + 'match': match, + 'type': match_type, + 'composite_key': f"{match['model_year_group']},{match['mappedClass']},{match['mappedFuel']}", + 'emfacId': match['emfacId'], + 'updates': {'mappedClass': match['mappedClass']} + } + + + + # Try class match only + class_matches = df[class_mask] + match_type = 'class' + if class_matches.empty: + class_matches = df[approx_class_mask] + match_type = "approx-class" + + if not class_matches.empty: + match = class_matches.sample(n=1, weights='vmt_proportion').iloc[0] + return { + 'match': match, + 'type': match_type, + 'composite_key': f"{match['model_year_group']},{match['mappedClass']},{match['mappedFuel']}", + 'emfacId': match['emfacId'], + 'updates': {'mappedFuel': match['mappedFuel']} + } + + # Last resort - any vehicle + match = df.sample(n=1, weights='vmt_proportion').iloc[0] + return { + 'match': match, + 'type': 'any', + 'composite_key': f"{match['model_year_group']},{match['mappedClass']},{match['mappedFuel']}", + 'emfacId': match['emfacId'], + 'updates': { + 'mappedClass': match['mappedClass'], + 'mappedFuel': match['mappedFuel'] + } + } + + +def analyze_vmt_distribution(beam_vmt_track, emfac_vmt_track): + """ + Analyze and compare VMT distributions between EMFAC and BEAM data after mapping. + + This function takes the VMT tracking dictionaries from the mapping process + and generates detailed comparative analysis in two dimensions: + 1. By model year group and vehicle class + 2. By fuel type only + + For each comparison, the function: + - Creates DataFrames from the tracking dictionaries + - Aggregates VMT proportions by the relevant dimensions + - Calculates absolute and percentage differences + - Prints formatted tables of the most significant differences + - Reports summary statistics on the overall distribution match + + Args: + beam_vmt_track (dict): Dictionary with composite keys (year,class,fuel) mapping + to BEAM VMT proportions + emfac_vmt_track (dict): Dictionary with composite keys (year,class,fuel) mapping + to EMFAC VMT proportions + + Returns: + None: Results are printed to standard output + + Note: + The function expects composite keys in the format "year,class,fuel" and + will parse these to create structured DataFrames for comparison. + """ + print("\n=== VMT Distribution Analysis ===") + + # Create DataFrames from tracking dictionaries + emfac_rows = [] + beam_rows = [] + + for composite_key in set(list(beam_vmt_track.keys()) + list(emfac_vmt_track.keys())): + parts = composite_key.split(',') + if len(parts) == 3: + model_year_group, mapped_class, mapped_fuel = parts + + # Get VMT proportions (default to 0 if not present) + emfac_proportion = emfac_vmt_track.get(composite_key, 0) + beam_proportion = beam_vmt_track.get(composite_key, 0) + + # Add to respective lists + emfac_rows.append({ + 'model_year_group': model_year_group, + 'mappedClass': mapped_class, + 'mappedFuel': mapped_fuel, + 'vmt_proportion': emfac_proportion + }) + + beam_rows.append({ + 'model_year_group': model_year_group, + 'mappedClass': mapped_class, + 'mappedFuel': mapped_fuel, + 'vmt_share': beam_proportion + }) + + emfac_df = pd.DataFrame(emfac_rows) + beam_df = pd.DataFrame(beam_rows) + + # 1. Compare by model_year_group and mappedClass + print("\n--- VMT Comparison by Model Year and Vehicle Class ---") + + # Aggregate by year and class + emfac_by_year_class = emfac_df.groupby(['model_year_group', 'mappedClass'])['vmt_proportion'].sum().reset_index() + beam_by_year_class = beam_df.groupby(['model_year_group', 'mappedClass'])['vmt_share'].sum().reset_index() + + # Merge for comparison + year_class_comparison = pd.merge( + emfac_by_year_class, + beam_by_year_class, + on=['model_year_group', 'mappedClass'], + how='outer', + copy=False + ).fillna(0) + + # Calculate differences + year_class_comparison['difference'] = year_class_comparison['vmt_proportion'] - year_class_comparison['vmt_share'] + year_class_comparison['abs_difference'] = abs(year_class_comparison['difference']) + + # Sort by absolute difference and get top 10 + top_diff = year_class_comparison.sort_values('abs_difference', ascending=False).head(10) + + # Print table header + print("\nTop 10 VMT Proportion Differences by Year and Class:") + print("------------------------------------------------------------------") + print(f"{'Year':^10} | {'Class':^15} | {'EMFAC %':^10} | {'BEAM %':^10} | {'Diff %':^10}") + print("------------------------------------------------------------------") + + # Print each row with formatting + for _, row in top_diff.iterrows(): + print(f"{row['model_year_group']:^10} | " + f"{row['mappedClass']:^15} | " + f"{row['vmt_proportion'] * 100:^10.2f} | " + f"{row['vmt_share'] * 100:^10.2f} | " + f"{row['difference'] * 100:^10.2f}") + + # 2. Compare by fuel only + print("\n\n--- VMT Comparison by Fuel Type ---") + + # Aggregate by fuel + emfac_by_fuel = emfac_df.groupby(['mappedFuel'])['vmt_proportion'].sum().reset_index() + beam_by_fuel = beam_df.groupby(['mappedFuel'])['vmt_share'].sum().reset_index() + + # Merge for comparison + fuel_comparison = pd.merge( + emfac_by_fuel, + beam_by_fuel, + on=['mappedFuel'], + how='outer' + ).fillna(0) + + # Calculate differences + fuel_comparison['difference'] = fuel_comparison['vmt_proportion'] - fuel_comparison['vmt_share'] + fuel_comparison['abs_difference'] = abs(fuel_comparison['difference']) + + # Sort by absolute difference + fuel_comparison = fuel_comparison.sort_values('abs_difference', ascending=False) + + # Print table header + print("\nVMT Proportion Differences by Fuel Type:") + print("------------------------------------------------------------------") + print(f"{'Fuel Type':^15} | {'EMFAC %':^10} | {'BEAM %':^10} | {'Diff %':^10}") + print("------------------------------------------------------------------") + + # Print each row with formatting + for _, row in fuel_comparison.iterrows(): + print(f"{row['mappedFuel']:^15} | " + f"{row['vmt_proportion'] * 100:^10.2f} | " + f"{row['vmt_share'] * 100:^10.2f} | " + f"{row['difference'] * 100:^10.2f}") + + # Print summary stats + print("\n--- Summary Statistics ---") + print(f"Total model year/class combinations: {len(year_class_comparison)}") + print(f"Total fuel types: {len(fuel_comparison)}") + print(f"Max absolute difference by year/class: {year_class_comparison['abs_difference'].max() * 100:.2f}%") + print(f"Max absolute difference by fuel: {fuel_comparison['abs_difference'].max() * 100:.2f}%") + print(f"Average absolute difference by year/class: {year_class_comparison['abs_difference'].mean() * 100:.2f}%") + print(f"Average absolute difference by fuel: {fuel_comparison['abs_difference'].mean() * 100:.2f}%") + + +def emfac2freight_by_model_year_class_fuel(ft_emfac_vmt, carriers_raw, payloads_raw, vehicle_types_formatted, alternatives_mapping): + """ + Map EMFAC vehicle data to BEAM freight vehicles based on VMT proportions and vehicle attributes. + + This function performs a comprehensive matching process between EMFAC's emissions database + and BEAM's freight vehicle fleet. It uses VMT (vehicle miles traveled) proportions as a key + metric to ensure the distribution of vehicle types in the mapped result preserves the original + EMFAC emissions characteristics. + + The matching process: + 1. Calculates VMT for each BEAM freight vehicle from tour payload data + 2. Extracts VMT proportions from the EMFAC data by vehicle class, model year, and fuel type + 3. Creates composite tracking keys in the format "year,class,fuel" for comparison + 4. Matches each BEAM vehicle to an appropriate EMFAC vehicle using a hierarchical strategy + 5. Tracks VMT allocation to prevent overallocation of specific vehicle configurations + 6. Analyzes and reports on the resulting VMT distribution match quality + + Args: + ft_emfac_vmt (pandas.DataFrame): EMFAC VMT data containing columns 'mappedClass', + 'model_year_group', 'fuel', 'total_vmt', and 'emfacId' for freight fleet + carriers_raw (pandas.DataFrame): Raw carriers data with 'vehicleId' and 'vehicleTypeId' + payloads_raw (pandas.DataFrame): Raw payload data for calculating tour distances + vehicle_types_formatted (pandas.DataFrame): Pre-formatted vehicle types with 'vehicleTypeId', + 'mappedClass', and 'mappedFuel' + + Returns: + pandas.DataFrame: Mapping result with columns 'vehicleId', 'emfacId', 'vehicleTypeId', + 'mappedFuel', and 'mappedClass' + + Note: + The function prints progress information and performs VMT distribution analysis + after completing the mapping. + """ + print("=== VMT-based Mapping Of BEAM Freight with EMFAC ===") + + # Step 1: Calculate euclidian VMT dataframe + tour_summary = calculate_tour_summary_by_vehicle(payloads_raw) + + # Step 2: Merge with vehicle types + vehicle_w_vmt = pd.merge( + tour_summary, + carriers_raw[['tourId', 'vehicleId', 'vehicleTypeId']], + on='tourId', + how='left', + copy=False + ).groupby('vehicleId').agg({ + 'total_vmt': 'sum', + 'vmt_proportion': 'sum', + 'vehicleTypeId': 'first' + }).reset_index() + vehicle_w_vmt = pd.merge(vehicle_w_vmt, vehicle_types_formatted, on='vehicleTypeId', how='left', copy=False) + vehicle_w_vmt = vehicle_w_vmt.sort_values('vmt_proportion', ascending=False).reset_index(drop=True) + total_beam_vmt = vehicle_w_vmt['total_vmt'].sum() + print(f"BEAM VMT with {len(vehicle_w_vmt)} rows and total vmt of {total_beam_vmt}.") + + # Step 3: Extract VMT proportion in EMFAC data + # Optimized code + emfac_w_vmt = ft_emfac_vmt.groupby(['mappedClass', 'model_year_group', 'mappedFuel', 'emfacId'])['total_vmt'].sum().reset_index() + emfac_w_vmt['vmt_proportion'] = emfac_w_vmt['total_vmt'] / emfac_w_vmt['total_vmt'].sum() + emfac_w_vmt = emfac_w_vmt.sort_values('vmt_proportion', ascending=False).reset_index(drop=True) + + total_emfac_vmt = emfac_w_vmt['total_vmt'].sum() + print(f"EMFAC VMT with {len(ft_emfac_vmt)} rows and total vmt of {total_emfac_vmt}.") + + # Step 4: Create composite key for tracking + emfac_w_vmt['composite_key'] = ( + emfac_w_vmt['model_year_group'].astype(str) + ',' + + emfac_w_vmt['mappedClass'] + ',' + + emfac_w_vmt['mappedFuel'] + ) + + key_vmt_series = emfac_w_vmt.groupby('composite_key')['total_vmt'].sum() + emfac_vmt_track = {k: v / total_emfac_vmt for k, v in key_vmt_series.items()} + + # Print top EMFAC VMT proportions + print("Top EMFAC VMT proportions:") + for key, prop in sorted(emfac_vmt_track.items(), key=lambda x: x[1], reverse=True)[:5]: + print(f" {key}: {prop:.4f}") + + # Step 5: Match BEAM vehicles to EMFAC vehicles with VMT-weighted sampling + # Initialize tracking + emfac_w_vmt_fallback = emfac_w_vmt.copy() + beam_vmt_track = {} + vehicle_w_vmt['assigned_class'] = "" # Track matching strategy + + # Create progress bar + total_vehicles = len(vehicle_w_vmt) + print(f"Matching {total_vehicles} vehicles to EMFAC records...") + + # Perform the matching + for i, row in tqdm(vehicle_w_vmt.iterrows(), total=total_vehicles, desc="Matching vehicles"): + veh_class = row['mappedClass'] + veh_fuel = row['mappedFuel'] + vmt_prop = row['vmt_proportion'] + + # Restore the full set if we've run out of options + if emfac_w_vmt.empty: + emfac_w_vmt = emfac_w_vmt_fallback.copy() + + # Find the best match + result = find_best_match( + veh_class, + veh_fuel, + alternatives_mapping, + emfac_w_vmt + ) + + if result['type'] == "any": + print(result) + + # Apply updates + vehicle_w_vmt.loc[i, "emfacId"] = result['emfacId'] + vehicle_w_vmt.loc[i, "assigned_class"] = result['type'] + + for key, value in result['updates'].items(): + vehicle_w_vmt.loc[i, key] = value + + # Track VMT allocation + composite_key = result['composite_key'] + beam_vmt_track[composite_key] = beam_vmt_track.get(composite_key, 0) + vmt_prop + + # Check if we've exhausted this composite key + if beam_vmt_track[composite_key] >= emfac_vmt_track[composite_key]: + print(f"Exhausted composite key {composite_key}: " + f"emfac={emfac_vmt_track[composite_key]:.4f}, " + f"beam={beam_vmt_track[composite_key]:.4f}") + + # Remove this composite key from available options + emfac_w_vmt = emfac_w_vmt[emfac_w_vmt["composite_key"] != composite_key] + + # Prepare the final result + result_columns = ["vehicleId", "emfacId", "vehicleTypeId", "mappedFuel", "mappedClass"] + result_df = vehicle_w_vmt[result_columns] + + # Analyze VMT distribution + analyze_vmt_distribution(beam_vmt_track, emfac_vmt_track) + + return result_df + + +def process_emfac_mappings(mapping_results, vehicle_types, vehicle_types_raw): + """ + Process EMFAC mapping results to create new vehicle types with optimized performance. + + Args: + mapping_results (pd.DataFrame): Results of EMFAC-to-BEAM mapping + vehicle_types (pd.DataFrame): Formatted vehicle types for matching + vehicle_types_raw (pd.DataFrame): Original vehicle types with all columns + + Returns: + tuple: (new_fleet, vehicle_type_map) + """ + from tqdm import tqdm + + print(f"Processing {len(mapping_results)} vehicle mappings...") + + # Initialize tracking variables + match_stats = {"fuel_and_class": 0, "fuel_only": 0, "class_only": 0, "none": 0} + + # For reproducibility + np.random.seed(42) + + # Step 1: Create lookup dataframes for each matching strategy + print("Building lookup tables for matching...") + match_keys = [] + + # Get all unique combinations from mapping_results + unique_fuel_class_combos = mapping_results[['mappedFuel', 'mappedClass']].drop_duplicates().reset_index(drop=True) + + # For each unique combination, find matching vehicle types + for _, combo in tqdm(unique_fuel_class_combos.iterrows(), + total=len(unique_fuel_class_combos), + desc="Building match tables"): + mapped_fuel = combo['mappedFuel'] + mapped_class = combo['mappedClass'] + + # Find matching indices for this combination + both_match = vehicle_types[(vehicle_types['mappedFuel'] == mapped_fuel) & + (vehicle_types['mappedClass'] == mapped_class)] + + fuel_match = vehicle_types[vehicle_types['mappedFuel'] == mapped_fuel] + class_match = vehicle_types[vehicle_types['mappedClass'] == mapped_class] + + # Store the match keys for later use + match_keys.append({ + 'mappedFuel': mapped_fuel, + 'mappedClass': mapped_class, + 'both_match': both_match['vehicleTypeId'].tolist() if not both_match.empty else [], + 'fuel_match': fuel_match['vehicleTypeId'].tolist() if not fuel_match.empty else [], + 'class_match': class_match['vehicleTypeId'].tolist() if not class_match.empty else [] + }) + + # Convert to dataframe for easier joining + match_keys_df = pd.DataFrame(match_keys) + + # Step 2: Join mapping results with match keys + print("Joining mapping results with match keys...") + merged_data = pd.merge( + mapping_results, + match_keys_df, + on=['mappedFuel', 'mappedClass'], + how='left' + ) + + # Step 3: Vectorized creation of new records + print("Applying matching strategy...") + # Prepare to collect results + vehicle_type_map = {} + new_rows = [] + + # Allocate arrays to determine match type for each record + match_type = np.full(len(merged_data), 'none', dtype=object) + match_vehicle_type_id = np.full(len(merged_data), None, dtype=object) + + # Apply matching strategy in order of preference: both > fuel > class > random + for i, row in tqdm(merged_data.iterrows(), + total=len(merged_data), + desc="Finding matches"): + if row['both_match']: + # Match on both fuel and class + match_vehicle_type_id[i] = np.random.choice(row['both_match']) + match_type[i] = 'fuel_and_class' + match_stats['fuel_and_class'] += 1 + elif row['fuel_match']: + # Fall back to matching on fuel only + match_vehicle_type_id[i] = np.random.choice(row['fuel_match']) + match_type[i] = 'fuel_only' + match_stats['fuel_only'] += 1 + elif row['class_match']: + # Fall back to matching on class only + match_vehicle_type_id[i] = np.random.choice(row['class_match']) + match_type[i] = 'class_only' + match_stats['class_only'] += 1 + else: + # Last resort: use any vehicle type + match_vehicle_type_id[i] = np.random.choice(vehicle_types['vehicleTypeId'].values) + match_type[i] = 'none' + match_stats['none'] += 1 + print(f" Warning: No match found for vehicleId={row['vehicleId']}, " + f"mappedClass={row['mappedClass']}, mappedFuel={row['mappedFuel']}") + + # Step 4: Create new vehicle types in a vectorized way + print("Creating new vehicle types...") + for i, row in tqdm(merged_data.iterrows(), + total=len(merged_data), + desc="Creating vehicle types"): + mapped_vehicle_id = row['vehicleId'] + mapped_emfac_id = row['emfacId'] + old_vehicle_type_id = match_vehicle_type_id[i] + + # Create new vehicle type ID that incorporates the EMFAC ID + old_vehicle_type_id_formatted = sanitize_name(old_vehicle_type_id).replace("_", "") + new_vehicle_type_id = f"{mapped_emfac_id}--{old_vehicle_type_id_formatted}" + + # Store the mapping for later carrier updates + vehicle_type_map[mapped_vehicle_id] = new_vehicle_type_id + + # Get the original record from vehicle_types_raw + original_record = vehicle_types_raw[vehicle_types_raw['vehicleTypeId'] == old_vehicle_type_id].iloc[ + 0].copy() + original_record['emfacId'] = mapped_emfac_id + original_record['vehicleTypeId'] = new_vehicle_type_id + new_rows.append(original_record) + + # Create dataframe from collected rows + print("Finalizing results...") + new_fleet = pd.DataFrame(new_rows) + + # Print summary statistics + print("\nMatch statistics:") + print(f" Exact matches (fuel and class): {match_stats['fuel_and_class']}") + print(f" Fuel-only matches: {match_stats['fuel_only']}") + print(f" Class-only matches: {match_stats['class_only']}") + print(f" No matches: {match_stats['none']}") + print(f" Total vehicles processed: {len(mapping_results)}") + print(f" Created {len(new_fleet)} new vehicle types") + + return new_fleet, vehicle_type_map + + +def generate_emfac_mapped_freight_fleet(emfac_vmt, freight_classes, work_dir, config, format_func): + """ + Create updated vehicle types and carriers files based on EMFAC mapping. + + This function performs a complete EMFAC to BEAM freight vehicle mapping workflow: + 1. Loads necessary input files (carriers, payloads, vehicle types) + 2. Formats vehicle types for EMFAC compatibility + 3. Performs the EMFAC-to-BEAM mapping process + 4. Creates new vehicle type records with EMFAC-specific IDs + 5. Updates carrier references to point to the new vehicle types + + Args: + emfac_vmt (pandas.DataFrame): EMFAC VMT data with emissions characteristics + freight_classes (list): List of vehicle classes to consider as freight vehicles + format_func (callable): Function to format vehicle types for EMFAC mapping + work_dir (str): Working directory containing input files + config (dict): Configuration dictionary with file paths and settings + + Returns: + tuple: (updated_carriers_df, updated_vehicle_types_df) + """ + # Prepare file paths + carriers_file = str(os.path.join(work_dir, config["beam"]["carriers_file"])) + payloads_file = str(os.path.join(work_dir, config["beam"]["payloads_file"])) + vehicle_types_file = str(os.path.join(work_dir, config["beam"]["ft_vehicle_types_file"])) + + # Load source data + print(f"Loading data from:\n {carriers_file}\n {vehicle_types_file}") + carriers_raw = pd.read_csv(carriers_file) + payloads_raw = pd.read_csv(payloads_file) + vehicle_types_raw = pd.read_csv(vehicle_types_file, dtype=str) + + # Get freight vehicle types with EMFAC mappings + vehicle_types = format_func( + vehicle_types_raw.loc[ + vehicle_types_raw['vehicleCategory'].isin(freight_classes), + ['vehicleTypeId', 'vehicleCategory', 'primaryFuelType', 'secondaryFuelType'] + ].copy() + ) + + # Filter EMFAC VMT data to freight classes + ft_emfac_vmt = emfac_vmt[['mappedClass', 'model_year_group', 'mappedFuel', 'total_vmt', 'emfacId']][ + emfac_vmt["mappedClass"].isin(freight_classes) + ].copy() + + fuel_class_alternative_mapping = config["mapping"]["fuel"]["alternatives"] | config["mapping"]["class"]["alternatives"] + + # Get mapping between EMFAC and freight vehicles + mapping_results = emfac2freight_by_model_year_class_fuel( + ft_emfac_vmt, + carriers_raw, + payloads_raw, + vehicle_types, + fuel_class_alternative_mapping + ) + + # Process mappings to create new vehicle types + new_fleet, vehicle_type_map = process_emfac_mappings( + mapping_results, + vehicle_types, + vehicle_types_raw + ) + + # Update the carriers file with new vehicle type IDs + new_carriers = carriers_raw.copy() + new_carriers["vehicleTypeId"] = new_carriers["vehicleId"].map( + pd.Series(vehicle_type_map)).fillna(new_carriers["vehicleTypeId"]) + + print(f"Updated {len(new_carriers)} carrier records") + + # Group by all columns except vehicleId, dropping the vehicleId column + new_vehicle_types = new_fleet[[col for col in new_fleet.columns if col != 'vehicleId']].drop_duplicates() + + return new_carriers, new_vehicle_types diff --git a/src/main/python/emissions/_emfac_beam_pax_mapping.py b/src/main/python/emissions/_emfac_beam_pax_mapping.py new file mode 100644 index 00000000000..883cc248c5b --- /dev/null +++ b/src/main/python/emissions/_emfac_beam_pax_mapping.py @@ -0,0 +1,686 @@ +import os +import re +import sys + +import numpy as np +import pandas as pd +from tqdm import tqdm + +from utils.files_utils import sanitize_name + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + + +def parse_sample_probability_string(prob_string): + """ + Parse a sample probability string to extract income and ridehail probabilities. + + The expected format is "income|:; ridehail|" + For example: "income|25-50:0.250000; ridehail|0.200000" + + Args: + prob_string (str): The probability string to parse + + Returns: + tuple: A tuple containing: + - income_bin (str or None): The income bin/range (e.g., '25-50') + - income_prob (float or None): The probability associated with this income bin + - ridehail_prob (float or None): The ridehail probability + """ + # Early return for empty strings or NaN values + if pd.isna(prob_string) or prob_string == "": + return None, None, None + + # Remove spaces and convert to lowercase in one step + cleaned = prob_string.replace(" ", "").lower() + + # Use regex for faster parsing with compile once pattern + income_match = re.search(r"income\|([^:]+):([0-9.]+)", cleaned) + ridehail_match = re.search(r"ridehail\|([^:]+):([0-9.]+)", cleaned) + + # Extract values from matches + income_bin = income_match.group(1) if income_match else None + income_prob = float(income_match.group(2)) if income_match else None + ridehail_bin = ridehail_match.group(1) if ridehail_match else None + ridehail_prob = float(ridehail_match.group(2)) if ridehail_match else None + + return income_bin, income_prob, ridehail_bin, ridehail_prob + + +def create_sample_probability_string(income_bin, income_prob, ridehail_bin, ridehail_prob): + """ + Convert income bin, income probability, and ridehail probability back to a sample probability string. + + This function is the inverse of parse_sample_probability_string. + The resulting string will be in the format: "income|:; ridehail|" + + Args: + income_bin (str or None): Income bin/range (e.g., '25-50', '50-75') + income_prob (float or None): Income probability value + ridehail_prob (float or None): Ridehail probability value + + Returns: + str: Formatted sample probability string + Example: "income|25-50:0.250000; ridehail|0.200000" + Returns empty string if all inputs are None + """ + # Quick return for empty data + if income_bin is None and income_prob is None and ridehail_bin is None and ridehail_prob is None: + return "" + + # Pre-allocate list with appropriate size to avoid resizing + parts = [] + + # Build parts directly + if income_bin is not None and income_prob is not None: + parts.append(f"income|{income_bin}:{income_prob:.6f}") + + if ridehail_bin is not None and ridehail_prob is not None: + parts.append(f"ridehail|{ridehail_bin}:{ridehail_prob:.6f}") + + # Use faster string joining + return "; ".join(parts) + + +def process_vehicle_types_probabilities_by_vehicle_category_and_income_group(vehicle_types): + """ + Process vehicle types data by extracting and normalizing probability distributions. + + This function: + 1. Extracts income bins, income probabilities, and ridehail probabilities from the + sampleProbabilityString column + 2. Normalizes probabilities by vehicle category (ensures sum equals 1 for each category) + 3. Normalizes probabilities by income bin (ensures sum equals 1 for each income bin) + 4. Normalizes ridehail probabilities (ensures sum equals 1) + + Args: + vehicle_types (pd.DataFrame): DataFrame containing vehicle types data with columns: + - vehicleCategory: Category of vehicle + - sampleProbabilityString: String containing probability information + - sampleProbabilityWithinCategory: Probability of the vehicle within its category + + Returns: + pd.DataFrame: Processed DataFrame with additional columns: + - income_bin: Extracted income bin + - income_prop: Normalized income probability + - ridehail_prop: Normalized ridehail probability + """ + # Create a copy of the dataframe to avoid modifying the original + df = vehicle_types.copy() + + # Add new columns directly using vectorized operations + # Apply parse_sample_probability_string to all rows at once + parsed_data = df['sampleProbabilityString'].apply(parse_sample_probability_string) + df['income_bin'] = parsed_data.apply(lambda x: x[0]) + df['income_prop'] = parsed_data.apply(lambda x: x[1]) + df['ridehail_bin'] = parsed_data.apply(lambda x: x[2]) + df['ridehail_prop'] = parsed_data.apply(lambda x: x[3]) + + df['sampleProbabilityWithinCategory'] = pd.to_numeric(df['sampleProbabilityWithinCategory'], errors='coerce') + + # Normalize probabilities by category using groupby operations + # This is faster than iterating through unique categories + category_groups = df.groupby('vehicleCategory') + df['sampleProbabilityWithinCategory'] = df.apply( + lambda row: row['sampleProbabilityWithinCategory'] / + category_groups.get_group(row['vehicleCategory'])['sampleProbabilityWithinCategory'].sum() + if category_groups.get_group(row['vehicleCategory'])['sampleProbabilityWithinCategory'].sum() > 0 + else row['sampleProbabilityWithinCategory'], + axis=1 + ) + + # Normalize income probabilities by category and income bin + for category in df['vehicleCategory'].unique(): + category_df = df[df['vehicleCategory'] == category] + + for income_bin in category_df['income_bin'].dropna().unique(): + mask = (df['vehicleCategory'] == category) & (df['income_bin'] == income_bin) + prob_sum = df.loc[mask, 'income_prop'].sum() + + if prob_sum > 0: + df.loc[mask, 'income_prop'] = df.loc[mask, 'income_prop'] / prob_sum + + # Normalize ridehail probabilities - can be done with vectorized operations + for category in df['vehicleCategory'].unique(): + category_df = df[df['vehicleCategory'] == category] + + for ridehail_bin in category_df['ridehail_bin'].dropna().unique(): + mask = (df['vehicleCategory'] == category) & (df['ridehail_bin'] == ridehail_bin) + prob_sum = df.loc[mask, 'ridehail_prop'].sum() + + if prob_sum > 0: + df.loc[mask, 'ridehail_prop'] = df.loc[mask, 'ridehail_prop'] / prob_sum + + return df + + +def emfac2passenger_with_atlas_crosswalk(vehicle_types, atlas_emfac_fleet, work_dir, config): + """ + Distribute total_vmt and population values evenly across different vehicle typeIds + that share the same emfacId and bodytype combination. + + Args: + vehicle_types (pd.DataFrame): DataFrame with vehicleTypeId and bodytype + atlas_emfac_fleet (pd.DataFrame): DataFrame with emfacId, bodytype, total_vmt, population + + Returns: + pd.DataFrame: DataFrame with distributed vmt and population values + """ + routee_beam_atlas_map = pd.read_csv(str(os.path.join(work_dir, config["mapping"]["atlas"]["routee"])), dtype=str) + vehicles = pd.read_csv(str(os.path.join(work_dir, config["beam"]["pax_vehicles_file"])), dtype=str) + beam_fleet = vehicles["vehicleTypeId"].unique() + filtered_vehicle_types = vehicle_types[vehicle_types["vehicleTypeId"].isin(beam_fleet)].copy() + beam_fleet = filtered_vehicle_types["vehicleTypeId"].unique() + vehicles_filtered = vehicles[vehicles["vehicleTypeId"].isin(beam_fleet)].copy() + + # Step 1: Merge vehicle types with body types + unique_vehicle_bodytype_map = routee_beam_atlas_map.groupby("vehicleTypeId")["bodytype"].first().to_dict() + vehicle_types_with_body_types = filtered_vehicle_types.copy() + vehicle_types_with_body_types["bodytype"] = filtered_vehicle_types["vehicleTypeId"].map(unique_vehicle_bodytype_map).str.lower().str.capitalize() + + # Step 2: Merge with EMFAC fleet data + vehicles_atlas_emfac = pd.merge( + left=vehicle_types_with_body_types, + right=atlas_emfac_fleet, + left_on=['bodytype', 'mappedFuel', 'mappedClass'], + right_on=['bodytype', 'mappedFuel', 'mappedClass'], + how='left' + ) + + # Step 3: Count matching vehicle types for each emfacId + emfac_counts = vehicles_atlas_emfac.groupby('emfacId').size().to_dict() + + # Step 4: Create a mapping of emfacId to total_vmt and population + emfac_values = {row['emfacId']: (row['total_vmt'], row['population']) + for _, row in atlas_emfac_fleet.iterrows()} + + # Step 5: Apply the distribution in one vectorized operation + vehicles_atlas_emfac['total_vmt'] = vehicles_atlas_emfac.apply( + lambda row: emfac_values[row['emfacId']][0] / emfac_counts[row['emfacId']] + if row['emfacId'] in emfac_counts and emfac_counts[row['emfacId']] > 0 else 0, + axis=1 + ) + vehicles_atlas_emfac['population'] = vehicles_atlas_emfac.apply( + lambda row: emfac_values[row['emfacId']][1] / emfac_counts[row['emfacId']] + if row['emfacId'] in emfac_counts and emfac_counts[row['emfacId']] > 0 else 0, + axis=1 + ) + + # Get only valid rows + results = vehicles_atlas_emfac.reset_index(drop=True) + + # Calculate proportions + results['vmt_proportion'] = results.groupby('vehicleCategory')['total_vmt'].transform( + lambda x: x / x.sum() if x.sum() > 0 else 0 + ) + results['population_proportion'] = results.groupby('vehicleCategory')['population'].transform( + lambda x: x / x.sum() if x.sum() > 0 else 0 + ) + + total_vehicle_types = len(vehicles_filtered) + vehicle_type_counts = vehicles_filtered.groupby('vehicleTypeId').size().reset_index(name='count') + vehicle_type_counts["proportion"] = vehicle_type_counts["count"] / total_vehicle_types + vehicle_type_proportions = dict(zip(vehicle_type_counts['vehicleTypeId'], vehicle_type_counts['proportion'])) + + # Apply distribution - fixed the dictionary lookup + results['distribution'] = results['vehicleTypeId'].map(vehicle_type_proportions) * results['vmt_proportion'] + total = results['distribution'].sum() + results['distribution'] = results['distribution'] / total if total > 0 else 0 + + results['sampleProbabilityWithinCategory'] = results['distribution'] + results['income_bin'] = "all" + results['income_prop'] = results['distribution'] + results['ridehail_bin'] = "all" + results['ridehail_prop'] = results['distribution'] + + results['sampleProbabilityString'] = results.apply( + lambda row: create_sample_probability_string( + row['income_bin'], row['income_prop'], row['ridehail_bin'], row['ridehail_prop'] + ), + axis=1 + ) + + return results + + +def emfac2passenger_by_category_income(vehicle_types, car_emfac_fleet, config): + """ + Merge passenger vehicle types with EMFAC vmt data. + + This function combines vehicle type data with EMFAC vmt distribution data, + adjusting and normalizing probabilities to maintain consistent distributions from + both input sources. + + Args: + vehicle_types (pd.DataFrame): DataFrame of vehicle types with columns: + - vehicleTypeId: ID of vehicle type + - mappedClass: Vehicle class category in BEAM + - mappedFuel: Fuel type compatible with EMFAC categories + - income_bin: Income bin/range (e.g., '25-50') + - income_prop: Probability for this income group + - ridehail_prop: Ridehail probability + - sampleProbabilityWithinCategory: Probability within vehicle category + + car_emfac_fleet (pd.DataFrame): DataFrame of EMFAC vehicle population and vmt with columns: + - emfacId: ID of EMFAC vehicle type + - mappedClass: Vehicle class category in BEAM + - vehicle_class: Specific vehicle class (e.g., 'LD1', 'LD2') + - mappedFuel: Fuel type in EMFAC + - vmt_proportion: Proportion in the total vehicle vmt + + Returns: + pd.DataFrame: Merged dataframe with new columns: + - newId: Combined ID (emfacId--vehicleTypeId) + - vmt_normalized: Normalized vmt proportion + - newProportionIncome: Recalculated income proportion + - newProportionRidehail: Recalculated ridehail proportion + - sampleProbabilityString: Updated probability string + """ + df_merged = pd.merge( + left=vehicle_types, + right=car_emfac_fleet, + left_on=['mappedClass', 'mappedFuel'], + right_on=['mappedClass', 'mappedFuel'], + how='left' + ) + + # Calculate vehicle class probabilities given fuel type using groupby + vehicle_class_probs = {} + # Group by mappedClass and fuel to get distribution by vehicle_class + grouped = car_emfac_fleet.groupby(['mappedClass', 'mappedFuel']) + + for group_key, group_df in grouped: + mapped_class, mapped_fuel = group_key + if (mapped_class, mapped_fuel) not in vehicle_class_probs: + vehicle_class_probs[(mapped_class, mapped_fuel)] = {} + + # Calculate normalized probabilities for each vehicle class within the group + total_vmt = group_df['total_vmt'].sum() + for _, row in group_df.iterrows(): + vehicle_class_probs[(mapped_class, mapped_fuel)][row['vehicle_class']] = row['total_vmt'] / total_vmt + + # Apply the conditional probability formula to calculate new proportions + # Using a vectorized approach where possible + def get_vehicle_class_prob(row): + key = (row['mappedClass'], row['mappedFuel']) + vehicle_class = row['vehicle_class'] + return vehicle_class_probs.get(key, {}).get(vehicle_class, 0) + + # Calculate vehicle class probabilities for each row + df_merged['vehicle_class_prob'] = df_merged.apply(get_vehicle_class_prob, axis=1) + + # Calculate new proportions + if config["mapping"]["fleet"]["ignore_beam_passenger_distribution"]: + df_merged['sampleProbabilityWithinCategory'] = df_merged['total_vmt'] + df_merged['income_prop'] = df_merged['vehicle_class_prob'] + df_merged['ridehail_prop'] = df_merged['vehicle_class_prob'] + else: + if 'population' in df_merged.columns and df_merged['population'].sum() > 0: + total = df_merged['population'].sum() + df_merged["population_proportion"] = df_merged['population'] / total + df_merged['sampleProbabilityWithinCategory'] = df_merged['population_proportion'] * df_merged[ + 'vmt_normalized'] + df_merged['income_prop'] = df_merged['population_proportion'] * df_merged['vehicle_class_prob'] + df_merged['ridehail_prop'] = df_merged['population_proportion'] * df_merged['vehicle_class_prob'] + else: + df_merged['sampleProbabilityWithinCategory'] = df_merged['sampleProbabilityWithinCategory'] * df_merged[ + 'vmt_normalized'] + df_merged['income_prop'] = df_merged['income_prop'] * df_merged['vehicle_class_prob'] + df_merged['ridehail_prop'] = df_merged['ridehail_prop'] * df_merged['vehicle_class_prob'] + + # Normalize by income group using groupby + for income_group in df_merged['income_bin'].dropna().unique(): + mask = df_merged['income_bin'] == income_group + + # Normalize income proportions + income_sum = df_merged.loc[mask, 'income_prop'].sum() + if income_sum > 0: + df_merged.loc[mask, 'income_prop'] = df_merged.loc[mask, 'income_prop'] / income_sum + + for ridehail_group in df_merged['ridehail_bin'].dropna().unique(): + mask = df_merged['ridehail_bin'] == ridehail_group + + # Normalize ridehail proportions + ridehail_sum = df_merged.loc[mask, 'ridehail_prop'].sum() + if ridehail_sum > 0: + df_merged.loc[mask, 'ridehail_prop'] = df_merged.loc[mask, 'ridehail_prop'] / ridehail_sum + + # Recreate the sample probability string with updated values + # Note: The original code uses 'new_income_prob' but this variable isn't defined or created in the function + # Using 'income_prop' instead based on context + df_merged['sampleProbabilityString'] = df_merged.apply( + lambda row: create_sample_probability_string( + row['income_bin'], + row['income_prop'], # Changed from 'new_income_prob' which doesn't exist + row['ridehail_bin'], + row['ridehail_prop'] + ), + axis=1 + ) + + return df_merged + + +def create_atlas_emfac_crosswalk(car_emfac_fleet, work_dir, config): + """ + Create a crosswalk between EMFAC classes and bodytypes. + + Args: + car_emfac_fleet (pd.DataFrame): DataFrame containing EMFAC fleet + work_dir (str): Working directory path containing input files + config (dict): Configuration dictionary with data file paths and settings + + Returns: + pd.DataFrame: car_emfac with added bodytype and bodytype_prop columns, + and updated emfacId column combined with bodytype + """ + emfac_bodytype_df = pd.read_csv(os.path.join(work_dir, config["mapping"]["atlas"]["emfac"])) + result_rows = [] + for _, emfac_row in car_emfac_fleet.iterrows(): + emfac_class = emfac_row['vehicle_class'] + body_type_matches = [] + + for _, body_type_row in emfac_bodytype_df.iterrows(): + body_type = body_type_row['bodytype'].lower().capitalize() + if emfac_class in body_type_row.index and body_type_row[emfac_class] > 0: + proportion = body_type_row[emfac_class] + body_type_matches.append((body_type, proportion)) + + for body_type, proportion in body_type_matches: + new_row = emfac_row.copy() + new_row["bodytype"] = body_type + new_row["bodytype_prop"] = proportion + result_rows.append(new_row) + + # Create DataFrame from results + result_df = pd.DataFrame(result_rows) + result_df["pop"] = result_df["population"] * result_df["bodytype_prop"] + result_df["vmt"] = result_df["total_vmt"] * result_df["bodytype_prop"] + result_df["population"] = result_df["pop"] + result_df["total_vmt"] = result_df["vmt"] + total_population = result_df['population'].sum() + total_vmt = result_df['total_vmt'].sum() + if total_population > 0 and total_vmt > 0: + result_df["population_proportion"] = result_df['population'] / total_population + result_df["vmt_proportion"] = result_df['total_vmt'] / total_vmt + + car_emfac_fleet_with_bodytype = result_df[car_emfac_fleet.columns.tolist() + ["bodytype"]].copy() + return car_emfac_fleet_with_bodytype + + +def generate_emfac_mapped_passenger_vehicle_types(emfac_fleet, car_class, bike_class, transit_class, filter_out_classes, work_dir, config, format_func): + """ + Generate a passenger vehicle types with EMFAC mappings for different vehicle classes. + + This function processes vehicle types data and maps it to EMFAC vmt data for + cars, bikes, and transit vehicles. It creates a combined dataset that preserves the + distributions from both sources while mapping vehicle types to appropriate EMFAC categories. + + Args: + emfac_fleet (pd.DataFrame): EMFAC vmt and population data with vehicle classes and proportions + car_class (str): Identifier for car vehicle classes + bike_class (str): Identifier for bike vehicle classes + transit_class (str): Identifier for transit vehicle classes + filter_out_classes (list): classes to filter out, specifically freight classes + format_func (function): Function to format vehicle types data + work_dir (str): Working directory path + config (dict): Configuration dictionary with keys: + - beam.pax_vehicle_types_file: Path to vehicle types file + - mappedFuel: Fuel configuration parameters + + Returns: + pd.DataFrame: Combined and mapped passenger vehicle types with EMFAC IDs + """ + # Load vehicle types file + vehicle_types_file = os.path.join(work_dir, f"{config['beam']['pax_vehicle_types_file']}") + + # Read and filter vehicle types + vehicle_types_raw = pd.read_csv(vehicle_types_file, dtype=str) + vehicle_types_filtered = vehicle_types_raw[~vehicle_types_raw["vehicleCategory"].isin(filter_out_classes)] + + # Create masks for filtering + car_bike_mask = vehicle_types_filtered['vehicleCategory'].isin([car_class, bike_class]) + + # Fix the bus mask - original had a logical error using & instead of bitwise & + bus_mask = (vehicle_types_filtered['vehicleCategory'] == transit_class) & \ + (vehicle_types_filtered['vehicleTypeId'].str.lower().str.contains('bus')) + + # Format the filtered vehicle types + filtered_vehicle_types = vehicle_types_filtered.loc[car_bike_mask | bus_mask].copy() + vehicle_types = format_func(filtered_vehicle_types) + + # ################################################################################################### + # CAR + # ################################################################################################### + + # Process car data + car_emfac_fleet = emfac_fleet[emfac_fleet["mappedClass"].isin([car_class])].copy() + + # Process car data with probabilities + car_vehicle_types = vehicle_types[vehicle_types['mappedClass'].isin([car_class])].copy() + processed_car_types = process_vehicle_types_probabilities_by_vehicle_category_and_income_group(car_vehicle_types) + + if config["mapping"]["atlas"]["enable_atlas_emfac_crosswalk"]: + atlas_emfac_fleet = create_atlas_emfac_crosswalk(car_emfac_fleet, work_dir, config) + car_beam_emfac = emfac2passenger_with_atlas_crosswalk(processed_car_types, atlas_emfac_fleet, work_dir, config) + else: + car_beam_emfac = emfac2passenger_by_category_income(processed_car_types, car_emfac_fleet, config) + + # Select only necessary columns from the result + car_beam_emfac["oldVehicleTypeId"] = car_beam_emfac["vehicleTypeId"] + car_beam_emfac['vehicleTypeId'] = car_beam_emfac.apply( + lambda row: str( + row["emfacId"]) + "--" + + sanitize_name(row["bodytype"]).replace("_", "") + "--" + + sanitize_name(row["oldVehicleTypeId"]).replace("_", ""), axis=1 + ) + car_beam_emfac = car_beam_emfac[vehicle_types_filtered.columns.tolist() + ["emfacId", "oldVehicleTypeId"]] + + # ################################################################################################### + # BIKE + # ################################################################################################### + + # Process bike data + bike_emfac = emfac_fleet[emfac_fleet["mappedClass"].isin([bike_class])].copy() + bike_pop_sum = bike_emfac['total_vmt'].sum() + if bike_pop_sum > 0: + bike_emfac['vmt_normalized'] = bike_emfac['total_vmt'] / bike_pop_sum + else: + bike_emfac['vmt_normalized'] = 0.0 # Default value if no range + + # Merge bike data + bike_beam_emfac = pd.merge( + left=vehicle_types[vehicle_types['mappedClass'].isin([bike_class])], + right=bike_emfac, + left_on=['mappedClass', 'mappedFuel'], + right_on=['mappedClass', 'mappedFuel'], + how='outer' + ) + + # Calculate new proportion for bikes + # The original had a possible bug with 'prob_category' - changed to 'sampleProbabilityWithinCategory' + bike_beam_emfac['sampleProbabilityWithinCategory'] = bike_beam_emfac.apply( + lambda row: 1 if pd.isna(row['sampleProbabilityWithinCategory']) or + row['sampleProbabilityWithinCategory'] == '' + else float(row['sampleProbabilityWithinCategory']) * row['vmt_normalized'], + axis=1 + ) + + # Select bike columns + bike_beam_emfac = bike_beam_emfac[vehicle_types_filtered.columns.tolist() + ["emfacId"]] + bike_beam_emfac["oldVehicleTypeId"] = bike_beam_emfac["vehicleTypeId"] + bike_beam_emfac['vehicleTypeId'] = bike_beam_emfac.apply( + lambda row: str(row["emfacId"]) + "--" + sanitize_name(row["oldVehicleTypeId"]).replace("_", "") + , axis=1) + + # ################################################################################################### + # BUS + # ################################################################################################### + + # Process bus data + bus_emfac = emfac_fleet[emfac_fleet["mappedClass"] == transit_class].copy() + bus_pop_sum = bus_emfac['total_vmt'].sum() + if bus_pop_sum > 0: + bus_emfac['vmt_normalized'] = bus_emfac['total_vmt'] / bus_pop_sum + else: + bus_emfac['vmt_normalized'] = 0.0 # Default value if no range + + # Bus mask for filter - corrected syntax for filtering + bus_types_mask = (vehicle_types['mappedClass'] == transit_class) & \ + (vehicle_types['vehicleTypeId'].str.lower().str.contains('bus')) + + # Merge bus data - using the corrected mask + bus_beam_emfac_merged = pd.merge( + left=vehicle_types[bus_types_mask], + right=bus_emfac, + on=['mappedClass', 'mappedFuel'], + how='outer' + ) + + bus_beam_emfac = bus_beam_emfac_merged.groupby('vehicleTypeId').apply( + lambda x: x.sample(n=1, weights='vmt_normalized', replace=True) if len(x) > 0 else x + ).reset_index(drop=True) + + # Select bus columns + bus_beam_emfac = bus_beam_emfac[vehicle_types_filtered.columns.tolist() + ["emfacId"]] + bus_beam_emfac["oldVehicleTypeId"] = bus_beam_emfac["vehicleTypeId"] + + # Combine all vehicle types + result = pd.concat([car_beam_emfac, bike_beam_emfac, bus_beam_emfac], ignore_index=True) + processed_ids = result["oldVehicleTypeId"].unique() + vehicle_types_others = vehicle_types_filtered.loc[~(car_bike_mask | bus_mask)].copy() + vehicle_types_others = vehicle_types_others[~vehicle_types_others["vehicleTypeId"].isin(processed_ids)] + return result, vehicle_types_others + + +def generate_fleet_from_vehicle_types(mapped_vehicle_types, car_class, bike_class, work_dir, config): + """ + Update vehicle.csv file by sampling from new vehicle types based on original vehicleTypeId. + This highly optimized function uses vectorized operations and eliminates loops where possible. + + Args: + mapped_vehicle_types (pd.DataFrame): DataFrame containing mapped vehicle types + car_class (str): Identifier for car vehicle class + bike_class (str): Identifier for bike vehicle class + work_dir (str): Working directory path + config (dict): Configuration dictionary with beam.pax_vehicles_file key + + Returns: + pd.DataFrame: Updated vehicles DataFrame with new vehicleTypeIds and stateOfCharge values + """ + # Read the vehicle.csv file + vehicles_file_path = os.path.join(work_dir, config["beam"]["pax_vehicles_file"]) + vehicles_df = pd.read_csv(vehicles_file_path) + + # Create new columns in advance + vehicles_df['oldVehicleTypeId'] = vehicles_df['vehicleTypeId'] + vehicles_df['stateOfCharge'] = "" + + # Filter vehicle types to only cars and bikes (do this once) + car_bike_mask = mapped_vehicle_types['vehicleCategory'].isin([car_class, bike_class]) + filtered_vehicle_types = mapped_vehicle_types.loc[car_bike_mask].copy() + + # Ensure sampleProbabilityWithinCategory is numeric (do this once) + filtered_vehicle_types['sampleProbabilityWithinCategory'] = pd.to_numeric( + filtered_vehicle_types['sampleProbabilityWithinCategory'], errors='coerce' + ).fillna(0) + + # Pre-process and organize vehicle types by category + vehicle_types_by_category = { + car_class: filtered_vehicle_types[filtered_vehicle_types['vehicleCategory'] == car_class], + bike_class: filtered_vehicle_types[filtered_vehicle_types['vehicleCategory'] == bike_class] + } + + # Pre-process and organize vehicle types by original type (if oldVehicleTypeId exists) + vehicle_types_by_original = {} + if 'oldVehicleTypeId' in filtered_vehicle_types.columns: + for orig_id in filtered_vehicle_types['oldVehicleTypeId'].unique(): + if pd.notna(orig_id) and orig_id: + matches = filtered_vehicle_types[filtered_vehicle_types['oldVehicleTypeId'] == orig_id] + if len(matches) > 0: + weights = matches['sampleProbabilityWithinCategory'].values + weights_sum = np.sum(weights) + if weights_sum > 0: + weights = weights / weights_sum + vehicle_types_by_original[str(orig_id)] = (matches, weights) + + # Create lookup table of original type IDs to categories + unique_vehicle_types = vehicles_df['vehicleTypeId'].unique() + vehicle_categories = {} + for vtype in unique_vehicle_types: + vtype_str = str(vtype) + if 'BIKE' in vtype_str.upper(): + vehicle_categories[vtype_str] = bike_class + else: + vehicle_categories[vtype_str] = car_class + + # Process in larger batches for better performance + batch_size = 10000 # Increased batch size + total_vehicles = len(vehicles_df) + num_batches = (total_vehicles + batch_size - 1) // batch_size + + with tqdm(total=total_vehicles, desc="Processing vehicles") as pbar: + for batch_idx in range(num_batches): + start_idx = batch_idx * batch_size + end_idx = min(start_idx + batch_size, total_vehicles) + batch = vehicles_df.iloc[start_idx:end_idx] + + # Create arrays to hold new values + new_vehicle_type_ids = [] + states_of_charge = [] + + # Group vehicles by original type to process in chunks + for original_type_id, group_indices in batch.groupby('vehicleTypeId').groups.items(): + original_type_id_str = str(original_type_id) + group_size = len(group_indices) + + # Get matching vehicle types for this original type + if original_type_id_str in vehicle_types_by_original: + matches, weights = vehicle_types_by_original[original_type_id_str] + else: + # If no direct match, use vehicle category + category = vehicle_categories[original_type_id_str] + matches = vehicle_types_by_category[category] + weights = matches['sampleProbabilityWithinCategory'].values + weights_sum = np.sum(weights) + if weights_sum > 0: + weights = weights / weights_sum + # Cache for future use + vehicle_types_by_original[original_type_id_str] = (matches, weights) + + # Sample vehicle types for the entire group at once + if len(matches) > 0: + if np.sum(weights) > 0: + sampled_indices = np.random.choice( + len(matches), size=group_size, p=weights, replace=True + ) + else: + sampled_indices = np.random.randint(0, len(matches), size=group_size) + + # Get sampled vehicle types and fuel types + sampled_vehicles = matches.iloc[sampled_indices] + sampled_types = sampled_vehicles['vehicleTypeId'].values + is_electric = sampled_vehicles['primaryFuelType'].str.lower().str.contains('electricity', + na=False).values + + # Assign to ordered arrays + for i, idx in enumerate(group_indices): + # No need to calculate idx_in_batch since we're using arrays and appending + new_vehicle_type_ids.append(sampled_types[i]) + states_of_charge.append('1' if is_electric[i] else '') + else: + # Fallback if no matches (should rarely happen) + for _ in range(group_size): + new_vehicle_type_ids.append(original_type_id) + states_of_charge.append('') + + # Bulk update the batch + vehicles_df.loc[start_idx:end_idx - 1, 'vehicleTypeId'] = new_vehicle_type_ids + vehicles_df.loc[start_idx:end_idx - 1, 'stateOfCharge'] = states_of_charge + + pbar.update(end_idx - start_idx) + + return vehicles_df \ No newline at end of file diff --git a/src/main/python/emissions/emfac_data_processing.py b/src/main/python/emissions/emfac_data_processing.py deleted file mode 100644 index c259e31d7b6..00000000000 --- a/src/main/python/emissions/emfac_data_processing.py +++ /dev/null @@ -1,83 +0,0 @@ -from emissions_utils import * -import geopandas as gpd -import matplotlib.pyplot as plt - -emfac_regions = ["SF"] -model_dir = os.path.abspath(os.path.expanduser('~/Workspace/Models/emfac/2018')) -work_dir = os.path.abspath(os.path.expanduser("~/Workspace/Simulation/sfbay")) -run_dir = work_dir + "/beam-freight/2024-01-23/Baseline" - - -# ## Population ## -statewide_pop_file = model_dir + '/Default_Statewide_2018_Annual_fleet_data_population_20240311153419.csv' - -# Load the dataset from the uploaded CSV file -emfac_pop = prepare_emfac_emissions_for_mapping(statewide_pop_file, emfac_regions) - -# ## TRIPS ## -statewide_trips_filename = model_dir + '/Default_Statewide_2018_Annual_fleet_data_trips_20240311153419.csv' - -########################################### -# ## EMISSIONS RATES ## -# pd.set_option('display.max_columns', 20) -########################################### -regional_emfac_data_file = model_dir + '/imputed_MTC_emission_rate_agg_NH3_added.csv' - - -########################################### -# ## FRISM PLANS ## -########################################### -# freight_carriers = pd.read_csv("~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/freight-carriers.csv") -# freight_payloads = pd.read_csv("~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/freight-payload-plans.csv") -# freight_tours = pd.read_csv("~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/freight-tours.csv") -# -# # Plot the histogram for the 'Values' column -# freight_payloads['sequenceRank'].plot(kind='hist', bins=20, edgecolor='black') -# plt.title('Histogram of sequenceRank') -# plt.xlabel('Value') -# plt.ylabel('Frequency') -# plt.savefig(os.path.expanduser('~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/histogram_sequenceRank.png'), dpi=300, bbox_inches='tight') -# plt.clf() -# -# -# freight_payloads['operationDurationInSec'].plot(kind='hist', bins=20, edgecolor='black') -# plt.title('Histogram of operationDurationInSec') -# plt.xlabel('Value') -# plt.ylabel('Frequency') -# plt.savefig(os.path.expanduser('~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/histogram_operationDurationInSec.png'), dpi=300, bbox_inches='tight') -# plt.clf() -# -# freight_payloads['weightInKg'].plot(kind='hist', bins=20, edgecolor='black') -# plt.title('Histogram of weightInKg') -# plt.xlabel('Value') -# plt.ylabel('Frequency') -# plt.savefig(os.path.expanduser('~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/histogram_weightInKg.png'), dpi=300, bbox_inches='tight') -# plt.clf() -# -# freight_payloads['arrivalTimeWindowInSecUpper'].plot(kind='hist', bins=20, edgecolor='black') -# plt.title('Histogram of arrivalTimeWindowInSecUpper') -# plt.xlabel('Value') -# plt.ylabel('Frequency') -# plt.savefig(os.path.expanduser('~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/histogram_arrivalTimeWindowInSecUpper.png'), dpi=300, bbox_inches='tight') -# plt.clf() -# -# freight_payloads['estimatedTimeOfArrivalInSec'].plot(kind='hist', bins=20, edgecolor='black') -# plt.title('Histogram of estimatedTimeOfArrivalInSec') -# plt.xlabel('Value') -# plt.ylabel('Frequency') -# plt.savefig(os.path.expanduser('~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/histogram_estimatedTimeOfArrivalInSec.png'), dpi=300, bbox_inches='tight') -# plt.clf() -# -# freight_payloads['arrivalTimeWindowInSecLower'].plot(kind='hist', bins=20, edgecolor='black') -# plt.title('Histogram of arrivalTimeWindowInSecUpper') -# plt.xlabel('Value') -# plt.ylabel('Frequency') -# plt.savefig(os.path.expanduser('~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/histogram_arrivalTimeWindowInSecLower.png'), dpi=300, bbox_inches='tight') -# plt.clf() -# -# freight_tours['departureTimeInSec'].plot(kind='hist', bins=20, edgecolor='black') -# plt.title('Histogram of departureTimeInSec') -# plt.xlabel('Value') -# plt.ylabel('Frequency') -# plt.savefig(os.path.expanduser('~/Workspace/Data/FREIGHT/sfbay/beam_freight/scenarios-23Jan2024/Base/histogram_departureTimeInSec.png'), dpi=300, bbox_inches='tight') -# plt.clf() diff --git a/src/main/python/emissions/emfac_mapping_of_vehicle_population.py b/src/main/python/emissions/emfac_mapping_of_vehicle_population.py deleted file mode 100644 index b724c2fd047..00000000000 --- a/src/main/python/emissions/emfac_mapping_of_vehicle_population.py +++ /dev/null @@ -1,272 +0,0 @@ -from emissions_utils import * -pd.set_option('display.max_columns', 20) - -# HEADER -# ### File Paths ### -# mesozones_lookup_file = os.path.expanduser("~/Workspace/Simulation/sfbay/geo/zonal_id_lookup_final.csv") -# county_data_file = os.path.expanduser("~/Workspace/Simulation/sfbay/geo/sfbay_counties_wgs84.geojson") -# cbg_data_file = os.path.expanduser("~/Workspace/Simulation/sfbay/geo/sfbay_cbgs_wgs84.geojson") -# taz_data_file = os.path.expanduser("~/Workspace/Simulation/sfbay/geo/sfbay_tazs_epsg26910.geojson") -# mesozones_to_county_file = os.path.expanduser("~/Workspace/Simulation/sfbay/geo/mesozones_to_county.csv") -emfac_population_file = os.path.expanduser('~/Workspace/Models/emfac/Default_Statewide_2018_2025_2030_2040_2050_Annual_population_20240612233346.csv') -emfac_emissions_file = os.path.expanduser('~/Workspace/Models/emfac/imputed_MTC_emission_rate_agg_NH3_added_2018_2025_2030_2040_2050.csv') - -runFT = True # Run Freight Emissions Mapping -runPAX = False # Run Passenger Emissions Mapping -ft_iteration = "2024-01-23" -area = "sfbay" -## -# emfac_year, ft_year, ft_scenario, pax_year, pax_scenario = 2050, 2050, "HOPhighp2", 2045, "LowTech" -# emfac_year, ft_year, ft_scenario, pax_year, pax_scenario = 2018, 2018, "Baseline", 2018, "Baseline" -# emfac_year, ft_year, ft_scenario, pax_year, pax_scenario = 2050, 2050, "Refhighp6", 2045, "LowTech" -emfac_year, ft_year, ft_scenario, pax_year, pax_scenario = 2050, 2050, "HOPhighp6", 2045, "LowTech" -## -input_dir = os.path.expanduser(f"~/Workspace/Simulation/{area}/beam-freight/{ft_iteration}") -carriers_file = f"{input_dir}/{str(ft_year)}_{ft_scenario}/carriers--{str(ft_year)}-{ft_scenario}.csv" -payloads_file = f"{input_dir}/{str(ft_year)}_{ft_scenario}/payloads--{str(ft_year)}-{ft_scenario}.csv" -ft_vehicle_types_file = f"{input_dir}/vehicle-tech/ft-vehicletypes--{str(ft_year)}-{ft_scenario}.csv" -pax_vehicle_types_file = f"{input_dir}/vehicle-tech/pax-vehicletypes--{str(pax_year)}-{pax_scenario}.csv" - -# ################## - -# output -ft_filtered_out_emissions_file = f"{input_dir}/vehicle-tech/ft-filtered-out--{str(ft_year)}-{ft_scenario}-TrAP.csv" -ft_vehicle_types_emissions_file = f"{input_dir}/vehicle-tech/ft-vehicletypes--{str(ft_year)}-{ft_scenario}-TrAP.csv" -ft_carriers_emissions_file = f"{input_dir}/{str(ft_year)}_{ft_scenario}/carriers--{str(ft_year)}-{ft_scenario}-TrAP.csv" -ft_emissions_rates_relative_filepath = f"TrAP/{str(ft_year)}-FT-{ft_scenario}" - -pax_filtered_out_emissions_file = f"{input_dir}/vehicle-tech/pax-filtered-out-TrAP.csv" -pax_vehicle_types_emissions_file = f"{input_dir}/vehicle-tech/pax-vehicletypes--{str(pax_year)}-{pax_scenario}-TrAP.csv" -pax_emissions_rates_relative_filepath = f"TrAP/{str(pax_year)}-Pax-{pax_scenario}" - -# combine_csv_files( -# [ -# os.path.expanduser('~/Workspace/Models/emfac/imputed_MTC_emission_rate_agg_NH3_added_2018.csv'), -# os.path.expanduser('~/Workspace/Models/emfac/imputed_MTC_emission_rate_agg_NH3_added_2025.csv'), -# os.path.expanduser('~/Workspace/Models/emfac/imputed_MTC_emission_rate_agg_NH3_added_2030.csv'), -# os.path.expanduser('~/Workspace/Models/emfac/imputed_MTC_emission_rate_agg_NH3_added_2040.csv'), -# os.path.expanduser('~/Workspace/Models/emfac/imputed_MTC_emission_rate_agg_NH3_added_2050.csv') -# ] -# , emfac_emissions_file) -# - -ft_fuel_mapping_assumptions = { - 'Dsl': 'Diesel', - 'Gas': 'Diesel', - 'NG': 'Diesel', - 'Elec': 'Electricity', - 'Phe': 'PlugInHybridElectricity', - 'H2fc': 'Electricity' -} -# -pax_fuel_mapping_assumptions = { - 'Dsl': 'Diesel', - 'Gas': 'Gasoline', - 'NG': 'Diesel', - 'Elec': 'Electricity', - 'Phe': 'PlugInHybridElectricity', - 'H2fc': 'Electricity', - 'BioDsl': 'Diesel' -} - - - - -# ######### MAIN ########## - -print(f"Scenario {area}, {str(ft_year)}-{ft_scenario} from {ft_iteration}..") -# all the readings: -ft_payloads = pd.read_csv(payloads_file) -ft_vehicle_types = pd.read_csv(ft_vehicle_types_file) -pax_vehicle_types = pd.read_csv(pax_vehicle_types_file) -ft_carriers = pd.read_csv(carriers_file, dtype=str) - -# ['Dsl', 'Elec', 'Gas', 'Phe', 'NG'] -print("Processing emfac population and rates") -emfac_population = pd.read_csv(emfac_population_file, low_memory=False, dtype=str) -emfac_population['population'] = pd.to_numeric(emfac_population['population'], errors='coerce') -pax_emfac_class_map, ft_emfac_class_map = create_vehicle_class_mapping(emfac_population["vehicle_class"].unique()) - - -emissions_rates = pd.read_csv(emfac_emissions_file, low_memory=False, dtype={ - 'calendar_year': int, - 'season_month': str, - 'sub_area': str, - 'vehicle_class': str, - 'fuel': str, - 'temperature': float, - 'relative_humidity': float, - 'process': str, - 'speed_time': float, - 'pollutant': str, - 'emission_rate': float -}) -filtered_rates = emissions_rates[ - emissions_rates["sub_area"].str.contains(fr"\({re.escape(region_to_emfac_area[area])}\)", case=False, na=False) & - (emissions_rates["calendar_year"] == emfac_year) - ] - - -# ### PASSENGER ### -if runPAX: - print("\nMapping EMFAC for passengers!") - # EMFAC Rates - pax_emissions_rates_for_mapping = prepare_emfac_emissions_for_mapping( - filtered_rates, - pax_emfac_class_map - ) - print(f"EMFAC Passenger Rates => rows: {len(pax_emissions_rates_for_mapping)}, " - f"classes: {len(pax_emissions_rates_for_mapping['emfacClass'].unique())}, " - f"fuel: {len(pax_emissions_rates_for_mapping['emfacFuel'].unique())}") - - # EMFAC Population - emfac_passenger_population_for_mapping = prepare_emfac_population_for_mapping( - emfac_population, - emfac_year, - pax_emfac_class_map, - pax_fuel_mapping_assumptions - ) - print(f"EMFAC Passenger Population => rows: {len(emfac_passenger_population_for_mapping)}, " - f"classes: {len(emfac_passenger_population_for_mapping['emfacClass'].unique())}, " - f"fuel: {len(emfac_passenger_population_for_mapping['emfacFuel'].unique())}") - - # Passenger Population - pax_population_for_mapping = prepare_pax_vehicle_population_for_mapping( - pax_vehicle_types, - pax_fuel_mapping_assumptions - ) - print(f"BEAM Passenger Population => rows: {len(pax_population_for_mapping)}, " - f"classes: {len(pax_population_for_mapping['beamClass'].unique())}, " - f"fuel: {len(pax_population_for_mapping['beamFuel'].unique())}") - - print("------------------------------------------------------------------") - print("Distributing passenger vehicle classes from EMFAC across BEAM population...") - updated_passenger_vehicle_types = build_new_pax_vehtypes( - emfac_passenger_population_for_mapping, - pax_population_for_mapping - ) - print(f"Previous vehicle types had {len(pax_population_for_mapping)} types " - f"while the new set has {len(updated_passenger_vehicle_types)} types") - - print("------------------------------------------------------------------") - print("Formatting Passenger EMFAC rates for BEAM") - pax_emfac_formatted, pax_emfac_filtered_out = format_rates_for_beam(pax_emissions_rates_for_mapping) - pax_emfac_filtered_out.to_csv(pax_filtered_out_emissions_file) - print(f"Filtered out passenger processes with all zeros emissions, verify output here => {pax_filtered_out_emissions_file}") - - print("------------------------------------------------------------------") - print("Assigning Passenger emissions rates to new set of vehicle types") - pax_vehicle_types_with_emissions_rates = assign_emissions_rates_to_vehtypes( - pax_emfac_formatted, - updated_passenger_vehicle_types, - input_dir + "/vehicle-tech", - pax_emissions_rates_relative_filepath - ) - - # Create a new dataframe with the missing rows - print("------------------------------------------------------------------") - print("Adding back Passenger vehicle types not mapped with EMFAC") - index_population = set(pax_population_for_mapping.index) - index_vehicle_types = set(pax_vehicle_types.index) - missing_rows = index_vehicle_types - index_population - missing_df = pax_vehicle_types.loc[list(missing_rows)] - missing_df["emissionsRatesFile"] = "" - pax_emfac_vehicletypes = pd.concat([pax_vehicle_types_with_emissions_rates[missing_df.columns], missing_df], axis=0) - pax_emfac_vehicletypes.to_csv(pax_vehicle_types_emissions_file, index=False) - - print("Done mapping EMFAC for passengers!") - - -# ************** -# FREIGHT -# ************** -if runFT: - print("\nMapping EMFAC for freight!") - # EMFAC Rates - ft_emissions_rates_for_mapping = prepare_emfac_emissions_for_mapping( - filtered_rates, - ft_emfac_class_map - ) - print(f"EMFAC Freight Rates => rows: {len(ft_emissions_rates_for_mapping)}, " - f"classes: {len(ft_emissions_rates_for_mapping['emfacClass'].unique())}, " - f"fuel: {len(ft_emissions_rates_for_mapping['emfacFuel'].unique())}") - - ft_emfac_pop_for_mapping = prepare_emfac_population_for_mapping( - emfac_population, - emfac_year, - ft_emfac_class_map, - ft_fuel_mapping_assumptions - ) - print(f"EMFAC Freight Population => rows: {len(ft_emfac_pop_for_mapping)}, " - f"classes: {len(ft_emfac_pop_for_mapping['emfacClass'].unique())}, " - f"fuel: {len(ft_emfac_pop_for_mapping['emfacFuel'].unique())}") - - # - ft_population_for_mapping = prepare_ft_vehicle_population_for_mapping( - ft_carriers, - ft_payloads, - ft_vehicle_types, - ft_fuel_mapping_assumptions - ) - print(f"BEAM Freight Population => rows: {len(ft_population_for_mapping)}, " - f"classes: {len(ft_population_for_mapping['beamClass'].unique())}, " - f"fuel: {len(ft_population_for_mapping['beamFuel'].unique())}") - unique_vehicles = set(ft_carriers["vehicleId"].unique()) - set(ft_population_for_mapping["vehicleId"].unique()) - if len(unique_vehicles) > 0: - print(f"Failed to map, maybe some vehicles in carriers were not used in payload plans:") - print(unique_vehicles) - - - ### - print("------------------------------------------------------------------") - print("Distributing freight vehicle classes from EMFAC across BEAM population...") - updated_freight_population = distribution_based_vehicle_classes_assignment( - ft_population_for_mapping, - ft_emfac_pop_for_mapping - ) - missing_classes = set(ft_emfac_pop_for_mapping['emfacClass'].unique()) - set(updated_freight_population['emfacClass'].unique()) - missing_fuel = set(ft_emfac_pop_for_mapping['emfacFuel'].unique()) - set(updated_freight_population['emfacFuel'].unique()) - if len(missing_classes) > 0 or len(missing_fuel) > 0: - print(f"Failed to match these classes {missing_classes} and fuel {missing_fuel}") - - - ### - print("------------------------------------------------------------------") - print("Building new set of freight vehicle types") - updated_vehicle_types = build_new_ft_vehtypes(updated_freight_population, ft_vehicle_types) - print(f"Previous vehicle types had {len(ft_vehicle_types)} types while the new set has {len(updated_vehicle_types)} types") - ### - print("------------------------------------------------------------------") - print("Assigning new freight vehicle types to carriers") - updated_carriers = assign_new_ft_vehtypes_to_carriers(ft_carriers, updated_freight_population, ft_carriers_emissions_file) - unique_vehicles = set(ft_carriers["vehicleId"].unique()) - set(updated_carriers["vehicleId"].unique()) - if len(unique_vehicles) > 0: - print(f"Failed to assign vehicle types to these vehicles: {unique_vehicles}") - - - ### - print("------------------------------------------------------------------") - print("Formatting EMFAC freight rates for BEAM") - ft_emfac_formatted, ft_emfac_filtered_out = format_rates_for_beam(ft_emissions_rates_for_mapping) - ft_emfac_filtered_out.to_csv(ft_filtered_out_emissions_file) - print(f"Filtered out freight processes with all zeros emissions, verify output here => {ft_filtered_out_emissions_file}") - - ### - print("------------------------------------------------------------------") - print("Assigning freight emissions rates to new set of vehicle types") - ft_vehicle_types_with_emissions_rates = assign_emissions_rates_to_vehtypes( - ft_emfac_formatted, - updated_vehicle_types, - input_dir + "/vehicle-tech", - ft_emissions_rates_relative_filepath - ) - - print("------------------------------------------------------------------") - unique_ft_vehicle_types = set(updated_vehicle_types["vehicleTypeId"].unique()) - set(ft_vehicle_types_with_emissions_rates["vehicleTypeId"].unique()) - if len(unique_ft_vehicle_types) > 0: - print(f"Failed to assign emissions rates to these vehicle types: {unique_ft_vehicle_types}") - - print(f"Writing {ft_vehicle_types_emissions_file}") - updated_vehicle_types.to_csv(ft_vehicle_types_emissions_file, index=False) - -print("End") diff --git a/src/main/python/emissions/emissions_skims_processing.py b/src/main/python/emissions/emissions_skims_processing.py deleted file mode 100644 index d8bbbdea0f8..00000000000 --- a/src/main/python/emissions/emissions_skims_processing.py +++ /dev/null @@ -1,190 +0,0 @@ -from emissions_utils import * -from pathlib import Path -pd.set_option('display.max_columns', 20) - - -# ################ -# #### Header #### -# ################ - -# Input -area = "sfbay" -batch = "2024-01-23" -mode_to_filter = "-TRUCK-" -expansion_factor = 1/0.1 -source_epsg = "EPSG:26910" -selected_pollutants = ['PM2_5', 'NOx', 'CO', 'ROG', 'CO2', 'HC'] -h3_resolution = 8 # Adjust as needed -emfac_vmt_file = os.path.expanduser(f"~/Workspace/Models/emfac/Default_Statewide_2018_2025_2030_2040_2050_Annual_vmt_20240612233346.csv") -run_dir = os.path.expanduser(f"~/Workspace/Simulation/{area}/beam-runs/{batch}") -scenario_2018 = "2018_Baseline" -scenario_2050 = "2050_Refhighp6" -skims_2018_file = f"{run_dir}/{scenario_2018}/0.skimsEmissions.csv.gz" -skims_2050_file = f"{run_dir}/{scenario_2050}/0.skimsEmissions.csv.gz" -network_file = f"{run_dir}/network.csv.gz" -plan_dir = os.path.expanduser(f"~/Workspace/Simulation/{area}/beam-freight/{batch}") -types_2018_file = f"{plan_dir}/vehicle-tech/ft-vehicletypes--{scenario_2018.replace('_', '-')}-TrAP.csv" -types_2050_file = f"{plan_dir}/vehicle-tech/ft-vehicletypes--{scenario_2050.replace('_', '-')}-TrAP.csv" -tours_2018_file = f"{plan_dir}/{scenario_2018}/tours--{scenario_2018.replace('_', '-')}.csv" -tours_2050_file = f"{plan_dir}/{scenario_2050}/tours--{scenario_2050.replace('_', '-')}.csv" -carriers_2018_file = f"{plan_dir}/{scenario_2018}/carriers--{scenario_2018.replace('_', '-')}-TrAP.csv" -carriers_2050_file = f"{plan_dir}/{scenario_2050}/carriers--{scenario_2050.replace('_', '-')}-TrAP.csv" - -# Output -plot_dir = f'{run_dir}/_plots' -Path(plot_dir).mkdir(parents=True, exist_ok=True) - -# ################ -# ##### Main ##### -# ################ - -scenario_2018_label = scenario_2018.replace("_", " ") -scenario_2050_label = scenario_2050.replace("_", " ").replace("HOPhighp2", "HAVF") - -# Network -network = load_network(network_file, source_epsg) -network_h3_intersection = generate_h3_intersections(network, h3_resolution, run_dir) -network_h3_intersection.to_csv(f'{run_dir}/network.h3.csv', index=False) - -# Skims -skims_2018 = read_skims_emissions_chunked( - skims_2018_file, - types_2018_file, - mode_to_filter, - network, - expansion_factor, - scenario_2018_label -) -skims_2050 = read_skims_emissions_chunked( - skims_2050_file, - types_2050_file, - mode_to_filter, - network, - expansion_factor, - scenario_2050_label -) -skims = pd.concat([skims_2018, skims_2050]) -print(f"Read {len(skims)} rows of skims") -# fast_df_to_gzip(skims, f'{run_dir}/skims_{scenario_2018}_{scenario_2050}.csv.gz') - -# FAMOS Tours -tours_2018 = pd.read_csv(tours_2018_file)[["tourId", 'departureTimeInSec']] -tours_2050 = pd.read_csv(tours_2050_file)[["tourId", 'departureTimeInSec']] -carriers_2018 = pd.read_csv(carriers_2018_file)[["tourId", 'vehicleTypeId']] -carriers_2050 = pd.read_csv(carriers_2050_file)[["tourId", 'vehicleTypeId']] -types_2018 = pd.read_csv(types_2018_file)[["vehicleTypeId", 'vehicleCategory', 'primaryFuelType', 'secondaryFuelType']] -types_2050 = pd.read_csv(types_2050_file)[["vehicleTypeId", 'vehicleCategory', 'primaryFuelType', 'secondaryFuelType']] - -tours_types_2018 = pd.merge(tours_2018, pd.merge(carriers_2018, types_2018, on="vehicleTypeId"), on="tourId") -tours_types_2018["scenario"] = scenario_2018_label -tours_types_2050 = pd.merge(tours_2050, pd.merge(carriers_2050, types_2050, on="vehicleTypeId"), on="tourId") -tours_types_2050["scenario"] = scenario_2050_label -famos_tours = pd.concat([tours_types_2018, tours_types_2050]) - -# FAMOS VMT -# Group by scenario, hour, and fuel_class, sum annualHourlyMVMT -famos_vmt = skims.groupby(['scenario', 'hour', 'beamFuel', 'class'])['vmt'].sum().reset_index().copy() - -# EMFAC VMT -emfac_famos_vmt = create_model_vmt_comparison_chart( - emfac_vmt_file, area, 2050, skims, scenario_2050_label, plot_dir -) - -# Processes -driving_process_activity = skims[ - (skims["process"].isin(["RUNEX", "PMBW", "PMTW", "RUNLOSS"])) & - (skims["vht"] > 0) -].groupby(["scenario", "linkId"])["vmt"].sum().reset_index(name="vmt") -h3_vmt = process_h3_data(network_h3_intersection, driving_process_activity, "vmt") -vmt_column = "Weighted VMT from driving activities" -h3_vmt.rename(columns={"weighted_vmt": vmt_column}, inplace=True) - -parking_process_activity = skims[ - (skims["process"].isin(["STREX", "DIURN", "HOTSOAK", "RUNLOSS", "IDLEX"])) & - (skims["vht"] == 0) -].groupby(["scenario", "linkId"]).size().reset_index(name='count') -h3_count = process_h3_data(network_h3_intersection, parking_process_activity, "count") -count_column = "Weighted count of parking activities" -h3_count.rename(columns={"weighted_count": count_column}, inplace=True) - -# Emissions -pm25 = process_h3_emissions(skims, network_h3_intersection, 'PM2_5') -nox = process_h3_emissions(skims, network_h3_intersection, 'NOx') -co = process_h3_emissions(skims, network_h3_intersection, 'CO') -co2 = process_h3_emissions(skims, network_h3_intersection, 'CO2') -# -pm25_column = "PM2_5 in grams per square meter" -pm25[pm25_column] = pm25["PM2_5"] * 1e6 # from metric ton to gram -# -nox_column = "NOx in grams per square meter" -nox[nox_column] = nox["NOx"] * 1e6 # from metric ton to gram -# -co_column = "CO in grams per square meter" -co[co_column] = co["CO"] * 1e6 # from metric ton to gram -# -co2_column = "CO2 in grams per square meter" -co2[co2_column] = co2["CO2"] * 1e6 # from metric ton to gram - -# Delta Emissions -pm25_delta = pm25.pivot(index='h3_cell', columns='scenario', values='PM2_5').reset_index() -pm25_delta = pm25_delta.fillna(0) -pm25_delta["scenario"] = "-".join([scenario_2050_label, scenario_2018_label]) -pm25_delta['Delta_PM2_5'] = pm25_delta[scenario_2050_label] - pm25_delta[scenario_2018_label] -pm25_delta_column = "Delta PM2_5 in grams per square meter" -pm25_delta[pm25_delta_column] = pm25_delta["Delta_PM2_5"] * 1e6 # from metric ton to gram -# -nox_delta = nox.pivot(index='h3_cell', columns='scenario', values='NOx').reset_index() -nox_delta = nox_delta.fillna(0) -nox_delta["scenario"] = "-".join([scenario_2050_label, scenario_2018_label]) -nox_delta['Delta_NOx'] = nox_delta[scenario_2050_label] - nox_delta[scenario_2018_label] -nox_delta_column = "Delta NOx in grams per square meter" -nox_delta[nox_delta_column] = nox_delta["Delta_NOx"] * 1e6 # from metric ton to gram -# -co2_delta = co2.pivot(index='h3_cell', columns='scenario', values='CO2').reset_index() -co2_delta = co2_delta.fillna(0) -co2_delta["scenario"] = "-".join([scenario_2050_label, scenario_2018_label]) -co2_delta['Delta_CO2'] = co2_delta[scenario_2050_label] - co2_delta[scenario_2018_label] -co2_delta_column = "Delta CO2 in grams per square meter" -co2_delta[co2_delta_column] = co2_delta["Delta_CO2"] * 1e6 # from metric ton to gram - - - -# ################ -# ### Plotting ### -# ################ -# Figure 1 -plot_hourly_activity(famos_tours, plot_dir, height_size=6) -plot_hourly_vmt(famos_vmt, plot_dir, height_size=6) -# Figure 2 -plot_multi_pie_emfac_famos_vmt(emfac_famos_vmt, plot_dir) -# Figure 3 -plot_h3_heatmap(h3_vmt, vmt_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, in_log_scale=True) -plot_h3_heatmap(h3_count, count_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, in_log_scale=True) -# Figure 4 -plot_h3_heatmap(pm25, pm25_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, in_log_scale=True) -plot_h3_heatmap(nox, nox_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, in_log_scale=True) -# plot_h3_heatmap(co, co_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, in_log_scale=True) -plot_h3_heatmap(co2, co2_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, in_log_scale=True) -# Figure 5 -plot_hourly_emissions_by_scenario_class_fuel(skims, 'PM2_5', plot_dir, plot_legend=True, height_size=6, font_size=24) -plot_hourly_emissions_by_scenario_class_fuel(skims, 'NOx', plot_dir, plot_legend=True, height_size=6, font_size=24) -#plot_hourly_emissions_by_scenario_class_fuel(skims, 'CO', plot_dir, plot_legend=True, height_size=6, font_size=24) -#plot_hourly_emissions_by_scenario_class_fuel(skims, 'SOx', plot_dir, plot_legend=True, height_size=6, font_size=24) -#plot_hourly_emissions_by_scenario_class_fuel(skims, 'NOx', plot_dir, plot_legend=False, height_size=11, font_size=30) -plot_hourly_emissions_by_scenario_class_fuel(skims, 'CO2', plot_dir, plot_legend=True, height_size=6, font_size=24) -# Figure 6 -plot_h3_heatmap(pm25_delta, pm25_delta_column, "-".join([scenario_2050_label, scenario_2018_label]), plot_dir, is_delta=True, remove_outliers=True, in_log_scale=True) -plot_h3_heatmap(nox_delta, nox_delta_column, "-".join([scenario_2050_label, scenario_2018_label]), plot_dir, is_delta=True, remove_outliers=True, in_log_scale=True) -plot_h3_heatmap(co2_delta, co2_delta_column, "-".join([scenario_2050_label, scenario_2018_label]), plot_dir, is_delta=True, remove_outliers=True, in_log_scale=True) -# Figure 7 - -plot_pollution_variability_by_process_vehicle_types(skims, "PM2_5", scenario_2018_label, plot_dir, height_size=6, font_size=24) -plot_pollution_variability_by_process_vehicle_types(skims, "NOx", scenario_2018_label, plot_dir, height_size=6, font_size=24) -#plot_pollution_variability_by_process_vehicle_types(skims, "CO", scenario_2018_label, plot_dir, height_size=6, font_size=24) -#plot_pollution_variability_by_process_vehicle_types(skims, "SOx", scenario_2018_label, plot_dir, height_size=6, font_size=24) -plot_pollution_variability_by_process_vehicle_types(skims, "CO2", scenario_2018_label, plot_dir, height_size=6, font_size=24) - -plot_pollutants_by_process(skims, scenario_2018_label, plot_dir, height_size=6, font_size=24) -plot_pollutants_by_process(skims, scenario_2050_label, plot_dir, height_size=6, font_size=24) - -print("End.") diff --git a/src/main/python/emissions/emissions_utils.py b/src/main/python/emissions/emissions_utils.py deleted file mode 100644 index 04dec08a1c2..00000000000 --- a/src/main/python/emissions/emissions_utils.py +++ /dev/null @@ -1,1761 +0,0 @@ -import pandas as pd -import numpy as np -import pyarrow as pa -import pyarrow.csv as pv -import pyarrow.compute as pc -import matplotlib.pyplot as plt -import matplotlib.colors as mcolors -import matplotlib.colors as colors -import matplotlib.patches as patches -import geopandas as gpd -from matplotlib import colors -from pyproj import Transformer -from shapely.geometry import LineString, Polygon -from tqdm import tqdm -from tqdm.auto import tqdm -from matplotlib.colors import LogNorm -import contextily as cx -import seaborn as sns -import gzip -import io -import h3 -import time -import os -import re -import shutil -import math -import warnings - -warnings.filterwarnings("ignore", category=FutureWarning, - message="The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.") - -class_2b3 = 'Class 2b&3 Vocational' -class_46 = 'Class 4-6 Vocational' -class_78_v = 'Class 7&8 Vocational' -class_78_t = 'Class 7&8 Tractor' -class_car = "Car" # these include light and medium duty trucks -class_bike = "Bike" -class_mdp = "MediumDutyPassenger" -not_matched = "Not Matched" - -class_to_category = { - class_2b3: 'Class2b3Vocational', - class_46: 'Class456Vocational', - class_78_v: 'Class78Vocational', - class_78_t: 'Class78Tractor' -} - -fuel_emfac2beam_map = { - 'Dsl': 'diesel', - 'Gas': 'gasoline', - 'NG': 'naturalgas', - 'Elec': 'electricity', - 'Phe': 'pluginhybridelectricity', - 'H2fc': 'hydrogen', - 'BioDsl': 'biodiesel' -} - -fuel_beam2emfac_map = { - 'diesel': 'Dsl', - 'gasoline': 'Gas', - 'naturalgas': 'NG', - 'electricity': 'Elec', - 'pluginhybridelectricity': 'Phe', - 'hydrogen': 'H2fc', - "biodiesel": 'BioDsl' -} - -# Fuel Color Map -fuel_color_map = { - 'Elec': '#4169E1', # Royal Blue - 'H2fc': '#6495ED', # Cornflower Blue - 'Phe': '#87CEEB', # Sky Blue - 'NG': '#B0E0E6', # Pale Blue - 'BioDsl': '#98FB98', # Pale Green - 'Dsl': '#FFD700', # Gold - 'Gas': '#708090' # Slate Gray -} - -process_color_map = { - 'IDLEX': '#fde725', # Light yellow - 'RUNEX': '#7ad151', # Light green - 'PMBW': '#22a884', # Teal - 'PMTW': '#2a788e', # Blue-green - 'STREX': '#8e0152', # Dark magenta - 'RUNLOSS': '#4b0082', # Indigo - 'HOTSOAK': '#414487', # Purple-blue - 'DIURN': '#440154', # Dark purple -} - -pollutant_columns = { - 'CH4': 'rate_ch4_gram_float', - 'CO': 'rate_co_gram_float', - 'CO2': 'rate_co2_gram_float', - 'HC': 'rate_hc_gram_float', - 'NH3': 'rate_nh3_gram_float', - 'NOx': 'rate_nox_gram_float', - 'PM': 'rate_pm_gram_float', - 'PM10': 'rate_pm10_gram_float', - 'PM2_5': 'rate_pm2_5_gram_float', - 'ROG': 'rate_rog_gram_float', - 'SOx': 'rate_sox_gram_float', - 'TOG': 'rate_tog_gram_float' -} - -emissions_processes = ["RUNEX", "IDLEX", "STREX", "DIURN", "HOTSOAK", "RUNLOSS", "PMTW", "PMBW"] - -region_to_emfac_area = { - "sfbay": "SF" -} - -skims_schema = pa.schema([ - ('hour', pa.int64()), - ('linkId', pa.int64()), - ('tazId', pa.string()), - ('vehicleTypeId', pa.string()), - ('emissionsProcess', pa.string()), - ('speedInMps', pa.float64()), - ('energyInJoule', pa.float64()), - ('observations', pa.int64()), - ('iterations', pa.int64()), - ('CH4', pa.float64()), - ('CO', pa.float64()), - ('CO2', pa.float64()), - ('HC', pa.float64()), - ('NH3', pa.float64()), - ('NOx', pa.float64()), - ('PM', pa.float64()), - ('PM10', pa.float64()), - ('PM2_5', pa.float64()), - ('ROG', pa.float64()), - ('SOx', pa.float64()), - ('TOG', pa.float64()) -]) - - -def darken_color(color, factor=0.8): - rgb = mcolors.to_rgb(color) - return tuple(max(0, c * factor) for c in rgb) - - -def sanitize_name(filename): - # Start with the original filename - sanitized = filename - - # Replace other common superscripts if needed - superscript_map = {'¹': '1', '²': '2', '³': '3', '⁴': '4', '⁵': '5', '⁶': '6', '⁷': '7', '⁸': '8', '⁹': '9'} - for sup, normal in superscript_map.items(): - sanitized = sanitized.replace(sup, normal) - - # Replace parentheses with underscores - sanitized = sanitized.replace('(', '_').replace(')', '_') - - # Replace forward slashes and backslashes with dashes - sanitized = sanitized.replace('/', '-').replace('\\', '-') - - # Replace spaces with underscores - sanitized = sanitized.replace(' ', '_') - - # Remove or replace any other non-alphanumeric characters (except dashes and underscores) - sanitized = re.sub(r'[^\w\-_]', '', sanitized) - - # Replace any sequence of dashes or underscores with a single underscore - sanitized = re.sub(r'[_-]+', '_', sanitized) - - # Remove leading and trailing underscores - sanitized = sanitized.strip('_') - - return sanitized - - -def get_vehicle_class_from_freight(vehicle_type): - if 'md' in vehicle_type: - return class_46 - elif 'hdt' in vehicle_type: - return class_78_v - elif 'hdv' in vehicle_type: - return class_78_t - else: - return None - - -def prepare_emfac_emissions_for_mapping(emissions_rates, emfac_class_map): - data = emissions_rates.copy() - data = data.fillna({'speed_time': ''}) # Replace NaN with empty string - data = data.reset_index(drop=True) # Reset index - grouped_data = data.groupby( - ['sub_area', "vehicle_class", 'fuel', 'process', "speed_time", "pollutant"] - )['emission_rate'].mean().reset_index() - # Extract county and area from sub_area - grouped_data['beamClass'] = grouped_data['vehicle_class'].map(emfac_class_map) - grouped_data.dropna(subset=['beamClass'], inplace=True) - grouped_data[['county', 'area']] = grouped_data['sub_area'].str.extract(r'^([^()]+)\s*\(([^)]+)\)') - # Clean up the extracted data - grouped_data['county'] = grouped_data['county'].str.strip().str.lower() - grouped_data['area'] = grouped_data['area'].str.strip() - grouped_data.drop(['sub_area'], axis=1, inplace=True) - # Create emfacId - grouped_data['emfacId'] = grouped_data.apply( - lambda row: sanitize_name(f"{row['vehicle_class']}-{row['fuel']}"), - axis=1 - ) - grouped_data.rename(columns={'vehicle_class': 'emfacClass', 'fuel': 'emfacFuel'}, inplace=True) - return grouped_data - - -def prepare_emfac_population_for_mapping(emfac_population, year, emfac_class_map, fuel_assumption_mapping, - ignore_model_year=True): - df = emfac_population[(emfac_population["calendar_year"] == str(year))].drop(["calendar_year"], axis=1) - if ignore_model_year: - # Group by vehicle_class and fuel, aggregating population - df = df.groupby(['vehicle_class', 'fuel'], as_index=False)['population'].sum() - - df['beamClass'] = df['vehicle_class'].map(emfac_class_map) - df.dropna(subset=['beamClass'], inplace=True) - - # Validation checks - if len(df["vehicle_class"].unique()) != len(emfac_class_map): - print("Warning: Mismatch in vehicle class mapping") - if not df['fuel'].isin(fuel_emfac2beam_map.keys()).all(): - print("Warning: Missing fuel type from dictionary") - - df["mappedFuel"] = df['fuel'].map(fuel_assumption_mapping) - df['emfacId'] = df.apply( - lambda row: sanitize_name(f"{row['vehicle_class']}-{row['fuel']}"), - axis=1 - ) - df.rename(columns={'vehicle_class': 'emfacClass', 'fuel': 'emfacFuel'}, inplace=True) - return df - - -def unpacking_ft_vehicle_population_mesozones(carriers, mesozones_to_county_file, mesozones_lookup_file): - import pygris - # ### Mapping counties with Mesozones ### - if not os.path.exists(mesozones_to_county_file): - county_data = pygris.counties(state='06', year=2018, cb=True, cache=True) - cbg_data = pygris.block_groups(state='06', year=2018, cb=True, cache=True) - county_data_clipped = county_data[['COUNTYFP', 'NAME']] - cbg_data_clipped = cbg_data[['GEOID', 'COUNTYFP']] - cbg_to_county = pd.merge(cbg_data_clipped, county_data_clipped, on="COUNTYFP", how='left') - mesozones_lookup = pd.read_csv(mesozones_lookup_file, dtype=str) - mesozones_lookup_clipped = mesozones_lookup[['MESOZONE', 'GEOID']] - mesozones_to_county = pd.merge(mesozones_lookup_clipped, cbg_to_county, on='GEOID', how='left') - mesozones_to_county.to_csv(mesozones_to_county_file, index=False) - else: - mesozones_to_county = pd.read_csv(mesozones_to_county_file, dtype=str) - - # TODO For future improvement find a way to map outside study area mesozones. It's a significant effort because - # TODO need to also restructure EMFAC in such a way vehicle population from outside study area well represented - if not mesozones_to_county[mesozones_to_county["NAME"].isna()].empty: - print("Mesozones outside study area do not have a proper GEOID and were not mapped.") - mesozones_to_county_studyarea = mesozones_to_county[mesozones_to_county["NAME"].notna()][["MESOZONE", "NAME"]] - - # ### Mapping freight carriers with counties, payload and vehicle types ### - carriers_by_zone = pd.merge(carriers, mesozones_to_county_studyarea, left_on='warehouseZone', - right_on='MESOZONE', how='left') - if not carriers_by_zone[carriers_by_zone['NAME'].isna()].empty: - print( - "Something went wrong with the mapping of freight carrier zones with mesozones. Here the non mapped ones:") - print(carriers_by_zone[carriers_by_zone['NAME'].isna()]) - carriers_by_zone = carriers_by_zone[['tourId', 'vehicleId', 'vehicleTypeId', 'NAME']].rename( - columns={'NAME': 'zone'}) - - return carriers_by_zone - - -def prepare_pax_vehicle_population_for_mapping(vehicletypes, fuel_assumption_mapping): - # Apply the parsing function to create a new DataFrame with the parsed values - data = vehicletypes.copy() - data = data[ - (data['vehicleCategory'].isin([class_car, class_bike])) | - ((data['vehicleCategory'] == class_mdp) & (data['vehicleTypeId'].str.lower().str.contains('bus'))) - ] - - # parsed_probs = data['sampleProbabilityString'].apply(parse_probability_string).apply(pd.Series) - # Merge the new columns with the original DataFrame - # data = pd.concat([data, parsed_probs], axis=1) - # Fill NaN values with 0 for the new probability columns - # prob_columns = [col for col in data.columns if col.startswith('ridehail_prob') or col.startswith('private_prob')] - # data[prob_columns] = data[prob_columns].fillna(0) - # Load and process vehicle types - data['beamClass'] = data['vehicleCategory'] - data['beamFuel'] = np.where( - (data['primaryFuelType'] == fuel_emfac2beam_map["Elec"]) & - data['secondaryFuelType'].notna(), - fuel_emfac2beam_map['Phe'], - data['primaryFuelType'] - ) - - def handle_missing_fuel(x): - try: - return fuel_assumption_mapping[fuel_beam2emfac_map[x.lower()]] - except KeyError: - warnings.warn(f"Fuel type '{x}' not found in mapping. Using original value.") - return None - - data['mappedFuel'] = data['beamFuel'].map(handle_missing_fuel) - return data - - -def prepare_ft_vehicle_population_for_mapping(carriers, payloads_raw, ft_vehicletypes, - fuel_assumption_mapping): - carriers_formatted = carriers[['tourId', 'vehicleId', 'vehicleTypeId']] - payloads = payloads_raw[['payloadId', 'tourId', 'payloadType']].copy() - ft_vehicletypes = ft_vehicletypes[['vehicleTypeId', 'primaryFuelType', 'secondaryFuelType']].copy() - - ft_vehicletypes['beamClass'] = ft_vehicletypes['vehicleTypeId'].apply(get_vehicle_class_from_freight) - - # Summarize data - payloads.loc[:, 'payloadType'] = payloads['payloadType'].astype(str) - payloads_summary = payloads.groupby(['tourId'])['payloadType'].agg('|'.join).reset_index() - - # Merge payload summary with carriers - payloads_merged = pd.merge(payloads_summary, carriers_formatted, on='tourId', how='left') - - # Load and process vehicle types - ft_vehicletypes['beamFuel'] = np.where( - (ft_vehicletypes['primaryFuelType'] == fuel_emfac2beam_map["Elec"]) & - ft_vehicletypes['secondaryFuelType'].notna(), - fuel_emfac2beam_map['Phe'], - ft_vehicletypes['primaryFuelType'] - ) - - def handle_missing_fuel(x): - try: - return fuel_assumption_mapping[fuel_beam2emfac_map[x.lower()]] - except KeyError: - warnings.warn(f"Fuel type '{x}' not found in mapping. Using original value.") - return x - - ft_vehicletypes['mappedFuel'] = ft_vehicletypes['beamFuel'].map(handle_missing_fuel) - - # Merge payloads with vehicle types - payloads_vehtypes = pd.merge( - payloads_merged, - ft_vehicletypes[['vehicleTypeId', 'beamClass', 'beamFuel', 'mappedFuel']], - on='vehicleTypeId', - how='left' - ) - - # Check for missing fuel types - if payloads_vehtypes['beamFuel'].isna().any(): - print("Warning: Missing fuel types for some vehicle IDs") - print(payloads_vehtypes[payloads_vehtypes['beamFuel'].isna()]) - - # Remove duplicates and return - return payloads_vehtypes.drop_duplicates('vehicleId', keep='first') - - -def distribution_based_vehicle_classes_assignment(ft_df, emfac_df): - # Remove 'Class 2b&3 Vocational' from EMFAC data - emfac_df = emfac_df[emfac_df['beamClass'] != class_2b3] - - def sample_emfac(the_class, ft_mapped_fuel): - emfac_grouped = emfac_df[ - (emfac_df['beamClass'] == the_class) & (emfac_df['mappedFuel'] == ft_mapped_fuel)] - if emfac_grouped.empty: - print(f"failed to match this fuel: {ft_mapped_fuel}") - emfac_grouped = emfac_df[emfac_df['beamClass'] == the_class] - return emfac_grouped.sample(n=1, weights='population')['emfacId'].iloc[0] - - total_emfac = emfac_df["population"].sum() - class_46_share = emfac_df[emfac_df['beamClass'] == class_46]["population"].sum() / total_emfac - class_78_v_share = emfac_df[emfac_df['beamClass'] == class_78_v]["population"].sum() / total_emfac - total_freight = len(ft_df) - class_46_target = int(class_46_share * total_freight) - class_78_v_target = int(class_78_v_share * total_freight) - - class_46_count = 0 - class_78_v_count = 0 - - def sample_emfac_class(row): - nonlocal class_46_count, class_78_v_count - - if class_46_count < class_46_target: - if row['beamClass'] == class_46: - class_46_count += 1 - return sample_emfac(class_46, row['mappedFuel']) - - if row['beamClass'] == class_78_v: - class_46_count += 1 - return sample_emfac(class_46, row['mappedFuel']) - - if row['beamClass'] == class_78_t: - class_46_count += 1 - return sample_emfac(class_46, row['mappedFuel']) - - if class_78_v_count < class_78_v_target: - if row['beamClass'] == class_78_v: - class_78_v_count += 1 - return sample_emfac(class_78_v, row['mappedFuel']) - - if row['beamClass'] == class_78_t: - class_78_v_count += 1 - return sample_emfac(class_78_v, row['mappedFuel']) - - return sample_emfac(class_78_t, row['mappedFuel']) - - ft_df['beamClassBis'] = ft_df['beamClass'].map({class_46: 1, class_78_v: 2, class_78_t: 3}) - ft_df['emfacId'] = ft_df.sort_values('beamClassBis').apply(sample_emfac_class, axis=1) - ft_df["oldVehicleTypeId"] = ft_df["vehicleTypeId"] - ft_df['vehicleTypeId'] = ft_df.apply( - lambda row: f"EMFAC-{row['emfacId']}--TRUCK-{'-'.join(row['oldVehicleTypeId'].split('-')[:-1])}", - axis=1 - ) - merged = pd.merge(ft_df, emfac_df.drop(["beamClass", "mappedFuel"], axis=1), on="emfacId", how="left").drop( - ["beamClassBis"], axis=1) - return merged - - -def pivot_rates_for_beam(df_raw): - unique_speed_time = df_raw.speed_time.unique() - has_non_empty_speed_time = any(len(str(x)) > 0 for x in unique_speed_time) and not pd.isnull( - unique_speed_time).all() - index_ = ["emfacId", 'county', 'process'] - if has_non_empty_speed_time: - index_.append("speed_time") - pivot_df = df_raw.pivot_table(index=index_, columns='pollutant', values='emission_rate', aggfunc='first', - fill_value=0).reset_index() - pivot_df = pivot_df.rename(columns=pollutant_columns) - # Add missing columns with default values - for col in pollutant_columns.values(): - if col not in pivot_df.columns: - pivot_df[col] = 0.0 - pivot_df.insert(0, 'speed_mph_float_bins', "") - pivot_df.insert(1, 'time_minutes_float_bins', "") - return pivot_df - - -def numerical_column_to_binned_and_pivot(df_raw, numerical_colname, binned_colname, edge_values): - pivot_df = pivot_rates_for_beam(df_raw).sort_values(by='speed_time', ascending=True) - df_raw_last_row = pivot_df.iloc[-1].copy() - df_raw_last_row['speed_time'] = edge_values[1] - pivot_df = pd.concat([pivot_df, pd.DataFrame([df_raw_last_row])], ignore_index=True) - col_sorted = sorted(pivot_df[numerical_colname].unique()) - col_bins = [edge_values[0]] + col_sorted - col_labels = [f"[{col_bins[i]}, {col_bins[i + 1]})" for i in range(len(col_bins) - 1)] - pivot_df[binned_colname] = pd.cut(pivot_df[numerical_colname], bins=col_bins, labels=col_labels, right=True) - return pivot_df - - -def process_rates_group(df, row): - mask = ((df["county"] == row["county"]) & (df["emfacId"] == row["emfacId"])) - df_subset = df[mask] - df_output_list = [] - for process in emissions_processes: - df_temp = df_subset[df_subset['process'] == process] - if not df_temp.empty: - if process in ['RUNEX', 'PMBW']: - df_temp = numerical_column_to_binned_and_pivot(df_temp, 'speed_time', 'speed_mph_float_bins', - [0.0, 200.0]) - elif process == 'STREX': - df_temp = numerical_column_to_binned_and_pivot(df_temp, 'speed_time', 'time_minutes_float_bins', - [0.0, 3600.0]) - else: - df_temp = pivot_rates_for_beam(df_temp) - df_output_list.append(df_temp) - - return pd.concat(df_output_list, ignore_index=True) - - -def format_rates_for_beam(emissions_rates): - from joblib import Parallel, delayed - - # Assuming emissions_rates is already loaded into a DataFrame `df` - group_by_cols = ["county", "emfacId"] - df_unique = emissions_rates[group_by_cols].drop_duplicates().reset_index(drop=True) - - # Parallel processing - df_output_list = Parallel(n_jobs=-1)( - delayed(process_rates_group)(emissions_rates, row) for index, row in df_unique.iterrows() - ) - - # Formatting for merge - df_output = pd.concat(df_output_list, ignore_index=True).drop(["speed_time"], axis=1) - - # Filter out rows where all emission columns are zero - emission_columns = [col for col in df_output.columns if col.startswith('rate_') and col.endswith('_gram_float')] - filtered_out = df_output[(df_output[emission_columns] == 0).all(axis=1)] - df_output = df_output[~(df_output[emission_columns] == 0).all(axis=1)] - - # Reorder columns to ensure 'county' is at the front - columns = df_output.columns.tolist() - columns = ['county'] + [col for col in columns if col != 'county'] - df_output = df_output[columns] - return df_output, filtered_out - - -def process_single_vehicle_type(veh_type, emissions_rates, rates_prefix_filepath): - veh_type_id = veh_type['vehicleTypeId'] - emfac_id = veh_type['emfacId'] - - # Filter taz_emissions_rates for the current vehicle type - veh_emissions = emissions_rates[emissions_rates['emfacId'] == emfac_id].copy() - - if not veh_emissions.empty: - # Remove the emfacId column as it's no longer needed - veh_emissions = veh_emissions.drop('emfacId', axis=1) - - # Generate the file name - file_path = f"{rates_prefix_filepath}{veh_type_id}.csv" - - print("Writing " + file_path) - # Save the emissions rates to a CSV file - veh_emissions.to_csv(file_path, index=False) - - return veh_type_id - else: - print(f"Warning: No emissions data found for vehicle type {veh_type_id}") - return veh_type_id - - -def assign_emissions_rates_to_vehtypes(emissions_rates, vehicle_types, output_dir, emissions_rates_relative_filepath): - from joblib import Parallel, delayed - emissions_rates_dir = os.path.abspath(os.path.join(output_dir, emissions_rates_relative_filepath)) - if ensure_empty_directory(emissions_rates_dir): - print(f"Ready to write new data to the directory {emissions_rates_dir}") - else: - print(f"Failed to prepare the directory {emissions_rates_dir}. Please check permissions and try again.") - os.makedirs(emissions_rates_dir, exist_ok=True) - - # Use parallel processing with error handling and chunking - chunk_size = 100 # Adjust this value based on your data size and available memory - results = [] - - for i in range(0, len(vehicle_types), chunk_size): - chunk = vehicle_types.iloc[i:i + chunk_size] - - chunk_results = Parallel(n_jobs=-1, timeout=600)( # 10-minute timeout - delayed(process_single_vehicle_type)( - veh_type, - emissions_rates, - f"{output_dir}/{emissions_rates_relative_filepath}/TrAP--" - ) for _, veh_type in chunk.iterrows() - ) - - results.extend(chunk_results) - - # Clear some memory - del chunk_results - - # Update the vehicle_types DataFrame with the new emissionsRatesFile information - for veh_type_id in results: - if veh_type_id: - relative_rates_filepath = f"{emissions_rates_relative_filepath}/TrAP--{veh_type_id}.csv" - vehicle_types.loc[ - vehicle_types['vehicleTypeId'] == veh_type_id, 'emissionsRatesFile'] = relative_rates_filepath - - return vehicle_types - - -def build_new_pax_vehtypes(pax_emfac_population_for_mapping, pax_population_for_mapping): - df_merged = pd.merge(pax_population_for_mapping, pax_emfac_population_for_mapping, - on=['beamClass', 'mappedFuel'], how='left') - df_merged_car = df_merged[df_merged["beamClass"] == class_car].copy() - df_merged_others = df_merged[df_merged["beamClass"] != class_car].copy() - - df_merged_car['population_share'] = df_merged_car['population'] / df_merged_car['population'].sum() - df_merged_car['updated_sampleProbabilityString'] = df_merged_car.apply( - lambda row: update_sample_probability_string(row), - axis=1 - ) - df_merged_car['updated_sampleProbabilityWithinCategory'] = df_merged_car.apply( - lambda row: row['sampleProbabilityWithinCategory'] * row['population_share'], - axis=1 - ) - # Update vehicleTypeId only for eligible rows - df_merged_car['updated_vehicleTypeId'] = df_merged_car.apply( - lambda row: f"EMFAC-{row['emfacId']}--ADOPT-{row['vehicleTypeId']}", - axis=1 - ) - # Update the original dataframe with new probabilities and vehicleTypeId - df_merged_car['sampleProbabilityString'] = df_merged_car['updated_sampleProbabilityString'] - df_merged_car['sampleProbabilityWithinCategory'] = df_merged_car['updated_sampleProbabilityWithinCategory'] - df_merged_car['vehicleTypeId'] = df_merged_car['updated_vehicleTypeId'] - updated_pax_vehicle_types = pd.concat([df_merged_car[df_merged_others.columns], df_merged_others], axis=0) - - return updated_pax_vehicle_types - - -def build_new_ft_vehtypes(updated_ft_population, ft_vehicle_types): - # Create a copy of the original vehicleTypeId and set up a lookup dictionary - ft_vehicle_types_dict = ft_vehicle_types.set_index("vehicleTypeId").to_dict('index') - - # Remove duplicates based on vehicleTypeId, keeping the first occurrence - unique_vehicle_types = updated_ft_population.drop_duplicates(subset='vehicleTypeId', keep='first') - - def process_row(row): - new_row = ft_vehicle_types_dict[row["oldVehicleTypeId"]].copy() - new_row["vehicleTypeId"] = row["vehicleTypeId"] - new_row['vehicleClass'] = row["beamClass"] - new_row['vehicleCategory'] = class_to_category[row['beamClass']] - new_row["emfacId"] = row['emfacId'] - return new_row - - # Apply process_row to the unique vehicle types - result_df = pd.DataFrame(unique_vehicle_types.apply(process_row, axis=1).tolist()) - - # Define the desired column order with 'vehicleTypeId' at the front - columns_order = ['vehicleTypeId'] + [ - col for col in result_df.columns if col not in {'vehicleTypeId'} - ] - - # Reorder the columns - result_df = result_df[columns_order] - - return result_df - - -def assign_new_ft_vehtypes_to_carriers(carrier_df, updated_ft_population, carriers_emissions_file): - vehicle_id_to_type_mapping = dict(zip(updated_ft_population['vehicleId'], - updated_ft_population['vehicleTypeId'])) - - def update_vehicle_type(row): - return vehicle_id_to_type_mapping.get(row['vehicleId']) - - carrier_df_new = carrier_df.copy() - carrier_df_new['vehicleTypeId'] = carrier_df.apply(update_vehicle_type, axis=1) - carrier_df_new.dropna(subset=['vehicleTypeId'], inplace=True) - print(f"Writing {carriers_emissions_file}") - carrier_df_new.to_csv(carriers_emissions_file, index=False) - return carrier_df_new - - -def combine_csv_files(input_files, output_file): - # Read and combine CSV files vertically - combined_df = pd.concat([pd.read_csv(f) for f in input_files], ignore_index=True) - - # Write the combined dataframe to a new CSV file - combined_df.to_csv(output_file, index=False) - - print(f"Combined CSV file has been created: {output_file}") - return combined_df # Return the dataframe for further processing if needed - - -def ensure_empty_directory(directory_path): - """ - Ensure an empty directory exists at the given path. - If it exists, delete it and its contents, then recreate it. - If it doesn't exist, create it. - """ - directory_path = os.path.abspath(directory_path) - - if os.path.exists(directory_path): - try: - shutil.rmtree(directory_path) - print(f"Existing directory removed: {directory_path}") - except Exception as e: - print(f"Error removing directory {directory_path}: {e}") - return False - - try: - os.makedirs(directory_path) - print(f"Directory created: {directory_path}") - return True - except Exception as e: - print(f"Error creating directory {directory_path}: {e}") - return False - - -def calculate_truck_ownership_probability(income): - """ - Calculate the probability of truck ownership based on household income. - - :param income: Household income in thousands of dollars per year - :return: Probability of truck ownership (0 to 1) - """ - k = 0.1 # Steepness parameter - x0 = 80 # Income at which probability is 0.5 - - # Calculate probability using logistic function - probability = 1 / (1 + math.exp(-k * (income - x0))) - - return probability - - -def parse_probability_string(prob_string): - result = {} - parts = prob_string.split(';') - for part in parts: - try: - key, value = part.strip().split(':') - if 'ridehail' in key: - result['ridehail_prob_all'] = float(value) - elif 'income' in key: - income_range = key.split('|')[1].strip() - result[f'private_prob_{income_range}'] = float(value) - except ValueError: - # If the part doesn't have the expected structure, skip it - continue - return result - - -def update_sample_probability_string(row): - groups = row['sampleProbabilityString'].replace(' ', '').lower().split(';') - updated_groups = [] - - for group in groups: - if '|' not in group: - updated_groups.append(group) - continue - - group_key, values = group.split('|') - key_probs = [kp.split(':') for kp in values.split(',')] - - if group_key == 'ridehail': - # Update 'all' probability with population_share - key_probs = [(k, str(float(p) * row['population_share']) if k == 'all' else p) for k, p in key_probs] - elif group_key == 'income': - # Update income category probability with population_share - key_probs = [(k, str(float(p) * row['population_share'])) for k, p in key_probs] - - updated_values = ','.join([f"{k}:{p}" for k, p in key_probs]) - updated_groups.append(f"{group_key}|{updated_values}") - - return '; '.join(updated_groups) - - -def create_vehicle_class_mapping(vehicle_list): - mapping = {} - - for vehicle in vehicle_list: - if 'Utility' in vehicle or 'Public' in vehicle: - mapping[vehicle] = not_matched - elif 'Port' in vehicle or 'POLA' in vehicle or 'POAK' in vehicle: - mapping[vehicle] = not_matched - elif 'SWCV' in vehicle or 'PTO' in vehicle or 'T6TS' in vehicle: - mapping[vehicle] = not_matched - - elif vehicle in ['LDA', 'LDT1', 'LDT2', 'MDV']: - mapping[vehicle] = class_car - elif vehicle in ['MCY']: - mapping[vehicle] = class_bike - elif vehicle in ['UBUS']: - mapping[vehicle] = class_mdp - elif 'LHD' in vehicle: - mapping[vehicle] = class_2b3 - - elif 'Class 4' in vehicle or 'Class 5' in vehicle or 'Class 6' in vehicle: - mapping[vehicle] = class_46 - - elif 'Class 7' in vehicle or 'Class 8' in vehicle: - if 'Tractor' in vehicle or 'CAIRP' in vehicle: - mapping[vehicle] = class_78_t - else: - mapping[vehicle] = class_78_v - elif "T7IS" in vehicle: - mapping[vehicle] = class_78_t - - else: - mapping[vehicle] = not_matched - - from collections import defaultdict - class_groups = defaultdict(list) - for vehicle, vehicle_class in mapping.items(): - class_groups[vehicle_class].append(vehicle) - for vehicle_class, vehicles in class_groups.items(): - print(f"Category: {vehicle_class}") - for vehicle in vehicles: - print(f" - {vehicle}") - - ft_emfac_class_map = {emfac: beam for emfac, beam in mapping.items() if - beam in [class_46, class_78_v, class_78_t]} - pax_emfac_class_map = {emfac: beam for emfac, beam in mapping.items() if - beam in [class_car, class_bike, class_mdp]} - - return pax_emfac_class_map, ft_emfac_class_map - - -def load_network(network_file, source_epsg): - # Read and process network file - network = pd.read_csv(network_file) - transformer = Transformer.from_crs(source_epsg, "EPSG:4326", always_xy=True) - - # Vectorized coordinate conversion - network[['fromLocationX', 'fromLocationY']] = network.apply( - lambda row: pd.Series(transformer.transform(row['fromLocationX'], row['fromLocationY'])), - axis=1, result_type='expand' - ) - network[['toLocationX', 'toLocationY']] = network.apply( - lambda row: pd.Series(transformer.transform(row['toLocationX'], row['toLocationY'])), - axis=1, result_type='expand' - ) - - return network[['linkId', 'linkLength', 'fromLocationX', 'fromLocationY', 'toLocationX', 'toLocationY']] - - -def read_skims_emissions(skims_file, vehicleTypes_file, vehicleTypeId_filter, network, expansion_factor, scenario_name): - start_time = time.time() - # Read and filter the skims file using PyArrow - table = pv.read_csv(skims_file, - read_options=pv.ReadOptions(use_threads=True), - parse_options=pv.ParseOptions(delimiter=','), - convert_options=pv.ConvertOptions(column_types=skims_schema)) - - filtered_table = table.filter(pc.match_substring(table['vehicleTypeId'], pattern=vehicleTypeId_filter)) - - # Perform calculations in PyArrow - annual_expansion = filtered_table['observations'] * expansion_factor * 365 - - for pollutant in pollutant_columns.keys(): - filtered_table = filtered_table.append_column( - f'{pollutant}_annual', - pc.multiply(pc.divide(filtered_table[pollutant], pc.cast(pa.scalar(1e6), pa.float64())), annual_expansion) - ) - - filtered_table = filtered_table.append_column( - 'annualHourlyEnergyGwh', - pc.multiply(pc.divide(filtered_table['energyInJoule'], pc.cast(pa.scalar(3.6e12), pa.float64())), - annual_expansion) - ) - - filtered_table = filtered_table.append_column( - 'annualHourlySpeedMph', - pc.divide(filtered_table['speedInMps'], pc.cast(pa.scalar(2.237), pa.float64())) - ) - - # Convert to pandas - df = filtered_table.to_pandas() - - # Process vehicleTypes file - vehicleTypes = pd.read_csv(vehicleTypes_file) - vehicleTypes['fuel'] = vehicleTypes['emfacId'].str.split('-').str[-1] - vehicleTypes['class'] = vehicleTypes['vehicleClass'].str.replace('Vocational|Tractor', '', regex=True).str.strip() - - # Merge with vehicleTypes and network - df = (df.merge(vehicleTypes[['vehicleTypeId', 'class', 'fuel']], on='vehicleTypeId', how='left') - .merge(network[['linkId', 'linkLength']], on='linkId', how='left')) - - # Calculate annualHourlyMVMT - df['annualHourlyMVMT'] = (df['linkLength'] * 6.21371192e-13) * annual_expansion - - # Rename column - df.rename(columns={'emissionsProcess': 'process'}, inplace=True) - - # Melt the dataframe - id_vars = ['hour', 'linkId', 'tazId', 'class', 'fuel', 'process', 'annualHourlySpeedMph', 'annualHourlyEnergyGwh', - 'annualHourlyMVMT'] - value_vars = [f'{pollutant}_annual' for pollutant in pollutant_columns.keys()] - melted = df.melt(id_vars=id_vars, value_vars=value_vars, var_name='pollutant', value_name='rate') - melted['pollutant'] = melted['pollutant'].str.replace('_annual', '') - melted['scenario'] = scenario_name - - end_time = time.time() - print(f"Time taken to read the file: {end_time - start_time:.2f} seconds to read file {skims_file}") - - return melted - - -def read_skims_emissions_chunked(skims_file, vehicleTypes_file, vehicleTypeId_filter, network, expansion_factor, - scenario_name, chunk_size=1000000): - start_time = time.time() - - # Process vehicleTypes file - vehicleTypes = pd.read_csv(vehicleTypes_file) - vehicleTypes['emfacFuel'] = vehicleTypes['emfacId'].str.split('-').str[-1] - vehicleTypes['class'] = vehicleTypes['vehicleCategory'].str.replace('Vocational|Tractor', '', regex=True).str.strip() - vehicleTypes['beamFuel'] = np.where( - (vehicleTypes['primaryFuelType'].str.lower() == fuel_emfac2beam_map["Elec"]) & vehicleTypes[ - 'secondaryFuelType'].notna(), - 'Phe', - vehicleTypes['primaryFuelType'].str.lower().map(fuel_beam2emfac_map) - ) - - # Initialize an empty list to store the processed chunks - result_chunks = [] - - # Set up the CSV reader with chunking - csv_reader = pv.open_csv( - skims_file, - read_options=pv.ReadOptions(block_size=chunk_size, use_threads=True), - parse_options=pv.ParseOptions(delimiter=','), - convert_options=pv.ConvertOptions(column_types=skims_schema) - ) - - # Get total file size for progress bar - total_size = os.path.getsize(skims_file) - - # Initialize progress bar - pbar = tqdm(total=total_size, unit='B', unit_scale=True, desc="Processing chunks", - position=0, leave=True, mininterval=1.0, maxinterval=10.0, miniters=1) - - # Process the skims file in chunks - for chunk in csv_reader: - chunk_size = chunk.nbytes - - # Filter the chunk - mask = pc.match_substring(chunk['vehicleTypeId'], pattern=vehicleTypeId_filter) - filtered_chunk = chunk.filter(mask) - # del chunk # Explicitly remove reference to the original chunk - - # Perform calculations in PyArrow - observations_expansion = pc.multiply( - filtered_chunk['observations'], pc.cast(pa.scalar(expansion_factor), pa.float64()) - ) - - new_columns = [] - new_fields = [] - for pollutant in pollutant_columns.keys(): - new_fields.append(pa.field(f'scaled_{pollutant}', pa.float64(), True)) - new_columns.append(pc.multiply( - pc.divide( - filtered_chunk[pollutant], pc.cast(pa.scalar(1e6), pa.float64()) - ), - observations_expansion - )) - - new_fields.append(pa.field('kwh', pa.float64(), True)) - new_columns.append( - pc.multiply( - pc.divide( - filtered_chunk['energyInJoule'], pc.cast(pa.scalar(3.6e6), pa.float64()) - ), - observations_expansion - ) - ) - - new_fields.append(pa.field('vht', pa.float64(), True)) - new_columns.append( - pc.multiply( - pc.divide( - filtered_chunk['travelTimeInSecond'], pc.cast(pa.scalar(3.6e3), pa.float64()) - ), - observations_expansion - ) - ) - - # Create a new RecordBatch with additional columns - # new_schema = filtered_chunk.schema.append(new_columns[::2]) - # new_columns = filtered_chunk.columns + new_columns[1::2] - new_schema = filtered_chunk.schema - for field in new_fields: - new_schema = new_schema.append(field) - - new_columns = filtered_chunk.columns + new_columns - filtered_chunk = pa.RecordBatch.from_arrays(new_columns, schema=new_schema) - - # Convert to pandas - df_chunk = filtered_chunk.to_pandas() - # del filtered_chunk - - # Merge with vehicleTypes and network - df_chunk_merged = ( - df_chunk - .merge(vehicleTypes[['vehicleTypeId', 'class', 'beamFuel', 'emfacFuel', 'emfacId']], on='vehicleTypeId', how='left') - .merge(network[['linkId', 'linkLength']], on='linkId', how='left') - ) - # del df_chunk - - # Calculate annualHourlyMVMT - df_chunk_merged['vmt'] = (df_chunk_merged['linkLength'] * 6.21371192e-4) * observations_expansion - - # Rename column - df_chunk_merged.rename(columns={'emissionsProcess': 'process'}, inplace=True) - - # Melt the dataframe - id_vars = ['hour', 'linkId', 'tazId', 'emfacId', 'class', 'beamFuel', 'emfacFuel', 'process', 'kwh', 'vmt', 'vht'] - value_vars = [f'scaled_{pollutant}' for pollutant in pollutant_columns.keys()] - melted_chunk = df_chunk_merged.melt( - id_vars=id_vars, - value_vars=value_vars, - var_name='pollutant', - value_name='rate' - ) - # del df_chunk_merged - melted_chunk['pollutant'] = melted_chunk['pollutant'].str.replace('scaled_', '') - melted_chunk['scenario'] = scenario_name - - result_chunks.append(melted_chunk) - - # Update progress bar - pbar.update(chunk_size) - - # Close progress bar - pbar.close() - - # Combine all processed chunks - melted = pd.concat(result_chunks, ignore_index=True) - - end_time = time.time() - print(f"Time taken to read the file: {end_time - start_time:.2f} seconds to read file {skims_file}") - - return melted - - -def plot_hourly_emissions_by_scenario_class_fuel(emissions_skims, pollutant, output_dir, plot_legend, height_size, font_size): - data = emissions_skims[emissions_skims['pollutant'] == pollutant].copy() - grouped_data = data.groupby(['scenario', 'hour', 'class', 'emfacFuel'])['rate'].sum().reset_index() - - plt.figure(figsize=(20, height_size)) - - grouped_data['fuel_class'] = grouped_data['emfacFuel'].astype(str) + ', ' + grouped_data['class'].astype(str) - scenarios = grouped_data['scenario'].unique() - fuel_classes = sorted(grouped_data['fuel_class'].unique()) - all_hours = sorted(grouped_data['hour'].unique()) - - - # Create color map for fuel_classes - fuel_class_colors = {} - for fc in fuel_classes: - fuel, vehicle_class = fc.split(',') - fuel = fuel.strip() - vehicle_class = vehicle_class.strip() - base_color = fuel_color_map[fuel] # Default to black if fuel not found - if any(c in vehicle_class for c in ['7', '8']): - fuel_class_colors[fc] = darken_color(base_color) - else: - fuel_class_colors[fc] = base_color - - x = np.arange(len(all_hours)) - width = 0.35 / len(scenarios) - - scenarios_labeling = [] - for i, scenario in enumerate(scenarios): - scenarios_labeling.append(scenario) - scenario_data = grouped_data[grouped_data['scenario'] == scenario] - bottom = np.zeros(len(all_hours)) - for fuel_class in fuel_classes: - fuel_class_data = scenario_data[scenario_data['fuel_class'] == fuel_class] - # Create an array of rates for all hours, filling with zeros where data is missing - rates = np.zeros(len(all_hours)) - for _, row in fuel_class_data.iterrows(): - hour_index = all_hours.index(row['hour']) - rates[hour_index] = row['rate'] - - # Add edgecolor and linewidth parameters to create a subtle border - plt.bar(x + i * width, rates, width, bottom=bottom, - label=f"{fuel_class}" if i == 0 else "", - color=fuel_class_colors[fuel_class], - edgecolor='black', # Add black edge color - linewidth=0.5) # Adjust linewidth as needed - bottom += rates - - plt.title( - f'{pollutant.replace("_", ".")} Emissions: {" vs. ".join(scenarios_labeling)}', - fontsize=font_size+4) - plt.xlabel('Hour', fontsize=font_size) - plt.ylabel('Emissions (Metric Tons)', fontsize=font_size) - plt.xticks(x + width * (len(scenarios) - 1) / 2, all_hours, fontsize=font_size) - plt.yticks(fontsize=24) - if plot_legend: - plt.legend(title='Fuel, Class', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=font_size+4, title_fontsize=font_size+4) - plt.grid(axis='y', linestyle='--', alpha=0.7) - - plt.tight_layout() - plt.savefig(f'{output_dir}/{pollutant.lower()}_emissions_by_scenario_hour_class_fuel.png', dpi=300, bbox_inches='tight') - - -def plot_hourly_activity(tours_types, output_dir, height_size): - # Preprocess data - tours_types['class'] = tours_types['vehicleCategory'].str.replace('Vocational|Tractor', '', regex=True).str.strip() - tours_types['fuel'] = tours_types['primaryFuelType'].str.lower().map(fuel_beam2emfac_map) - tours_types['fuel'] = np.where((tours_types['fuel'] == "Elec") & tours_types['secondaryFuelType'].notna(), 'Phe', - tours_types['fuel']) - tours_types['fuel_class'] = tours_types['fuel'] + '-' + tours_types['class'] - tours_types['departure_hour'] = (tours_types['departureTimeInSec'] / 3600).astype(int) % 24 - # Group by scenario, hour, and fuel_class, count the number of tours - hourly_activity = tours_types.groupby(['scenario', 'departure_hour', 'fuel_class']).size().unstack( - level=[0, 2], fill_value=0 - ) - - scenarios = tours_types['scenario'].unique() - # If the DataFrame is empty, create a default one with all hours - if hourly_activity.empty: - fuel_classes = tours_types['fuel_class'].unique() - index = pd.Index(range(24), name='departure_hour') - columns = pd.MultiIndex.from_product([scenarios, fuel_classes], names=['scenario', 'fuel_class']) - hourly_activity = pd.DataFrame(0, index=index, columns=columns) - else: - # Ensure all hours are present - for hour in range(24): - if hour not in hourly_activity.index: - hourly_activity.loc[hour] = 0 - hourly_activity = hourly_activity.sort_index() - - # Create the plot - plt.figure(figsize=(20, height_size)) - x = np.arange(24) # 24 hours - width = 0.35 # width of the bars - scenarios = hourly_activity.columns.levels[0] - - # Get all unique fuel classes across all scenarios - all_fuel_classes = set() - for scenario in scenarios: - all_fuel_classes.update(hourly_activity[scenario].columns) - - fuel_order = list(fuel_color_map.keys()) - # Sort fuel classes based on the defined order - sorted_fuel_classes = sorted(all_fuel_classes, - key=lambda x: ( - fuel_order.index(x.split('-')[0]) if x.split('-')[0] in fuel_order else len( - fuel_order), x)) - - # Create a color map for all fuel types - #color_map = {fuel: fuel_color_map[fuel] for fuel in fuel_order} - color_map = {} - for fc in sorted_fuel_classes: - fuel, vehicle_class = fc.split('-') - base_color = fuel_color_map[fuel] # Default to black if fuel not found - if any(c in vehicle_class for c in ['7', '8']): - color_map[fc] = darken_color(base_color) - else: - color_map[fc] = base_color - - print("Sorted fuel classes:", sorted_fuel_classes) - print("Color map:", color_map) - - # Plot stacked bars for each scenario - legend_handles = [] - legend_labels = [] - for i, scenario in enumerate(scenarios): - bottom = np.zeros(24) - for fuel_class in sorted_fuel_classes: - color = color_map[fuel_class] - - if fuel_class in hourly_activity[scenario].columns: - values = hourly_activity[scenario][fuel_class] - else: - values = np.zeros(24) - - bar = plt.bar(x + i * width, values, width, bottom=bottom, color=color, edgecolor='black', linewidth=0.5) - bottom += values - - if fuel_class not in legend_labels: - legend_handles.append(bar) - legend_labels.append(fuel_class) - - # plt.title(f'Weekday Tour Activity by Fuel, Class and Scenario: {" vs ".join(scenarios).replace("_", " ")}', fontsize=24) - plt.xlabel('Hour', fontsize=24) - plt.ylabel('Number of Tours Departing', fontsize=24) - plt.xticks(x + width / 2, range(24), fontsize=24) - plt.yticks(fontsize=12) - - # Create legend with ordered fuel classes - plt.legend(legend_handles, legend_labels, fontsize=28, loc='upper left', bbox_to_anchor=(1, 1)) - - plt.grid(axis='y', linestyle='--', alpha=0.7) - - # Adjust layout and save - plt.tight_layout() - plt.savefig(f'{output_dir}/hourly_activity_by_scenario_fuel_class.png', dpi=300, bbox_inches='tight') - plt.close() - - print(f"Plot saved as {output_dir}/hourly_activity_by_scenario_fuel_class.png") - - -def plot_hourly_vmt(df, output_dir, height_size): - # Preprocess the data - df['fuel_class'] = df['beamFuel'].astype(str) + '-' + df['class'].astype(str) - df['hour'] = df['hour'].astype(int) % 24 - df['mvmt'] = df['vmt'] / 1e6 - - scenarios = df['scenario'].unique() - - hourly_vmt = df.groupby(['scenario', 'hour', 'fuel_class'])['mvmt'].sum().unstack( - level=[0, 2], fill_value=0 - ).copy().reset_index() - - # Ensure all hours are present - for hour in range(24): - if hour not in hourly_vmt.index: - hourly_vmt.loc[hour] = 0 - hourly_vmt = hourly_vmt.sort_index() - - # Create the plot - plt.figure(figsize=(20, height_size)) - x = np.arange(24) # 24 hours - width = 0.35 # width of the bars - - # Get all unique fuel classes across all scenarios - all_fuel_classes = set() - for scenario in scenarios: - all_fuel_classes.update(hourly_vmt[scenario].columns) - - fuel_order = list(fuel_color_map.keys()) - # Sort fuel classes based on the defined order - sorted_fuel_classes = sorted(all_fuel_classes, - key=lambda x: ( - fuel_order.index(x.split('-')[0]) if x.split('-')[0] in fuel_order else len( - fuel_order), x)) - - - # Create color map for fuel_classes - color_map = {} - for fc in sorted_fuel_classes: - fuel, vehicle_class = fc.split('-') - base_color = fuel_color_map[fuel] # Default to black if fuel not found - if any(c in vehicle_class for c in ['7', '8']): - color_map[fc] = darken_color(base_color) - else: - color_map[fc] = base_color - - # Plot stacked bars for each scenario - legend_handles = [] - legend_labels = [] - for i, scenario in enumerate(scenarios): - bottom = np.zeros(24) - for fuel_class in sorted_fuel_classes: - if fuel_class in hourly_vmt[scenario].columns: - values = hourly_vmt[scenario][fuel_class] - else: - values = np.zeros(24) - - bar = plt.bar(x + i * width, values, width, bottom=bottom, color=color_map[fuel_class], edgecolor='black', linewidth=0.5) - bottom += values - - if fuel_class not in legend_labels: - legend_handles.append(bar) - legend_labels.append(fuel_class) - - # plt.title(f'Weekday VMT by Fuel, Class and Scenario: {" vs ".join(scenarios).replace("_", " ")}', fontsize=20) - plt.xlabel('Hour', fontsize=24) - plt.ylabel('Million Vehicle Miles Traveled', fontsize=24) - plt.xticks(x + width / 2, range(24), fontsize=24) - plt.yticks(fontsize=24) - - # Create legend with ordered fuel classes - plt.legend(legend_handles, legend_labels, title='Fuel, Class', fontsize=28, loc='upper left', bbox_to_anchor=(1, 1)) - plt.grid(axis='y', linestyle='--', alpha=0.7) - - # Adjust layout and save - plt.tight_layout() - plt.savefig(f'{output_dir}/hourly_vmt_by_scenario_fuel_class.png', dpi=300, bbox_inches='tight') - plt.close() - - print(f"Hourly VMT plot saved as {output_dir}/hourly_vmt_by_scenario_fuel_class.png") - - -def generate_h3_intersections(network_df, resolution, output_dir): - print(f"Initial network_df shape: {network_df.shape}") - - # Remove rows with NaN values in coordinate columns - coord_columns = ['fromLocationX', 'fromLocationY', 'toLocationX', 'toLocationY'] - network_clean = network_df.dropna(subset=coord_columns) - print(f"Clean network_df shape: {network_clean.shape}") - - # Create bounding box - lats = network_clean[['fromLocationY', 'toLocationY']].values.flatten() - lons = network_clean[['fromLocationX', 'toLocationX']].values.flatten() - bbox = [[ - [min(lats), min(lons)], - [min(lats), max(lons)], - [max(lats), max(lons)], - [max(lats), min(lons)], - [min(lats), min(lons)] # Close the polygon - ]] - - # Generate H3 cells - h3_cells = list(h3.polyfill({'type': 'Polygon', 'coordinates': bbox}, resolution)) - print(f"Number of H3 cells: {len(h3_cells)}") - - if len(h3_cells) == 0: - print("No H3 cells created. Check your bounding box and resolution.") - return pd.DataFrame() - - # Create GeoDataFrame of H3 cells - h3_gdf = gpd.GeoDataFrame( - {'h3_cell': h3_cells}, - geometry=[Polygon(h3.h3_to_geo_boundary(h, geo_json=True)) for h in h3_cells], - crs="EPSG:4326" - ) - - # Create network GeoDataFrame - def create_linestring(row): - return LineString([(row['fromLocationX'], row['fromLocationY']), - (row['toLocationX'], row['toLocationY'])]) - - network_gdf = gpd.GeoDataFrame( - network_clean, - geometry=network_clean.apply(create_linestring, axis=1), - crs="EPSG:4326" - ) - - # Spatial join - joined = gpd.sjoin(h3_gdf, network_gdf, how="inner", predicate="intersects") - print(f"Joined DataFrame shape after spatial join: {joined.shape}") - - if joined.empty: - print("No intersections found between H3 cells and network geometries.") - return pd.DataFrame() - - # Calculate intersections and lengths - def calculate_intersection(row): - try: - h3_poly = Polygon(h3.h3_to_geo_boundary(row['h3_cell'], geo_json=True)) - line = row['geometry'] - intersection = h3_poly.intersection(line) - return pd.Series({'intersection_length': intersection.length}) - except Exception as e: - print(f"Error in calculate_intersection: {e}") - return pd.Series({'intersection_length': 0}) - - tqdm.pandas(desc="Calculating intersections") - joined['intersection_length'] = joined.progress_apply(calculate_intersection, axis=1) - - # Calculate length ratios - joined['length_ratio'] = joined['intersection_length'] / joined['linkLength'] - - # Keep only necessary columns - intersection_df = joined[['h3_cell', 'linkId', 'length_ratio']] - - intersection_df.to_csv(f'{output_dir}/network.h3.csv', index=False) - - return intersection_df - - -def process_h3_data(h3_df, data_df, data_col): - print(f"Initial emissions_df shape: {data_df.shape}") - - # Filter emissions data for the specific pollutant - data_df[data_col] = pd.to_numeric(data_df[data_col], errors='coerce') - data_df_filtered = data_df.dropna() - print(f"Filtered emissions shape: {data_df_filtered.shape}") - - # Merge with intersection data - merged = pd.merge(h3_df, data_df_filtered, on='linkId', how='inner') - print(f"Merged DataFrame shape: {merged.shape}") - - # Calculate normalized emissions - merged[f'weighted_{data_col}'] = merged[data_col] * merged['length_ratio'] - - # Group by H3 cell and sum normalized emissions - result = merged.groupby(['scenario', 'h3_cell'])[f'weighted_{data_col}'].sum().reset_index() - print(f"Final result shape: {result.shape}") - return result - - -def process_h3_emissions(emissions_df, intersection_df, pollutant): - print(f"Initial emissions_df shape: {emissions_df.shape}") - - # Filter emissions data for the specific pollutant - filtered_emissions = emissions_df[emissions_df['pollutant'] == pollutant][['scenario', 'linkId', 'rate']] - filtered_emissions['rate'] = pd.to_numeric(filtered_emissions['rate'], errors='coerce') - filtered_emissions = filtered_emissions.dropna() - print(f"Filtered emissions shape: {filtered_emissions.shape}") - - # Merge with intersection data - merged = pd.merge(intersection_df, filtered_emissions, on='linkId', how='inner') - print(f"Merged DataFrame shape: {merged.shape}") - - # Calculate normalized emissions - merged[f'{pollutant}'] = merged['rate'] * merged['length_ratio'] - - # Group by H3 cell and sum normalized emissions - result = merged.groupby(['scenario', 'h3_cell'])[f'{pollutant}'].sum().reset_index() - print(f"Final result shape: {result.shape}") - return result - - -def plot_h3_heatmap(df, df_col, scenario, output_dir, is_delta, remove_outliers, in_log_scale): - """Create a heatmap using the H3 grid structure with linear or logarithmic color scale and a base map.""" - subset_df = df[df["scenario"] == scenario] - if remove_outliers: - subset_df = remove_outliers_zscore(subset_df, df_col) - - # Create polygons for all H3 cells in the result - polygons = [Polygon(h3.h3_to_geo_boundary(h3_cell, geo_json=True)) for h3_cell in subset_df['h3_cell']] - - # Create GeoDataFrame - gdf = gpd.GeoDataFrame({ - 'h3_cell': subset_df['h3_cell'], - 'h3_var': subset_df[df_col], - 'geometry': polygons - }) - gdf = gdf.set_crs("EPSG:4326") - - # Convert to Web Mercator projection for compatibility with contextily - gdf_mercator = gdf.to_crs(epsg=3857) - - # Create figure and axis - fig, ax = plt.subplots(figsize=(15, 10)) - - vmin, vmax = gdf_mercator['h3_var'].min(), gdf_mercator['h3_var'].max() - - if in_log_scale: - if is_delta: - norm = mcolors.SymLogNorm(linthresh=1e-5, vmin=vmin, vmax=vmax) - else: - gdf_mercator = gdf_mercator[gdf_mercator['h3_var'] > 0] - vmin, vmax = gdf_mercator['h3_var'].min(), gdf_mercator['h3_var'].max() - norm = LogNorm(vmin=vmin, vmax=vmax) - label_suffix = "in log scale" - file_suffix = "log" - else: - if is_delta: - norm = mcolors.TwoSlopeNorm(vmin=vmin, vcenter=0, vmax=vmax) - else: - norm = None - label_suffix = "" - file_suffix = "linear" - - # Choose colormap based on whether it's a delta calculation - if is_delta: - cmap = mcolors.LinearSegmentedColormap.from_list("", ["blue", "lightblue", "white", "pink", "red"]) - else: - cmap = plt.get_cmap('viridis') - - # Plot cells with data - gdf_mercator.plot(column='h3_var', ax=ax, legend=False, cmap=cmap, edgecolor='none', norm=norm, alpha=0.7) - - # Add base map - cx.add_basemap(ax, source=cx.providers.CartoDB.Positron) - - # Add colorbar - sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) - sm.set_array([]) - if is_delta: - cbar = fig.colorbar(sm, ax=ax, extend='both') - else: - cbar = fig.colorbar(sm, ax=ax, extend='max') - - cbar.ax.tick_params(labelsize=14) - cbar.set_label(f'{df_col.replace("_", ".")} {label_suffix}', rotation=270, labelpad=15, fontsize=18) - - # Set title and adjust plot - # plt.title(f'Emissions Distribution of {df_col.replace("_", ".")}, {scenario} ', fontsize=16) - ax.set_axis_off() - plt.tight_layout() - - # Save figure - outlier_status = "no_outliers" if remove_outliers else "with_outliers" - file_name = f'{output_dir}/{df_col.replace(" ", "_").lower()}_{scenario.replace(" ", "_").lower()}_heatmap_{file_suffix}_{outlier_status}_with_basemap.png' - plt.savefig(file_name, dpi=300, bbox_inches='tight') - plt.close() - print(f"Heatmap with base map saved as {file_name}") - - -def create_h3_histogram(df, output_dir, pollutant, scenario, remove_outliers, in_log_scale): - subset_df = df[df["scenario"] == scenario] - if remove_outliers: - subset_df = remove_outliers_zscore(subset_df, pollutant) - # Extract pollutant values - pollutant_values = subset_df[pollutant].values - - # Create the histogram - plt.figure(figsize=(12, 6)) - - if in_log_scale: - # Use log-spaced bins, but with adjustments for potential zero values - bins = np.logspace(np.log10(pollutant_values.min() + 1e-10), - np.log10(pollutant_values.max()), - num=50) - x_label = f'{pollutant.replace("_", ".")} Emissions (log scale)' - title_label = f'Histogram of {pollutant.replace("_", ".")} Emissions by H3 Cell (Log Scale)' - file_name = f'{output_dir}/{pollutant}_{scenario.replace(" ","_").lower()}_emissions_histogram_log.png' - else: - # Use automatic binning based on Sturges' rule - bins = 'sturges' - x_label = f'{pollutant.replace("_", ".")} Emissions' - title_label = f'Histogram of {pollutant.replace("_", ".")} Emissions by H3 Cell' - file_name = f'{output_dir}/{pollutant}_{scenario.replace(" ","_").lower()}_emissions_histogram.png' - - plt.hist(pollutant_values, bins=bins, edgecolor='black') - - # Set x-axis to log scale if specified - if in_log_scale: - plt.xscale('log') - - # Set labels and title - plt.xlabel(x_label, fontsize=12) - plt.ylabel('Frequency', fontsize=12) - plt.title(title_label, fontsize=14) - - # Add grid for better readability - plt.grid(True, linestyle='--', alpha=0.7) - - # Adjust layout and save - plt.tight_layout() - plt.savefig(file_name, dpi=300, bbox_inches='tight') - plt.close() - print(f"Histogram saved as {file_name}/") - - -def remove_outliers_zscore(df, column, threshold=3): - mean = df[column].mean() - std = df[column].std() - z_scores = np.abs((df[column] - mean) / std) - df_filtered = df[z_scores < threshold].copy() - removed_rows = df[~df.index.isin(df_filtered.index)] - summary_df = pd.DataFrame({ - 'column': [column], - 'mean': [mean], - 'std': [std], - 'num_outliers': [len(removed_rows)] - }) - print(summary_df) - print(removed_rows) - return df_filtered - - -def fast_df_to_gzip(df, output_file, compression_level=5, chunksize=100000): - """ - Write a pandas DataFrame to a compressed CSV.gz file quickly with a progress bar. - - :param df: pandas DataFrame to write - :param output_file: path to the output .csv.gz file - :param compression_level: gzip compression level (1-9, 9 being highest) - :param chunksize: number of rows to write at a time - """ - total_rows = len(df) - - with gzip.open(output_file, 'wt', compresslevel=compression_level) as gz_file: - # Write header - gz_file.write(','.join(df.columns) + '\n') - - # Write data in chunks - with tqdm(total=total_rows, desc="Writing to gzip", unit="rows") as pbar: - for start in range(0, total_rows, chunksize): - end = min(start + chunksize, total_rows) - chunk = df.iloc[start:end] - - csv_buffer = io.StringIO() - chunk.to_csv(csv_buffer, index=False, header=False) - gz_file.write(csv_buffer.getvalue()) - - pbar.update(end - start) - - -def create_model_vmt_comparison_chart(emfac_vmt_file, emfac_area, emfac_scenario, skims_data, famos_scenario, output_dir): - df = pd.read_csv(emfac_vmt_file) - _, ft_emfac_class_map = create_vehicle_class_mapping(df["vehicle_class"].unique()) - filtered_df = df[ - (df['calendar_year'] == emfac_scenario) & - (df['sub_area'].str.contains(f'\({region_to_emfac_area[emfac_area]}\)')) & - (df['vehicle_class'].map(ft_emfac_class_map))].copy() - filtered_df["class"] = df['vehicle_class'].map(ft_emfac_class_map).map( - { - 'Class 4-6 Vocational': 'Class456', - 'Class 7&8 Vocational': 'Class78', - 'Class 7&8 Tractor': 'Class78' - } - ) - filtered_df["fuel_class"] = filtered_df["fuel"] + "-" + filtered_df["class"] - emfac_vmt = filtered_df.groupby(["fuel_class"])["total_vmt"].sum().reset_index() - emfac_vmt.rename(columns={'total_vmt': 'mvmt'}, inplace=True) - emfac_vmt["model"] = "emfac" - famos_vmt = skims_data[skims_data["scenario"] == famos_scenario].groupby( - ["class", "beamFuel"] - )["vmt"].sum().reset_index() - famos_vmt["fuel_class"] = famos_vmt["beamFuel"] + "-" + famos_vmt["class"] - famos_vmt = famos_vmt[["fuel_class", "vmt"]].copy() - famos_vmt.rename(columns={'vmt': 'mvmt'}, inplace=True) - famos_vmt["model"] = "famos" - emfac_famos_vmt = pd.concat([emfac_vmt, famos_vmt], axis=0) - emfac_famos_vmt.to_csv(f"{output_dir}/emfac_famos_vmt_by_fuel_class.csv") - return emfac_famos_vmt - - -def plot_multi_pie_emfac_famos_vmt(data, plot_dir): - def assign_color(fuel_class): - return fuel_color_map[fuel_class.split('-')[0]] - - models = data["model"].unique() - - emfac_data = data[data['model'] == 'emfac'].sort_values('mvmt', ascending=False) - famos_data = data[data['model'] == 'famos'].sort_values('mvmt', ascending=False) - - all_fuel_classes = set(emfac_data['fuel_class']) | set(famos_data['fuel_class']) - for fuel_class in all_fuel_classes: - if fuel_class not in emfac_data['fuel_class'].values: - emfac_data = pd.concat( - [emfac_data, pd.DataFrame({'fuel_class': [fuel_class], 'model': ['EMFAC'], 'mvmt': [0]})], - ignore_index=True) - if fuel_class not in famos_data['fuel_class'].values: - famos_data = pd.concat( - [famos_data, pd.DataFrame({'fuel_class': [fuel_class], 'model': ['FAMOS'], 'mvmt': [0]})], - ignore_index=True) - - emfac_data = emfac_data.sort_values('fuel_class') - famos_data = famos_data.sort_values('fuel_class') - - if emfac_data['mvmt'].sum() == 0 and famos_data['mvmt'].sum() == 0: - print("Error: All VMT values are zero. Cannot create pie chart.") - return - - fig, ax = plt.subplots(figsize=(14, 10)) - size = 0.3 - outer_radius = 1 - inner_radius = outer_radius - size - outer_colors = [assign_color(fuel_class) for fuel_class in famos_data['fuel_class']] - inner_colors = [assign_color(fuel_class) for fuel_class in emfac_data['fuel_class']] - - def make_autopct(values): - def my_autopct(pct): - return f'{pct:.1f}%' if pct >= 1 else '' - - return my_autopct - - def add_labels(wedges, fuel_classes, autopct, colors, radius, inner=False): - for wedge, fuel_class, color in zip(wedges, fuel_classes, colors): - ang = (wedge.theta2 + wedge.theta1) / 2 - pct = wedge.theta2 - wedge.theta1 - if pct * 100 / 360 >= 1: # Only show labels for slices >= 1% - label = autopct(pct * 100 / 360) - theta = np.deg2rad(ang) - - if inner: - start_point = ((inner_radius - size) * np.cos(theta), (inner_radius - size) * np.sin(theta)) - end_point = (0.4 * np.cos(theta), 0.4 * np.sin(theta)) - - bbox_props = dict(boxstyle="round,pad=0.3", fc=color, ec="k", lw=0.72, alpha=0.7) - arrowprops = dict(arrowstyle="-", connectionstyle=f"arc3,rad=0", color='k') - - ax.annotate(f'{fuel_class}\n{label}', xy=start_point, xytext=end_point, - horizontalalignment='center', - verticalalignment='center', - bbox=bbox_props, arrowprops=arrowprops, - fontsize=16) - else: - x = (radius + size / 2 + 0.05) * np.cos(theta) - y = (radius + size / 2 + 0.05) * np.sin(theta) - - bbox_props = dict(boxstyle="round,pad=0.3", fc=color, ec="k", lw=0.72, alpha=0.7) - ax.annotate(f'{fuel_class}\n{label}', xy=(x, y), xytext=(x, y), - horizontalalignment='center', - verticalalignment='center', - bbox=bbox_props, - fontsize=16) - - wedges_outer, texts_outer, autotexts_outer = ax.pie(famos_data['mvmt'], radius=outer_radius, colors=outer_colors, - labels=None, autopct='', pctdistance=0.85, - labeldistance=1.1, - wedgeprops=dict(width=size, edgecolor='white')) - - add_labels(wedges_outer, famos_data['fuel_class'], make_autopct(famos_data['mvmt']), outer_colors, outer_radius) - - wedges_inner, texts_inner, autotexts_inner = ax.pie(emfac_data['mvmt'], radius=inner_radius, colors=inner_colors, - labels=None, autopct='', pctdistance=0.75, - wedgeprops=dict(width=size, edgecolor='white')) - - add_labels(wedges_inner, emfac_data['fuel_class'], make_autopct(emfac_data['mvmt']), inner_colors, inner_radius, inner=True) - - # ax.set_title('VMT Share by Fuel-Class: FAMOS (outer) vs EMFAC (inner)', fontsize=16) - - # handles = [plt.Rectangle((0, 0), 1, 1, fc="w", ec="k", lw=2, alpha=0.5) for _ in range(2)] - # labels = ['FAMOS (Outer)', 'EMFAC (Inner)'] - # ax.legend(handles, labels, title="Models", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1)) - - plt.tight_layout() - output_file = os.path.join(plot_dir, f"{'_'.join(models)}_vmt_multi_level_pie_chart.png") - plt.savefig(output_file, bbox_inches='tight', dpi=300) - plt.close() - print(f"Chart has been saved as '{output_file}'") - - -def plot_pollution_variability_by_process_vehicle_types(skims, pollutant, scenario, output_dir, height_size, font_size): - warnings.filterwarnings("ignore", category=FutureWarning, module="seaborn") - # Filter data for specified scenario and pollutant - data = skims[(skims['scenario'] == scenario) & (skims['pollutant'] == pollutant)].copy() - processes = sorted(skims["process"].unique().tolist()) - - # Create fuel_class category - data['fuel_class'] = data['emfacFuel'].astype(str) + ', ' + data['class'].astype(str) - data['rate_micro_gram'] = data['rate'] * 1e12 - - # Sort fuel_class by median emission rate - fuel_class_order = data.groupby('fuel_class')['rate_micro_gram'].median().sort_values(ascending=False).index - - # Set up the plot - fig, ax = plt.subplots(figsize=(20, height_size)) - - # Create color map for fuel_classes - fuel_class_colors = {} - for fc in data['fuel_class'].unique(): - fuel, vehicle_class = fc.split(',') - fuel = fuel.strip() - vehicle_class = vehicle_class.strip() - base_color = fuel_color_map[fuel] # Default to black if fuel not found - if any(c in vehicle_class for c in ['7', '8']): - fuel_class_colors[fc] = darken_color(base_color) - else: - fuel_class_colors[fc] = base_color - - # Create the box plot with adjusted parameters - with warnings.catch_warnings(): - warnings.simplefilter("ignore", category=FutureWarning) - sns.boxplot(x='process', y='rate_micro_gram', hue='fuel_class', data=data, - order=processes, hue_order=fuel_class_order, - palette=fuel_class_colors, - ax=ax, whis=1.5, fliersize=2, showcaps=True, showfliers=True) - - # Add strip plot for additional data points - sns.stripplot(x='process', y='rate_micro_gram', hue='fuel_class', data=data, - order=processes, hue_order=fuel_class_order, - palette=fuel_class_colors, - ax=ax, size=1, jitter=True, dodge=True, alpha=0.3) - - # Customize the plot - ax.set_title(f'{pollutant.replace("_", ".")} Emissions Variability - {scenario}', fontsize=font_size+4) - ax.set_xlabel('Process', fontsize=font_size) - ax.set_ylabel('Microgram per road link', fontsize=font_size) - ax.tick_params(axis='both', which='major', labelsize=font_size) - - # Rotate x-axis labels if needed - plt.setp(ax.get_xticklabels(), rotation=0, ha='right') - - # Move the legend outside the plot - ax.legend(title='Fuel, Class', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=font_size) - - # Use log scale for y-axis if the range of values is large - min_rate = data['rate_micro_gram'].min() - max_rate = data['rate_micro_gram'].max() - - if min_rate <= 0: - print(f"Warning: Minimum rate is {min_rate}, which is zero or negative. Using log scale by default.") - ax.set_yscale('log') - # Set a small positive value for the bottom of the y-axis - ax.set_ylim(bottom=1e-10) # You might need to adjust this value - scale_label = "log" - elif max_rate / min_rate > 1000: - print(f"Using log scale. Max/min ratio: {max_rate/min_rate}") - ax.set_yscale('log') - scale_label = "log" - else: - print(f"Using linear scale. Max/min ratio: {max_rate/min_rate}") - scale_label = "linear" - - plt.tight_layout() - plt.savefig(f'{output_dir}/{pollutant.lower()}_variability_by_process_fuel_class_{scenario.replace(" ", "_").lower()}_{scale_label}_scale.png', dpi=300, bbox_inches='tight') - plt.close() - - -def plot_pollutants_by_process(skims, scenario, plot_dir, height_size, font_size): - # Define process order and color map based on toxicity - process_order = list(process_color_map.keys()) - # Group by pollutant and process, and sum the rates - grouped = skims[skims["scenario"] == scenario].groupby(['pollutant', 'process'])['rate'].sum().unstack() - - # Reorder columns based on process_order - grouped = grouped.reindex(columns=process_order) - - # Normalize the data - normalized = grouped.div(grouped.sum(axis=1), axis=0) - normalized = normalized * 100 - - # Create the stacked bar plot - fig, ax = plt.subplots(figsize=(20, height_size)) - normalized.plot(kind='bar', stacked=True, ax=ax, color=[process_color_map[col] for col in normalized.columns]) - - # Customize the plot - plt.title(f'Normalized Emissions by Process - {scenario}', fontsize=font_size+4) - plt.xlabel('Pollutant', fontsize=font_size) - plt.ylabel('Relative Emissions (%)', fontsize=font_size) - plt.xticks(rotation=0, ha='center', fontsize=font_size) - plt.yticks(fontsize=font_size) - - ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda y, _: '{:.0f}%'.format(y))) - ax.set_ylim(0, 100) - - legend = plt.legend(title='Process', bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=font_size) - plt.setp(legend.get_title(), fontsize=font_size) - plt.tight_layout() - - # Save the plot - plt.savefig( - f'{plot_dir}/pollutant_by_process_{scenario.replace(" ", "_").lower()}.png', - dpi=300, - bbox_inches='tight' - ) - - # Show the plot - plt.show() diff --git a/src/main/python/emissions/map_emfac_population_with_beam.py b/src/main/python/emissions/map_emfac_population_with_beam.py new file mode 100644 index 00000000000..a9a8ba9da2d --- /dev/null +++ b/src/main/python/emissions/map_emfac_population_with_beam.py @@ -0,0 +1,448 @@ +import json +import logging +import os +import os.path +import shutil +import sys +from typing import Dict, Any, Optional +from collections import defaultdict + +import pandas as pd +import pyarrow as pa +import pyarrow.csv as csv +from joblib import Parallel, delayed + +from _emfac_and_emissions_rates_processing import process_emfac_population +from _emfac_and_emissions_rates_processing import process_emfac_vmt +from _emfac_and_emissions_rates_processing import process_emissions_rates +from _emfac_beam_ft_matching import generate_emfac_mapped_freight_fleet +from _emfac_beam_pax_mapping import generate_emfac_mapped_passenger_vehicle_types +from _emfac_beam_pax_mapping import generate_fleet_from_vehicle_types + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +# Now use absolute import +from python.utils.study_area_config import get_area_config +from python.utils.study_area_config import BeamClasses +from python.utils.study_area_config import get_fuel_key +from python.utils.files_utils import sanitize_name +from python.utils.files_utils import check_files + +pd.set_option('display.max_columns', 20) + + +def create_emfac_id(row): + model_year_group_st = sanitize_name(row['model_year_group']).replace("_","") + vehicle_class_st = sanitize_name(row['vehicle_class']).replace("_","") + fuel_st = sanitize_name(row['fuel']).replace("_","") + return f"{model_year_group_st}{vehicle_class_st}{fuel_st}" + +def generate_emfac_beam_class_mapping(_study_area, _scenario_name, _work_dir, _config, to_filter_out): + """ + Creates vehicle class mapping and saves it to a JSON file if it doesn't exist. + If the file exists, loads and returns the existing mapping. + + Args: + _study_area: Stud Area + _scenario_name: Scenario Name + _work_dir: + _config: Configuration dictionary + to_filter_out: + + Returns: + dict: The vehicle class mapping (either newly created or loaded from existing file) + """ + _vehicle_class_output_file = os.path.join( + _work_dir, + f"{_config["rates"]["output_dir"]}/{_study_area}_vehicle_class_mapping_{_scenario_name}.json" + ) + # Check if the file already exists + if os.path.exists(_vehicle_class_output_file): + print(f"File {_vehicle_class_output_file} already exists. Loading existing mapping.") + with open(_vehicle_class_output_file, 'r') as f: + return json.load(f) + + # Create the mapping + mapping = {} + + table = csv.read_csv( + os.path.join(_work_dir, _config["rates"]["emfac"]["emfac_pop_by_model_year_file"]), + read_options=pa.csv.ReadOptions(use_threads=True) + ) + df = table.to_pandas() + + for vehicle in df["vehicle_class"].unique(): + if 'Utility' in vehicle or 'Public' in vehicle: + mapping[vehicle] = "NotMatched" + elif 'Port' in vehicle or 'POLA' in vehicle or 'POAK' in vehicle: + mapping[vehicle] = "NotMatched" + elif 'SWCV' in vehicle or 'PTO' in vehicle or 'T6TS' in vehicle: + mapping[vehicle] = "NotMatched" + elif vehicle in ['LDA', 'LDT1', 'LDT2', 'MDV']: + mapping[vehicle] = BeamClasses.CLASS_CAR + elif vehicle in ['MCY']: + mapping[vehicle] = BeamClasses.CLASS_BIKE + elif vehicle in ['UBUS']: + mapping[vehicle] = BeamClasses.CLASS_MDP + elif 'LHD' in vehicle: + mapping[vehicle] = BeamClasses.CLASS_2B3_VOCATIONAL + elif 'Class 4' in vehicle or 'Class 5' in vehicle or 'Class 6' in vehicle: + mapping[vehicle] = BeamClasses.CLASS_456_VOCATIONAL + elif 'Class 7' in vehicle or 'Class 8' in vehicle: + if 'Tractor' in vehicle or 'CAIRP' in vehicle: + mapping[vehicle] = BeamClasses.CLASS_78_TRACTOR + else: + mapping[vehicle] = BeamClasses.CLASS_78_VOCATIONAL + elif "T7IS" in vehicle: + mapping[vehicle] = BeamClasses.CLASS_78_TRACTOR + else: + mapping[vehicle] = "NotMatched" + + # Print category groupings + class_groups = defaultdict(list) + for vehicle, vehicle_class in mapping.items(): + if vehicle_class in to_filter_out: + mapping[vehicle] = "NotMatched" + class_groups[mapping[vehicle]].append(vehicle) + for vehicle_class, vehicles in class_groups.items(): + print(f"Category: {vehicle_class}") + for vehicle in vehicles: + print(f" - {vehicle}") + + return {k: v for k, v in mapping.items() if v != "NotMatched"} + + +def prepare_emissions_data_for_mapping(area, scenario, work_dir, config): + mapping_config = config["mapping"] + def categorize_model_year(year): + # https://pubs.acs.org/doi/full/10.1021/acs.est.9b04763 + if year <= 1993: return '1993' + elif year <= 2006: return '2006' + else: return '2018' + def format_emissions_data(emfac_types: pd.DataFrame) -> pd.DataFrame: + result_ft_df = emfac_types.copy() + result_ft_df['mappedClass'] = result_ft_df['vehicle_class'].map(mapping_config["class"]["emfac-ft"]) + result_ft_df.dropna(subset=['mappedClass'], inplace=True) + result_ft_df['mappedFuel'] = result_ft_df['fuel'].map(mapping_config["fuel"]["emfac-ft"]) + result_ft_df.dropna(subset=['mappedFuel'], inplace=True) + + result_pax_df = emfac_types.copy() + result_pax_df['mappedClass'] = result_pax_df['vehicle_class'].map(mapping_config["class"]["emfac-pax"]) + result_pax_df.dropna(subset=['mappedClass'], inplace=True) + result_pax_df['mappedFuel'] = result_pax_df['fuel'].map(mapping_config["fuel"]["emfac-pax"]) + result_pax_df.dropna(subset=['mappedFuel'], inplace=True) + + result_bus_df = emfac_types.copy() + result_bus_df['mappedClass'] = result_bus_df['vehicle_class'].map(mapping_config["class"]["emfac-bus"]) + result_bus_df.dropna(subset=['mappedClass'], inplace=True) + result_bus_df['mappedFuel'] = result_bus_df['fuel'].map(mapping_config["fuel"]["emfac-bus"]) + result_bus_df.dropna(subset=['mappedFuel'], inplace=True) + + result_df = pd.concat([result_ft_df, result_pax_df, result_bus_df]) + + result_df['model_year_group'] = result_df['model_year'].apply(categorize_model_year) + result_df[['county', 'area']] = result_df['sub_area'].str.extract(r'^([^()]+)\s*\(([^)]+)\)') + result_df['county'] = result_df['county'].str.strip().str.lower() + result_df['area'] = result_df['area'].str.strip() + result_df['emfacId'] = result_df.apply(create_emfac_id, axis=1) + return result_df + + emfac_pop = process_emfac_population(area, scenario, work_dir, config, format_emissions_data) + print("\n=== EMFAC Population ===\n") + print(f"total_population: {emfac_pop["population"].sum() / 1_000_000:.1f}M") + # + print("\n=== EMFAC VMT ===\n") + emfac_vmt = process_emfac_vmt(area, scenario, work_dir, config, format_emissions_data) + print(f"total_vmt: {emfac_vmt["total_vmt"].sum() / 1_000_000:.1f}M") + # + emfac_fleet = pd.merge(emfac_pop, emfac_vmt[["emfacId", "total_vmt", "vmt_proportion"]], on='emfacId', how='left') + # + print("\n=== CARB Emissions Rates ===\n") + emfac_rates = process_emissions_rates(area, scenario, work_dir, config, format_emissions_data) + print(f"rates: {len(emfac_rates):,}") + + return emfac_fleet, emfac_rates + + +def assign_emission_rates_to_vehicle_types(scenario, emissions_rates, emfac_fleet, work_dir, config): + """ + Process freight and passenger vehicle emissions by assigning EMFAC IDs and emissions rates. + + This function: + 1. Builds new freight vehicle types and assigns them to carriers + 2. Creates or loads passenger vehicle types + 3. Assigns emissions rates to all vehicle types + + Args: + scenario (str): Scenario name + emissions_rates (DataFrame): DataFrame containing emissions rates + emfac_fleet (DataFrame): DataFrame containing EMFAC population and VMT data + work_dir (str): Working directory for file operations + config (dict): Configuration dictionary + + Returns: + None: Files are saved to disk + """ + # ###### + def format_beam_vehicle_types(vehicle_types: pd.DataFrame) -> pd.DataFrame: + # Validate inputs + result_df = vehicle_types.copy() + result_df['fuel_key'] = result_df.apply(get_fuel_key, axis=1) + result_df['mappedFuel'] = result_df['fuel_key'].map(config["mapping"]["fuel"]["beam"]) + na_count = result_df['mappedFuel'].isna().sum() + if na_count > 0: + logging.warning(f"{na_count} vehicle types could not be mapped to EMFAC fuel types") + result_df['mappedClass'] = result_df['vehicleCategory'] + return result_df + # ###### + + print("\n=== Map EMFAC To BEAM Population ===\n") + + # Define output file paths + carriers_out_file = os.path.join(work_dir, f"{config['beam']['carriers_file'].replace('.csv', '--EM.csv')}") + ft_vehtypes_out_file = os.path.join(work_dir, + f"{config['beam']['ft_vehicle_types_file'].replace('.csv', '--EM.csv')}") + pax_vehtypes_out_file = os.path.join(work_dir, + f"{config['beam']['pax_vehicle_types_file'].replace('.csv', '--EM.csv')}") + emissions_rates_dir = os.path.join( + os.path.dirname(os.path.join(work_dir, f"{config['beam']['ft_vehicle_types_file']}")), + f"emissions/{scenario.replace('_', '-')}" + ) + + + # Process freight vehicles + if check_files([carriers_out_file, ft_vehtypes_out_file], config["override_fleet"]): + logging.info("All carriers and freight vehicle types emissions files have already been created") + logging.info(f" carriers: {carriers_out_file}") + logging.info(f" freight vehicle types: {ft_vehtypes_out_file}") + new_ft_vehicle_types = pd.read_csv(ft_vehtypes_out_file) + else: + new_carriers, new_ft_vehicle_types = generate_emfac_mapped_freight_fleet( + emfac_fleet, BeamClasses.get_freight_classes(), work_dir, config, format_beam_vehicle_types + ) + logging.info(f"Saving updated files to:\n {carriers_out_file}\n {ft_vehtypes_out_file}") + new_ft_vehicle_types.to_csv(ft_vehtypes_out_file, index=False) + new_carriers.to_csv(carriers_out_file, index=False) + + # Process passenger vehicles + if check_files([pax_vehtypes_out_file], config["override_fleet"]): + logging.info("Passenger vehicle types emissions files have already been created:") + logging.info(f" passenger vehicle types: {pax_vehtypes_out_file}") + new_pax_vehicle_types = pd.read_csv(pax_vehtypes_out_file) + temp = pd.read_csv(os.path.join(work_dir, f"{config['beam']['pax_vehicle_types_file']}")) + other_pax_vehicle_types = temp[temp["vehicleCategory"].isin( + BeamClasses.get_freight_classes() + new_pax_vehicle_types["vehicleCategory"].unique().tolist())] + else: + # Generate passenger vehicle types + new_pax_vehicle_types, other_pax_vehicle_types = generate_emfac_mapped_passenger_vehicle_types( + emfac_fleet, + car_class=BeamClasses.CLASS_CAR, + bike_class=BeamClasses.CLASS_BIKE, + transit_class=BeamClasses.CLASS_MDP, + filter_out_classes=BeamClasses.get_freight_classes(), + work_dir=work_dir, + config=config, + format_func=format_beam_vehicle_types, + ) + + vehicles_output = os.path.join(work_dir, f"{config['beam']['pax_vehicles_file'].replace('.csv', '--EM.csv')}") + if not check_files([vehicles_output], config["override_fleet"]): + pax_vehicles = generate_fleet_from_vehicle_types( + new_pax_vehicle_types, + car_class=BeamClasses.CLASS_CAR, + bike_class=BeamClasses.CLASS_BIKE, + work_dir=work_dir, + config=config + ) + vehicles_output = os.path.join(work_dir, f"{vehicles_output}") + pax_vehicles.to_csv(vehicles_output, index=False) + + # Prepare for emissions rates processing + vehtypes_with_emfac_id = pd.concat([new_ft_vehicle_types, new_pax_vehicle_types], ignore_index=True) + vehtypes_with_emfac_id = vehtypes_with_emfac_id.fillna("") + + # Prepare directory for emissions rates files + try: + if os.path.exists(emissions_rates_dir): + shutil.rmtree(emissions_rates_dir) + os.makedirs(emissions_rates_dir, exist_ok=True) + logging.info(f"Ready to write new data to the directory {emissions_rates_dir}") + except Exception as e: + logging.error(f"Failed to prepare directory {emissions_rates_dir}: {e}") + + # Process vehicle emissions in parallel with chunking + chunk_size = 100 + results = [] + for i in range(0, len(vehtypes_with_emfac_id), chunk_size): + chunk = vehtypes_with_emfac_id.iloc[i:i + chunk_size] + chunk_results = Parallel(n_jobs=-1, timeout=600)( + delayed(process_single_vehicle_type)( + veh_type, + emissions_rates, + f"{emissions_rates_dir}/" + ) for _, veh_type in chunk.iterrows() + ) + results.extend(chunk_results) + del chunk_results # Free memory + + # Update emissions rate file paths in vehicle types + path_parts = emissions_rates_dir.split('/') + em_index = path_parts.index("emissions") + shortened_path = '/'.join(path_parts[em_index:]) + for veh_type_id, emfac_id in results: + if veh_type_id: + relative_rates_filepath = f"{shortened_path}/{emfac_id}.csv" + vehtypes_with_emfac_id.loc[ + vehtypes_with_emfac_id['vehicleTypeId'] == veh_type_id, 'emissionsRatesFile' + ] = relative_rates_filepath + + # Save updated vehicle types + logging.info(f"Writing:\n{ft_vehtypes_out_file}\n{pax_vehtypes_out_file}") + + # Save freight vehicle types + ft_freight_mask = (vehtypes_with_emfac_id['vehicleCategory'].isin(BeamClasses.get_freight_classes())) + updated_ft_vehicle_types = vehtypes_with_emfac_id[ft_freight_mask].copy() + updated_ft_vehicle_types.drop(['emfacId', 'oldVehicleTypeId', 'vehicleClass'], axis=1, inplace=True) + updated_ft_vehicle_types.to_csv(ft_vehtypes_out_file, index=False) + + # Save passenger vehicle types + updated_pax_vehicle_types_others = other_pax_vehicle_types.copy() + updated_pax_vehicle_types_others['emissionsRatesFile'] = "" + updated_pax_vehicle_types = pd.concat( + [vehtypes_with_emfac_id[~ft_freight_mask].copy(), other_pax_vehicle_types], + axis=0 + ) + updated_pax_vehicle_types.drop(['emfacId', 'oldVehicleTypeId', 'vehicleClass'], axis=1, inplace=True) + updated_pax_vehicle_types.to_csv(pax_vehtypes_out_file, index=False) + + +def process_single_vehicle_type( + veh_type: Dict[str, Any], + emissions_rates: pd.DataFrame, + rates_prefix_filepath: str +) -> Optional[tuple[str, str]]: + """ + Process and save emissions rates for a single vehicle type. + + Filters the emissions rates for a specific vehicle type identified by its + vehicleTypeId, removes the emfacId column, and saves the filtered data + to a CSV file in the specified directory. + + Args: + veh_type (Dict[str, Any]): Dictionary containing vehicle type information, + must include 'vehicleTypeId' key + emissions_rates (pd.DataFrame): DataFrame containing emissions rates data + with 'emfacId' column matching vehicleTypeId values + rates_prefix_filepath (str): Directory path prefix where the CSV file + will be saved + + Returns: + Optional[str]: The vehicleTypeId if processing was successful, None if + no emissions data was found or an error occurred + + Raises: + IOError: If there is an error writing the CSV file + """ + try: + veh_type_id = veh_type['vehicleTypeId'] + emfac_id = veh_type['emfacId'] + + # Filter emissions_rates for the current vehicle type + veh_emissions = emissions_rates[emissions_rates['emfacId'] == emfac_id].copy() + + if veh_emissions.empty: + logging.warning(f"No emissions data found for vehicle type {veh_type_id}") + return None + + # Generate the file path + file_path = f"{rates_prefix_filepath}{emfac_id}.csv" + + # Save the emissions rates to a CSV file only if it doesn't exist + if not os.path.exists(file_path): + print(f"Writing emissions data to {file_path}") + logging.info(f"Writing emissions data to {file_path}") + os.makedirs(os.path.dirname(file_path), exist_ok=True) + veh_emissions.to_csv(file_path, index=False) + print(f"Created new file: {file_path}") + else: + print(f"File already generated: {file_path}") + + return veh_type_id, emfac_id + + except KeyError as e: + logging.error(f"Missing required key in vehicle type data: {e}") + return None + except IOError as e: + logging.error(f"Error writing emissions data file: {e}") + return None + except Exception as e: + logging.error(f"Unexpected error processing vehicle type: {e}") + return None + +def print_unmapped(df, mapped_col, col_to_be_mapped): + unmapped_classes = df[df[mapped_col].isna()][col_to_be_mapped].unique() + if len(unmapped_classes) > 0: + unmapped_classes_message = f"The following {col_to_be_mapped} were not mapped to {mapped_col}:\n" + formatted_list = "" + current_line = "" + for vehicle_class in unmapped_classes: + # Check if adding this class would exceed the line limit + if len(current_line + vehicle_class) > 115: # 115 to leave room for comma and space + formatted_list += current_line.rstrip(", ") + "\n" + current_line = vehicle_class + ", " + else: + current_line += vehicle_class + ", " + # Add the last line + if current_line: + formatted_list += current_line.rstrip(", ") + print(f"{unmapped_classes_message}{formatted_list}") + + +def run(): + # Configuration parameters + area = "sfbay" + run_batch = "20240123" + run_batch_label = run_batch.replace("-", "") + scenario = "2018-Baseline" + scenario_label = scenario.replace("_", "-") + + study_area_config = get_area_config(area) + config = study_area_config["emissions"][scenario] + config["rates"]["output_dir"] = f"emissions/{run_batch}" + beam_config = config["beam"] + beam_config["carriers_file"] = f"beam-ft/{run_batch}/{scenario}/carriers--{scenario_label}.csv" + beam_config["payloads_file"] = f"beam-ft/{run_batch}/{scenario}/payloads--{scenario_label}.csv" + beam_config["ft_vehicle_types_file"] = f"vehicle-tech/vehicleTypes--frism--{scenario_label}.csv" + beam_config["pax_vehicle_types_file"] = f"vehicle-tech/vehicleTypes--atlas--2023-Baseline.csv" + emfac_class_map = generate_emfac_beam_class_mapping( + area, scenario, study_area_config["work_dir"], config, to_filter_out=[BeamClasses.CLASS_2B3_VOCATIONAL] + ) + config["mapping"]["class"]["emfac"] = emfac_class_map + # Write Config file to keep track of runs + # Write it onl after all modification to config are completed + emissions_work_dir = os.path.join(study_area_config["work_dir"], config["rates"]["output_dir"]) + os.makedirs(emissions_work_dir, exist_ok=True) + with open(os.path.join(study_area_config["work_dir"], f"{emissions_work_dir}/{area}_emissions_config_{scenario}.json"), 'w') as f: + json.dump(study_area_config, f, indent=2) + + # ################################################################# + + print(f"\n{'='*50}") + print(f" EMISSIONS PROCESSING - {area.upper()} REGION") + print(f" Run Batch: {run_batch}") + print(f" Scenario: {scenario}") + print(f"{'='*50}\n") + + work_dir = study_area_config["work_dir"] + emfac_fleet, emfac_rates = prepare_emissions_data_for_mapping(area, scenario, work_dir, config) + assign_emission_rates_to_vehicle_types(scenario, emfac_rates, emfac_fleet, work_dir, config) + print(f" DONE") + + # ################################################################# + + +if __name__ == "__main__": + run() \ No newline at end of file diff --git a/src/main/python/emissions/process_emissions_skims.py b/src/main/python/emissions/process_emissions_skims.py new file mode 100644 index 00000000000..128116ba49e --- /dev/null +++ b/src/main/python/emissions/process_emissions_skims.py @@ -0,0 +1,648 @@ +import time +from pathlib import Path + +import pyarrow as pa +import pyarrow.compute as pc +import pyarrow.csv as pv +from pyproj import Transformer +from shapely.geometry import LineString + +from _beam_emissions_plotting import * +from _emfac_emissions_mapping import * + +# Configure pandas display options +pd.set_option('display.max_columns', 20) + +# ################ +# ### Constants ## +# ################ + +# Define schema for skims data +SKIMS_SCHEMA = pa.schema([ + ('hour', pa.int64()), + ('linkId', pa.int64()), + ('tazId', pa.string()), + ('vehicleTypeId', pa.string()), + ('emissionsProcess', pa.string()), + ('speedInMps', pa.float64()), + ('energyInJoule', pa.float64()), + ('observations', pa.int64()), + ('iterations', pa.int64()), + ('CH4', pa.float64()), + ('CO', pa.float64()), + ('CO2', pa.float64()), + ('HC', pa.float64()), + ('NH3', pa.float64()), + ('NOx', pa.float64()), + ('PM', pa.float64()), + ('PM10', pa.float64()), + ('PM2_5', pa.float64()), + ('ROG', pa.float64()), + ('SOx', pa.float64()), + ('TOG', pa.float64()) +]) + + +# ################ +# ### Functions ## +# ################ + +def read_skims_emissions_chunked(skims_file, vehicleTypes_file, vehicleTypeId_filter, network, expansion_factor, + scenario_name, chunk_size=1000000): + """ + Read and process emissions data from skims file in chunks + + Args: + skims_file: Path to skims emissions CSV file + vehicleTypes_file: Path to vehicle types CSV file + vehicleTypeId_filter: Filter string for vehicle type IDs + network: Network dataframe with link information + expansion_factor: Factor to scale observations + scenario_name: Name of the scenario + chunk_size: Size of chunks to process at once + + Returns: + DataFrame with processed emissions data + """ + start_time = time.time() + + # Process vehicleTypes file + vehicleTypes = pd.read_csv(vehicleTypes_file) + vehicleTypes['emfacFuel'] = vehicleTypes['emfacId'].str.split('-').str[-1] + vehicleTypes['class'] = vehicleTypes['vehicleCategory'].str.replace('Vocational|Tractor', '', + regex=True).str.strip() + vehicleTypes['beamFuel'] = np.where( + (vehicleTypes['primaryFuelType'].str.lower() == fuel_emfac2beam_map["Elec"]) & vehicleTypes[ + 'secondaryFuelType'].notna(), + 'Phe', + vehicleTypes['primaryFuelType'].str.lower().map(fuel_beam2emfac_map) + ) + + # Initialize an empty list to store the processed chunks + result_chunks = [] + + # Set up the CSV reader with chunking + csv_reader = pv.open_csv( + skims_file, + read_options=pv.ReadOptions(block_size=chunk_size, use_threads=True), + parse_options=pv.ParseOptions(delimiter=','), + convert_options=pv.ConvertOptions(column_types=SKIMS_SCHEMA) + ) + + # Get total file size for progress bar + total_size = os.path.getsize(skims_file) + + # Initialize progress bar + pbar = tqdm(total=total_size, unit='B', unit_scale=True, desc="Processing chunks", + position=0, leave=True, mininterval=1.0, maxinterval=10.0, miniters=1) + + # Process the skims file in chunks + for chunk in csv_reader: + chunk_size = chunk.nbytes + + # Filter the chunk + mask = pc.match_substring(chunk['vehicleTypeId'], pattern=vehicleTypeId_filter) + filtered_chunk = chunk.filter(mask) + + # Perform calculations in PyArrow + observations_expansion = pc.multiply( + filtered_chunk['observations'], pc.cast(pa.scalar(expansion_factor), pa.float64()) + ) + + new_columns = [] + new_fields = [] + for pollutant in pollutant_columns.keys(): + new_fields.append(pa.field(f'scaled_{pollutant}', pa.float64(), True)) + new_columns.append(pc.multiply( + pc.divide( + filtered_chunk[pollutant], pc.cast(pa.scalar(1e6), pa.float64()) + ), + observations_expansion + )) + + new_fields.append(pa.field('kwh', pa.float64(), True)) + new_columns.append( + pc.multiply( + pc.divide( + filtered_chunk['energyInJoule'], pc.cast(pa.scalar(3.6e6), pa.float64()) + ), + observations_expansion + ) + ) + + new_fields.append(pa.field('vht', pa.float64(), True)) + new_columns.append( + pc.multiply( + pc.divide( + filtered_chunk['travelTimeInSecond'], pc.cast(pa.scalar(3.6e3), pa.float64()) + ), + observations_expansion + ) + ) + + # Create a new RecordBatch with additional columns + new_schema = filtered_chunk.schema + for field in new_fields: + new_schema = new_schema.append(field) + + new_columns = filtered_chunk.columns + new_columns + filtered_chunk = pa.RecordBatch.from_arrays(new_columns, schema=new_schema) + + # Convert to pandas + df_chunk = filtered_chunk.to_pandas() + + # Merge with vehicleTypes and network + df_chunk_merged = ( + df_chunk + .merge(vehicleTypes[['vehicleTypeId', 'class', 'beamFuel', 'emfacFuel', 'emfacId']], on='vehicleTypeId', + how='left') + .merge(network[['linkId', 'linkLength']], on='linkId', how='left') + ) + + # Calculate annualHourlyMVMT + df_chunk_merged['vmt'] = (df_chunk_merged['linkLength'] * 6.21371192e-4) * observations_expansion + + # Rename column + df_chunk_merged.rename(columns={'emissionsProcess': 'process'}, inplace=True) + + # Melt the dataframe + id_vars = ['hour', 'linkId', 'tazId', 'emfacId', 'class', 'beamFuel', 'emfacFuel', 'process', 'kwh', 'vmt', + 'vht'] + value_vars = [f'scaled_{pollutant}' for pollutant in pollutant_columns.keys()] + melted_chunk = df_chunk_merged.melt( + id_vars=id_vars, + value_vars=value_vars, + var_name='pollutant', + value_name='rate' + ) + melted_chunk['pollutant'] = melted_chunk['pollutant'].str.replace('scaled_', '') + melted_chunk['scenario'] = scenario_name + + result_chunks.append(melted_chunk) + + # Update progress bar + pbar.update(chunk_size) + + # Close progress bar + pbar.close() + + # Combine all processed chunks + melted = pd.concat(result_chunks, ignore_index=True) + + end_time = time.time() + print(f"Time taken to read the file: {end_time - start_time:.2f} seconds to read file {skims_file}") + + return melted + + +def create_model_vmt_comparison_chart(emfac_vmt_file, emfac_area, emfac_scenario, skims_data, famos_scenario, + output_dir): + """ + Create a comparison chart between EMFAC and FAMOS VMT data + + Args: + emfac_vmt_file: Path to EMFAC VMT CSV file + emfac_area: Area name for EMFAC data + emfac_scenario: Scenario year for EMFAC data + skims_data: Processed skims data + famos_scenario: Name of the FAMOS scenario + output_dir: Directory to save output + + Returns: + DataFrame with combined EMFAC and FAMOS VMT data + """ + df = pd.read_csv(emfac_vmt_file) + _, ft_emfac_class_map = create_vehicle_class_mapping(df["vehicle_class"].unique()) + filtered_df = df[ + (df['calendar_year'] == emfac_scenario) & + (df['sub_area'].str.contains(fr'\({region_to_carb_area[emfac_area]}\)')) & + (df['vehicle_class'].map(ft_emfac_class_map))].copy() + filtered_df["class"] = df['vehicle_class'].map(ft_emfac_class_map).map( + { + 'Class 4-6 Vocational': 'Class456', + 'Class 7&8 Vocational': 'Class78', + 'Class 7&8 Tractor': 'Class78' + } + ) + filtered_df["fuel_class"] = filtered_df["fuel"] + "-" + filtered_df["class"] + emfac_vmt = filtered_df.groupby(["fuel_class"])["total_vmt"].sum().reset_index() + emfac_vmt.rename(columns={'total_vmt': 'mvmt'}, inplace=True) + emfac_vmt["model"] = "emfac" + famos_vmt = skims_data[skims_data["scenario"] == famos_scenario].groupby( + ["class", "beamFuel"] + )["vmt"].sum().reset_index() + famos_vmt["fuel_class"] = famos_vmt["beamFuel"] + "-" + famos_vmt["class"] + famos_vmt = famos_vmt[["fuel_class", "vmt"]].copy() + famos_vmt.rename(columns={'vmt': 'mvmt'}, inplace=True) + famos_vmt["model"] = "famos" + emfac_famos_vmt = pd.concat([emfac_vmt, famos_vmt], axis=0) + emfac_famos_vmt.to_csv(f"{output_dir}/emfac_famos_vmt_by_fuel_class.csv") + return emfac_famos_vmt + + +def load_network(network_file, source_epsg): + """ + Load and transform network data + + Args: + network_file: Path to network CSV file + source_epsg: Source EPSG code for coordinate transformation + + Returns: + DataFrame with network data + """ + # Read and process network file + network = pd.read_csv(network_file) + transformer = Transformer.from_crs(source_epsg, "EPSG:4326", always_xy=True) + + # Vectorized coordinate conversion + network[['fromLocationX', 'fromLocationY']] = network.apply( + lambda row: pd.Series(transformer.transform(row['fromLocationX'], row['fromLocationY'])), + axis=1, result_type='expand' + ) + network[['toLocationX', 'toLocationY']] = network.apply( + lambda row: pd.Series(transformer.transform(row['toLocationX'], row['toLocationY'])), + axis=1, result_type='expand' + ) + + return network[['linkId', 'linkLength', 'fromLocationX', 'fromLocationY', 'toLocationX', 'toLocationY']] + + +def generate_h3_intersections(network_df, resolution, output_dir): + """ + Generate H3 cell intersections with network + + Args: + network_df: Network dataframe + resolution: H3 resolution + output_dir: Directory to save output + + Returns: + DataFrame with intersection data + """ + print(f"Initial network_df shape: {network_df.shape}") + + # Remove rows with NaN values in coordinate columns + coord_columns = ['fromLocationX', 'fromLocationY', 'toLocationX', 'toLocationY'] + network_clean = network_df.dropna(subset=coord_columns) + print(f"Clean network_df shape: {network_clean.shape}") + + # Create bounding box + lats = network_clean[['fromLocationY', 'toLocationY']].values.flatten() + lons = network_clean[['fromLocationX', 'toLocationX']].values.flatten() + bbox = [[ + [min(lats), min(lons)], + [min(lats), max(lons)], + [max(lats), max(lons)], + [max(lats), min(lons)], + [min(lats), min(lons)] # Close the polygon + ]] + + # Generate H3 cells + h3_cells = list(h3.polyfill({'type': 'Polygon', 'coordinates': bbox}, resolution)) + print(f"Number of H3 cells: {len(h3_cells)}") + + if len(h3_cells) == 0: + print("No H3 cells created. Check your bounding box and resolution.") + return pd.DataFrame() + + # Create GeoDataFrame of H3 cells + h3_gdf = gpd.GeoDataFrame( + {'h3_cell': h3_cells}, + geometry=[Polygon(h3.h3_to_geo_boundary(h, geo_json=True)) for h in h3_cells], + crs="EPSG:4326" + ) + + # Create network GeoDataFrame + def create_linestring(row): + return LineString([(row['fromLocationX'], row['fromLocationY']), + (row['toLocationX'], row['toLocationY'])]) + + network_gdf = gpd.GeoDataFrame( + network_clean, + geometry=network_clean.apply(create_linestring, axis=1), + crs="EPSG:4326" + ) + + # Spatial join + joined = gpd.sjoin(h3_gdf, network_gdf, how="inner", predicate="intersects") + print(f"Joined DataFrame shape after spatial join: {joined.shape}") + + if joined.empty: + print("No intersections found between H3 cells and network geometries.") + return pd.DataFrame() + + # Calculate intersections and lengths + def calculate_intersection(row): + try: + h3_poly = Polygon(h3.h3_to_geo_boundary(row['h3_cell'], geo_json=True)) + line = row['geometry'] + intersection = h3_poly.intersection(line) + return pd.Series({'intersection_length': intersection.length}) + except Exception as e: + print(f"Error in calculate_intersection: {e}") + return pd.Series({'intersection_length': 0}) + + tqdm.pandas(desc="Calculating intersections") + joined['intersection_length'] = joined.progress_apply(calculate_intersection, axis=1) + + # Calculate length ratios + joined['length_ratio'] = joined['intersection_length'] / joined['linkLength'] + + # Keep only necessary columns + intersection_df = joined[['h3_cell', 'linkId', 'length_ratio']] + + intersection_df.to_csv(f'{output_dir}/network.h3.csv', index=False) + + return intersection_df + + +def process_h3_data(h3_df, data_df, data_col): + """ + Process H3 data for a given data column + + Args: + h3_df: H3 intersection dataframe + data_df: Data dataframe + data_col: Column name for data to process + + Returns: + DataFrame with H3 cell data + """ + print(f"Initial emissions_df shape: {data_df.shape}") + + # Filter emissions data for the specific pollutant + data_df[data_col] = pd.to_numeric(data_df[data_col], errors='coerce') + data_df_filtered = data_df.dropna() + print(f"Filtered emissions shape: {data_df_filtered.shape}") + + # Merge with intersection data + merged = pd.merge(h3_df, data_df_filtered, on='linkId', how='inner') + print(f"Merged DataFrame shape: {merged.shape}") + + # Calculate normalized emissions + merged[f'weighted_{data_col}'] = merged[data_col] * merged['length_ratio'] + + # Group by H3 cell and sum normalized emissions + result = merged.groupby(['scenario', 'h3_cell'])[f'weighted_{data_col}'].sum().reset_index() + print(f"Final result shape: {result.shape}") + return result + + +def process_h3_emissions(emissions_df, intersection_df, pollutant): + """ + Process H3 emissions data for a specific pollutant + + Args: + emissions_df: Emissions dataframe + intersection_df: H3 intersection dataframe + pollutant: Pollutant name + + Returns: + DataFrame with H3 cell emissions data + """ + print(f"Initial emissions_df shape: {emissions_df.shape}") + + # Filter emissions data for the specific pollutant + filtered_emissions = emissions_df[emissions_df['pollutant'] == pollutant][['scenario', 'linkId', 'rate']] + filtered_emissions['rate'] = pd.to_numeric(filtered_emissions['rate'], errors='coerce') + filtered_emissions = filtered_emissions.dropna() + print(f"Filtered emissions shape: {filtered_emissions.shape}") + + # Merge with intersection data + merged = pd.merge(intersection_df, filtered_emissions, on='linkId', how='inner') + print(f"Merged DataFrame shape: {merged.shape}") + + # Calculate normalized emissions + merged[f'{pollutant}'] = merged['rate'] * merged['length_ratio'] + + # Group by H3 cell and sum normalized emissions + result = merged.groupby(['scenario', 'h3_cell'])[f'{pollutant}'].sum().reset_index() + print(f"Final result shape: {result.shape}") + return result + + +def calculate_delta_emissions(emissions_df, pollutant, scenario1, scenario2): + """ + Calculate delta emissions between two scenarios + + Args: + emissions_df: Emissions dataframe + pollutant: Pollutant name + scenario1: First scenario name + scenario2: Second scenario name + + Returns: + DataFrame with delta emissions data + """ + pivot_df = emissions_df.pivot(index='h3_cell', columns='scenario', values=pollutant).reset_index() + pivot_df = pivot_df.fillna(0) + pivot_df["scenario"] = f"{scenario1}-{scenario2}" + pivot_df[f'Delta_{pollutant}'] = pivot_df[scenario1] - pivot_df[scenario2] + return pivot_df + + +# ################ +# ##### Main ##### +# ################ + +if __name__ == "__main__": + # Input parameters + area = "sfbay" + batch = "2024-01-23" + mode_to_filter = "-TRUCK-" + expansion_factor = 1 / 0.1 + source_epsg = "EPSG:26910" + selected_pollutants = ['PM2_5', 'NOx', 'CO', 'ROG', 'CO2', 'HC'] + h3_resolution = 8 + + # File paths + emfac_vmt_file = os.path.expanduser( + f"~/Workspace/Models/emfac/Default_Statewide_2018_2025_2030_2040_2050_Annual_vmt_20240612233346.csv") + run_dir = os.path.expanduser(f"~/Workspace/Simulation/{area}/beam-runs/{batch}") + scenario_2018 = "2018_Baseline" + scenario_2050 = "2050_Refhighp6" + skims_2018_file = f"{run_dir}/{scenario_2018}/0.skimsEmissions.csv.gz" + skims_2050_file = f"{run_dir}/{scenario_2050}/0.skimsEmissions.csv.gz" + network_file = f"{run_dir}/network.csv.gz" + plan_dir = os.path.expanduser(f"~/Workspace/Simulation/{area}/beam-freight/{batch}") + types_2018_file = f"{plan_dir}/vehicle-tech/ft-vehicletypes--{scenario_2018.replace('_', '-')}-TrAP.csv" + types_2050_file = f"{plan_dir}/vehicle-tech/ft-vehicletypes--{scenario_2050.replace('_', '-')}-TrAP.csv" + tours_2018_file = f"{plan_dir}/{scenario_2018}/tours--{scenario_2018.replace('_', '-')}.csv" + tours_2050_file = f"{plan_dir}/{scenario_2050}/tours--{scenario_2050.replace('_', '-')}.csv" + carriers_2018_file = f"{plan_dir}/{scenario_2018}/carriers--{scenario_2018.replace('_', '-')}-TrAP.csv" + carriers_2050_file = f"{plan_dir}/{scenario_2050}/carriers--{scenario_2050.replace('_', '-')}-TrAP.csv" + + # Output directories + plot_dir = f'{run_dir}/_plots' + Path(plot_dir).mkdir(parents=True, exist_ok=True) + + # Create scenario labels + scenario_2018_label = scenario_2018.replace("_", " ") + scenario_2050_label = scenario_2050.replace("_", " ").replace("HOPhighp2", "HAVF") + + print("Loading network data...") + network = load_network(network_file, source_epsg) + network_h3_intersection = generate_h3_intersections(network, h3_resolution, run_dir) + + print("Processing skims data...") + skims_2018 = read_skims_emissions_chunked( + skims_2018_file, + types_2018_file, + mode_to_filter, + network, + expansion_factor, + scenario_2018_label + ) + + skims_2050 = read_skims_emissions_chunked( + skims_2050_file, + types_2050_file, + mode_to_filter, + network, + expansion_factor, + scenario_2050_label + ) + + skims = pd.concat([skims_2018, skims_2050]) + print(f"Read {len(skims)} rows of skims") + + print("Processing FAMOS tours data...") + # Load tours data + tours_2018 = pd.read_csv(tours_2018_file)[["tourId", 'departureTimeInSec']] + tours_2050 = pd.read_csv(tours_2050_file)[["tourId", 'departureTimeInSec']] + carriers_2018 = pd.read_csv(carriers_2018_file)[["tourId", 'vehicleTypeId']] + carriers_2050 = pd.read_csv(carriers_2050_file)[["tourId", 'vehicleTypeId']] + types_2018 = pd.read_csv(types_2018_file)[ + ["vehicleTypeId", 'vehicleCategory', 'primaryFuelType', 'secondaryFuelType']] + types_2050 = pd.read_csv(types_2050_file)[ + ["vehicleTypeId", 'vehicleCategory', 'primaryFuelType', 'secondaryFuelType']] + + # Process and merge tours data + tours_types_2018 = pd.merge(tours_2018, pd.merge(carriers_2018, types_2018, on="vehicleTypeId"), on="tourId") + tours_types_2018["scenario"] = scenario_2018_label + tours_types_2050 = pd.merge(tours_2050, pd.merge(carriers_2050, types_2050, on="vehicleTypeId"), on="tourId") + tours_types_2050["scenario"] = scenario_2050_label + famos_tours = pd.concat([tours_types_2018, tours_types_2050]) + + print("Calculating VMT...") + famos_vmt = skims.groupby(['scenario', 'hour', 'beamFuel', 'class'])['vmt'].sum().reset_index().copy() + + print("Creating VMT comparison with EMFAC...") + emfac_famos_vmt = create_model_vmt_comparison_chart( + emfac_vmt_file, area, 2050, skims, scenario_2050_label, plot_dir + ) + + print("Processing activities...") + driving_process_activity = skims[ + (skims["process"].isin(["RUNEX", "PMBW", "PMTW", "RUNLOSS"])) & + (skims["vht"] > 0) + ].groupby(["scenario", "linkId"])["vmt"].sum().reset_index(name="vmt") + + h3_vmt = process_h3_data(network_h3_intersection, driving_process_activity, "vmt") + vmt_column = "Weighted VMT from driving activities" + h3_vmt.rename(columns={"weighted_vmt": vmt_column}, inplace=True) + + parking_process_activity = skims[ + (skims["process"].isin(["STREX", "DIURN", "HOTSOAK", "RUNLOSS", "IDLEX"])) & + (skims["vht"] == 0) + ].groupby(["scenario", "linkId"]).size().reset_index(name='count') + + h3_count = process_h3_data(network_h3_intersection, parking_process_activity, "count") + count_column = "Weighted count of parking activities" + h3_count.rename(columns={"weighted_count": count_column}, inplace=True) + + print("Processing emissions...") + # Process each pollutant + pm25 = process_h3_emissions(skims, network_h3_intersection, 'PM2_5') + nox = process_h3_emissions(skims, network_h3_intersection, 'NOx') + co = process_h3_emissions(skims, network_h3_intersection, 'CO') + co2 = process_h3_emissions(skims, network_h3_intersection, 'CO2') + + # Convert to grams per square meter + pm25_column = "PM2_5 in grams per square meter" + pm25[pm25_column] = pm25["PM2_5"] * 1e6 # from metric ton to gram + + nox_column = "NOx in grams per square meter" + nox[nox_column] = nox["NOx"] * 1e6 + + co_column = "CO in grams per square meter" + co[co_column] = co["CO"] * 1e6 + + co2_column = "CO2 in grams per square meter" + co2[co2_column] = co2["CO2"] * 1e6 + + print("Calculating delta emissions...") + # Calculate delta emissions between scenarios + # PM2.5 delta + pm25_delta = pm25.pivot(index='h3_cell', columns='scenario', values='PM2_5').reset_index() + pm25_delta = pm25_delta.fillna(0) + pm25_delta["scenario"] = "-".join([scenario_2050_label, scenario_2018_label]) + pm25_delta['Delta_PM2_5'] = pm25_delta[scenario_2050_label] - pm25_delta[scenario_2018_label] + pm25_delta_column = "Delta PM2_5 in grams per square meter" + pm25_delta[pm25_delta_column] = pm25_delta["Delta_PM2_5"] * 1e6 + + # NOx delta + nox_delta = nox.pivot(index='h3_cell', columns='scenario', values='NOx').reset_index() + nox_delta = nox_delta.fillna(0) + nox_delta["scenario"] = "-".join([scenario_2050_label, scenario_2018_label]) + nox_delta['Delta_NOx'] = nox_delta[scenario_2050_label] - nox_delta[scenario_2018_label] + nox_delta_column = "Delta NOx in grams per square meter" + nox_delta[nox_delta_column] = nox_delta["Delta_NOx"] * 1e6 + + # CO2 delta + co2_delta = co2.pivot(index='h3_cell', columns='scenario', values='CO2').reset_index() + co2_delta = co2_delta.fillna(0) + co2_delta["scenario"] = "-".join([scenario_2050_label, scenario_2018_label]) + co2_delta['Delta_CO2'] = co2_delta[scenario_2050_label] - co2_delta[scenario_2018_label] + co2_delta_column = "Delta CO2 in grams per square meter" + co2_delta[co2_delta_column] = co2_delta["Delta_CO2"] * 1e6 + + print("Generating plots...") + # Figure 1: Activity plots + plot_hourly_activity(famos_tours, fuel_beam2emfac_map, plot_dir, height_size=6) + plot_hourly_vmt(famos_vmt, plot_dir, height_size=6) + + # Figure 2: VMT comparison + plot_multi_pie_emfac_famos_vmt(emfac_famos_vmt, plot_dir) + + # Figure 3: Activity heatmaps + plot_h3_heatmap(h3_vmt, vmt_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, + in_log_scale=True) + plot_h3_heatmap(h3_count, count_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, + in_log_scale=True) + + # Figure 4: Emissions heatmaps + plot_h3_heatmap(pm25, pm25_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, + in_log_scale=True) + plot_h3_heatmap(nox, nox_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, + in_log_scale=True) + plot_h3_heatmap(co2, co2_column, scenario_2018_label, plot_dir, is_delta=False, remove_outliers=True, + in_log_scale=True) + + # Figure 5: Hourly emissions + plot_hourly_emissions_by_scenario_class_fuel(skims, 'PM2_5', plot_dir, plot_legend=True, height_size=6, + font_size=24) + plot_hourly_emissions_by_scenario_class_fuel(skims, 'NOx', plot_dir, plot_legend=True, height_size=6, font_size=24) + plot_hourly_emissions_by_scenario_class_fuel(skims, 'CO2', plot_dir, plot_legend=True, height_size=6, font_size=24) + + # Figure 6: Delta emissions heatmaps + plot_h3_heatmap(pm25_delta, pm25_delta_column, "-".join([scenario_2050_label, scenario_2018_label]), plot_dir, + is_delta=True, remove_outliers=True, in_log_scale=True) + plot_h3_heatmap(nox_delta, nox_delta_column, "-".join([scenario_2050_label, scenario_2018_label]), plot_dir, + is_delta=True, remove_outliers=True, in_log_scale=True) + plot_h3_heatmap(co2_delta, co2_delta_column, "-".join([scenario_2050_label, scenario_2018_label]), plot_dir, + is_delta=True, remove_outliers=True, in_log_scale=True) + + # Figure 7: Pollution variability + plot_pollution_variability_by_process_vehicle_types(skims, "PM2_5", scenario_2018_label, plot_dir, height_size=6, + font_size=24) + plot_pollution_variability_by_process_vehicle_types(skims, "NOx", scenario_2018_label, plot_dir, height_size=6, + font_size=24) + plot_pollution_variability_by_process_vehicle_types(skims, "CO2", scenario_2018_label, plot_dir, height_size=6, + font_size=24) + + plot_pollutants_by_process(skims, scenario_2018_label, plot_dir, height_size=6, font_size=24) + plot_pollutants_by_process(skims, scenario_2050_label, plot_dir, height_size=6, font_size=24) + + print("Processing completed successfully.") \ No newline at end of file diff --git a/src/main/python/emissions/todo_distribute_vehicle_types.py b/src/main/python/emissions/todo_distribute_vehicle_types.py new file mode 100644 index 00000000000..afa3aa5915a --- /dev/null +++ b/src/main/python/emissions/todo_distribute_vehicle_types.py @@ -0,0 +1,57 @@ +import math +import os + +import pandas as pd + + +def unpacking_ft_vehicle_population_mesozones(carriers, mesozones_to_county_file, mesozones_lookup_file): + import pygris + # ### Mapping counties with Mesozones ### + if not os.path.exists(mesozones_to_county_file): + county_data = pygris.counties(state='06', year=2018, cb=True, cache=True) + cbg_data = pygris.block_groups(state='06', year=2018, cb=True, cache=True) + county_data_clipped = county_data[['COUNTYFP', 'NAME']] + cbg_data_clipped = cbg_data[['GEOID', 'COUNTYFP']] + cbg_to_county = pd.merge(cbg_data_clipped, county_data_clipped, on="COUNTYFP", how='left') + mesozones_lookup = pd.read_csv(mesozones_lookup_file, dtype=str) + mesozones_lookup_clipped = mesozones_lookup[['MESOZONE', 'GEOID']] + mesozones_to_county = pd.merge(mesozones_lookup_clipped, cbg_to_county, on='GEOID', how='left') + mesozones_to_county.to_csv(mesozones_to_county_file, index=False) + else: + mesozones_to_county = pd.read_csv(mesozones_to_county_file, dtype=str) + + # TODO For future improvement find a way to map outside study area mesozones. It's a significant effort because + # TODO need to also restructure EMFAC in such a way vehicle population from outside study area well represented + if not mesozones_to_county[mesozones_to_county["NAME"].isna()].empty: + print("Mesozones outside study area do not have a proper GEOID and were not mapped.") + mesozones_to_county_studyarea = mesozones_to_county[mesozones_to_county["NAME"].notna()][["MESOZONE", "NAME"]] + + # ### Mapping freight carriers with counties, payload and vehicle types ### + carriers_by_zone = pd.merge(carriers, mesozones_to_county_studyarea, left_on='warehouseZone', + right_on='MESOZONE', how='left') + if not carriers_by_zone[carriers_by_zone['NAME'].isna()].empty: + print( + "Something went wrong with the mapping of freight carrier zones with mesozones. Here the non mapped ones:") + print(carriers_by_zone[carriers_by_zone['NAME'].isna()]) + carriers_by_zone = carriers_by_zone[['tourId', 'vehicleId', 'vehicleTypeId', 'NAME']].rename( + columns={'NAME': 'zone'}) + + return carriers_by_zone + + +def calculate_truck_ownership_probability(income): + """ + Calculate the probability of truck ownership based on household income. + + :param income: Household income in thousands of dollars per year + :return: Probability of truck ownership (0 to 1) + """ + k = 0.1 # Steepness parameter + x0 = 80 # Income at which probability is 0.5 + + # Calculate probability using logistic function + probability = 1 / (1 + math.exp(-k * (income - x0))) + + return probability + + diff --git a/src/main/python/freight/__init__.py b/src/main/python/freight/__init__.py new file mode 100644 index 00000000000..f49f713c5a3 --- /dev/null +++ b/src/main/python/freight/__init__.py @@ -0,0 +1 @@ +# python/freight/__init__.py \ No newline at end of file diff --git a/src/main/python/freight/estimate_stop_duration.py b/src/main/python/freight/estimate_stop_duration.py new file mode 100644 index 00000000000..8e5974d7afb --- /dev/null +++ b/src/main/python/freight/estimate_stop_duration.py @@ -0,0 +1,917 @@ +import math +import os +import sys + +import numpy as np +import pandas as pd +import random +from collections import defaultdict + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) + +# Go up to the parent directory that contains the 'python' directory +# If your file is in /path/to/python/freight/frism_to_beam_freight_plans.py +# This will add /path/to to sys.path +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +# Now use absolute import +from python.utils.study_area_config import BeamClasses +from python.utils.study_area_config import get_area_config + +vehicle_classes = BeamClasses.get_medium_heavy_freight_classes() + + +def sample_from_distribution(distribution_info): + """ + Sample a value from a distribution based on its parameters. + """ + if distribution_info['distribution'] == 'lognormal': + params = distribution_info['params'] + bounds = distribution_info['bounds'] + + # Sample from lognormal distribution + try: + sample = float(np.random.lognormal( + float(params['mu']), + float(params['sigma']) + )) + except (ValueError, TypeError): + # Fallback if parameters are invalid + sample = float(distribution_info['mean']) + + # Apply bounds + sample = max(float(bounds['min']), min(float(bounds['max']), sample)) + + # Round to nearest minute + return round(sample) + else: + # Default to mean if distribution type not recognized + return round(float(distribution_info['mean'])) + + +def get_base_duration(df, weight_dict): + """ + Calculate base duration for each vehicle class. + + Args: + df: DataFrame with survey data + weight_dict: Optional dictionary mapping weight ranges to bin labels + + Returns: + Dictionary mapping vehicle classes to base durations (in seconds) + """ + # Create a copy to avoid modifying the original DataFrame + df_copy = df.copy() + + # Create bins for cargo weights based on the weight_dict + df_copy['cargoWeightPU_bin'] = df_copy['cargoWeightPU'].apply(lambda x: get_weight_bin(x, weight_dict)) + df_copy['cargoWeightDO_bin'] = df_copy['cargoWeightDO'].apply(lambda x: get_weight_bin(x, weight_dict)) + + # Group by vehicle class, activity type, and weight bins + groupby_columns = ['vehicleClass', 'activityType', 'cargoWeightPU_bin', 'cargoWeightDO_bin'] + + # Group and calculate average operation duration + grouped_data = df_copy.groupby(groupby_columns)['operationDurationInMin'].agg(['mean', 'count']).reset_index() + + print("\nGrouped data summary:") + print(f"Total groups: {len(grouped_data)}") + + # Find the minimum average duration for each vehicle class across all combinations + min_durations = {} + for vehicle_class in vehicle_classes: + class_data = grouped_data[grouped_data['vehicleClass'] == vehicle_class].copy().reset_index() + + min_duration = class_data['mean'].min() + min_durations[vehicle_class] = min_duration + print(f"{vehicle_class}: Minimum average duration = {min_duration:.2f} minutes") + + # Show the specific combination that resulted in the minimum + if len(class_data) > 0: + min_idx = class_data[class_data['mean'] == min_duration].index[0] + min_row = class_data.iloc[min_idx] + print(f" Combination: {min_row[groupby_columns].to_dict()}") + print(f" Count: {min_row['count']} records") + + # Convert minutes to seconds for the base_duration dictionary + min_durations_in_sec = {} + for vehicle_class, min_duration in min_durations.items(): + # Convert to seconds and round to nearest minute + min_durations_in_sec[vehicle_class] = int(round(min_duration * 60 / 60) * 60) + + return min_durations_in_sec + + +def get_weight_factor(df, base_duration, operation_dict): + """ + Calculate weight factor for each vehicle class based on the relationship between + cargo weight and operation duration in the survey data. + """ + # Create a copy to avoid warnings + df_copy = df.copy() + + # Group by vehicle class + weight_factors = {} + + for vehicle_class in vehicle_classes: + class_data = df_copy[df_copy['vehicleClass'] == vehicle_class].copy() + loading_df = class_data[class_data['activityType'] == operation_dict["loading"]].copy() + unloading_df = class_data[class_data['activityType'] == operation_dict["unloading"]].copy() + + # Set effective weight for each activity type + loading_df['effectiveWeight'] = loading_df['cargoWeightPU'] + unloading_df['effectiveWeight'] = unloading_df['cargoWeightDO'] + + # Combine datasets for weight factor calculation + combined_df = pd.concat([loading_df, unloading_df]) + combined_df = combined_df[combined_df['effectiveWeight'] > 0] + + # Get base duration (convert seconds to minutes) + base = base_duration[vehicle_class] / 60 + + # Calculate individual factors for each record + combined_df['individual_factor'] = (combined_df['operationDurationInMin'] - base) / combined_df['effectiveWeight'] + + # Use median to avoid remaining outliers + median_factor = combined_df['individual_factor'].median() + + # Convert from minutes/kg to seconds/kg + weight_factors[vehicle_class] = max(0, median_factor * 60) + + + print("\nWeight factors:") + for vehicle_class, factor in weight_factors.items(): + print(f" {vehicle_class}: {factor:.6f} seconds per kg") + + return weight_factors + + +def get_operation_factor(df, operation_dict): + """ + Calculate operation factor (loading vs unloading) for each vehicle class. + """ + # Create a copy to avoid warnings + df_copy = df.copy() + + # Group and calculate average operation duration normalized by weight + grouped_data = df_copy.groupby(['vehicleClass', 'activityType'])['operationDurationInMin'].mean().reset_index() + + # Calculate operation factors relative to unloading + operation_factors = {} + + for vehicle_class in vehicle_classes: + class_data = grouped_data[grouped_data['vehicleClass'] == vehicle_class] + loading_df = class_data[class_data['activityType'] == operation_dict["loading"]] + unloading_df = class_data[class_data['activityType'] == operation_dict["unloading"]] + + loading_duration = loading_df['operationDurationInMin'].values[0] + unloading_duration = unloading_df['operationDurationInMin'].values[0] + + loading_ratio = loading_duration / (loading_duration+unloading_duration) + unloading_ratio = 1 - loading_ratio + + operation_factors[vehicle_class] = { + 'loading': 2 * loading_ratio, + 'unloading': 2 * unloading_ratio + } + + print("\nOperation factors:") + for vehicle_class, factors in operation_factors.items(): + print(f" {vehicle_class}: loading = {factors['loading']:.2f}, unloading = {factors['unloading']:.2f}") + + return operation_factors + + +def extract_weight_bins(df, operation_dict, num_bins=7): + """ + Extract weight bins from the data dynamically. + + Args: + df: DataFrame with weight data + num_bins: Number of bins to create + + Returns: + Dictionary mapping (lower, upper) bounds to bin labels + """ + # Combine pickup and delivery weights + weights = [] + for _, row in df.iterrows(): + if row['activityType'] == operation_dict["loading"]: + weights.append(row['cargoWeightPU']) + elif row['activityType'] == operation_dict["unloading"]: + weights.append(row['cargoWeightDO']) + + # Remove extreme outliers to prevent skewing the bin boundaries + weights = np.array(weights) + q1, q3 = np.percentile(weights, [25, 75]) + iqr = q3 - q1 + lower_bound = q1 - 1.5 * iqr + upper_bound = q3 + 1.5 * iqr + filtered_weights = weights[(weights >= max(0, lower_bound)) & (weights <= upper_bound)] + + # Use percentile-based bins to ensure even distribution of data + percentiles = np.linspace(0, 100, num_bins + 1) + bin_edges = np.percentile(filtered_weights, percentiles) + + # Round bin edges for better readability + bin_edges = np.unique([round(edge, -1) for edge in bin_edges]) + + # Ensure the bins are strictly increasing + bin_edges = np.unique(bin_edges) + if bin_edges[0] > 0: + bin_edges = np.insert(bin_edges, 0, 0) + if bin_edges[-1] != float('inf'): + bin_edges = np.append(bin_edges, float('inf')) + + # Create weight_dict + weight_dict = {} + for i in range(len(bin_edges) - 1): + lower = bin_edges[i] + upper = bin_edges[i + 1] + + # Format the label based on weight magnitude + if upper < 1000: + label = f"{int(lower)}-{int(upper)}lb" + elif upper < 10000: + label = f"{int(lower / 1000)}k-{int(upper / 1000)}klb" + elif upper == float('inf'): + label = f"{int(lower / 1000)}k+lb" + else: + label = f"{int(lower / 1000)}k-{int(upper / 1000)}klb" + + # For the last bin, use infinity + if i == len(bin_edges) - 2: + label = f"{int(lower)}+lb" + + weight_dict[(lower, upper)] = label + + return weight_dict + + +def get_weight_bin(weight_value, weight_dict): + """ + Determine the weight bin for a given weight value. + + Args: + weight_value: The weight value + weight_dict: Dictionary mapping (lower, upper) bounds to bin labels + + Returns: + The bin label for the weight value + """ + for (lower, upper), label in weight_dict.items(): + if lower <= weight_value < upper: + return label + + # Fallback for any value not covered (should not happen with properly defined bins) + return list(weight_dict.values())[-1] # Return the highest bin + + +def calculate_lognormal_params(mean, std): + """ + Calculate mu and sigma parameters for lognormal distribution + given desired mean and standard deviation. + """ + # Avoid division by zero or negative values + if mean <= 0 or std <= 0: + return {'mu': 0, 'sigma': 1} + + # Calculate variance + variance = std ** 2 + + # Calculate sigma squared + sigma_squared = math.log(1 + (variance / (mean ** 2))) + + # Calculate sigma + sigma = math.sqrt(sigma_squared) + + # Calculate mu + mu = math.log(mean) - (sigma_squared / 2) + + return {'mu': mu, 'sigma': sigma} + + +def build_operation_duration_model_from_austin_survey(survey_file_path, variability_exponent=0.7): + # Process the survey data to extract parameters + operation_dict, weight_dict, base_durations, weight_factors, operation_factors, variability_factors = \ + process_austin_survey_data(survey_file_path) + + # Create the model class + duration_model = OperationDurationModel( + operation_dict, + weight_dict, + base_durations, + weight_factors, + operation_factors, + variability_factors, + variability_exponent + ) + + return duration_model + + + +def build_operation_duration_model(operation_dict, weight_dict, base_durations, + weight_factors, operation_factors, variability_factors, + variability_exponent=0.7): + """ + Build a nested model for operation durations from predefined factors. + + Args: + weight_dict: Dictionary mapping weight ranges to bin labels + base_durations: Dictionary mapping vehicle classes to base durations (in seconds) + weight_factors: Dictionary mapping vehicle classes to weight factors (seconds per lb) + operation_factors: Nested dictionary mapping vehicle classes and operation types to factors + variability_factors: Dictionary mapping vehicle classes to variability factors + variability_exponent: Exponent for the utility-based variability model (default: 0.7) + + Returns: + Nested model structure + """ + # Build the nested model structure + model = { + "weight_dict": weight_dict, + "sample_func": sample_operation_duration + } + + # First level: Vehicle Class + for vehicle_class in vehicle_classes: + model[vehicle_class] = {} + + # Get the variability factor for this vehicle class + variability = variability_factors[vehicle_class] + + # Second level: Operation Type (fixed missing .items()) + for operation_key, standard_op_type in operation_dict.items(): + model[vehicle_class][standard_op_type] = {} + + # Get operation factor for this combination + op_factor = operation_factors[vehicle_class][standard_op_type] + + # Third level: Weight Bins + for (lower_bound, upper_bound), bin_label in weight_dict.items(): + # Calculate the midpoint of the weight bin for reference + if upper_bound == float('inf'): + midpoint = lower_bound * 1.5 + else: + midpoint = (lower_bound + upper_bound) / 2 + + # Get the base duration for this vehicle class (in seconds) + base = base_durations[vehicle_class] + + # Get the weight factor for this vehicle class (seconds per lb) + weight_factor = weight_factors[vehicle_class] + + # Calculate mean duration using the formula + mean_duration_sec = (base + midpoint * weight_factor) * op_factor + + # Convert to minutes + mean_duration_min = mean_duration_sec / 60 + + # Utility approach: variability is a non-linear function of duration + # Using the configurable exponent parameter + std_duration_min = variability * mean_duration_min ** variability_exponent + + # Create the distribution parameters + model[vehicle_class][standard_op_type][bin_label] = { + 'distribution': 'lognormal', # More realistic for durations + 'params': calculate_lognormal_params(mean_duration_min, std_duration_min), + 'mean': mean_duration_min, + 'std': std_duration_min, + 'count': 10, # Add a default count for compatibility + 'bounds': { + 'min': max(1, mean_duration_min - 2.5 * std_duration_min), + 'max': mean_duration_min + 3 * std_duration_min + } + } + + return model + + +def find_closest_bin(weight_lbs, weight_bins, available_bins): + # Find closest bin based on numeric weight value + closest_bin = available_bins[0] + closest_distance = float('inf') + + for bin_name in available_bins: + # Find the bin that would contain this weight + for (lower, upper), label in weight_bins.items(): + if label == bin_name: + # Calculate midpoint of this bin + if upper == float('inf'): + midpoint = lower * 1.5 # Approximate midpoint for highest bin + else: + midpoint = (lower + upper) / 2 + + # Check if this is closer to our target weight + distance = abs(midpoint - weight_lbs) + if distance < closest_distance: + closest_distance = distance + closest_bin = bin_name + break + + return closest_bin + + +def sample_operation_duration(model, vehicle_class, operation_type, weight_lbs, fallback_duration=30): + """ + Sample an operation duration from the model based on vehicle class, operation type, and weight. + """ + # Handle empty model + if not model or vehicle_class not in model or operation_type not in model[vehicle_class]: + return fallback_duration + + # Get weight dictionary + weight_dict = model.get("weight_dict", {}) + if not weight_dict: + return fallback_duration + + # Determine weight bin + weight_bin = get_weight_bin(weight_lbs, weight_dict) + + # If weight bin isn't found in the model for this combination, find closest bin + if weight_bin not in model[vehicle_class][operation_type]: + available_bins = list(model[vehicle_class][operation_type].keys()) + if not available_bins: + return fallback_duration + weight_bin = find_closest_bin(weight_lbs, weight_dict, available_bins) + + # Get the distribution for this combination + distribution = model[vehicle_class][operation_type][weight_bin] + + # Sample a duration using the distribution parameters + return sample_from_distribution(distribution) + + +def process_austin_survey_data(survey_file_path): + """ + Process the Austin survey data to extract parameters for the operation duration model. + + Args: + survey_file_path: Path to the survey data file + + Returns: + Tuple of (vehicle_classes, operation_dict, base_durations, weight_factors, + operation_factors, variability_factors, weight_dict) + """ + print("Loading survey data from:", survey_file_path) + + # Load the survey data + survey_data = pd.read_csv(survey_file_path) + + print("Extracting model parameters from survey data...") + # Print summary of the survey data + print(f"Found {len(survey_data)} valid records in survey data") + print(f"Vehicle classes: {', '.join(survey_data['vehicleClass'].unique())}") + print(f"Activity types: {', '.join(survey_data['activityType'].unique())}") + + operation_dict = { + 'loading': 'Pick up Cargo', + 'unloading': 'Delivery of Cargo' + } + + # Filter data for relevant activity types and vehicle classes + survey_data2 = survey_data[survey_data['activityType'].isin(operation_dict.values())] + survey_data2 = survey_data2[survey_data2['vehicleClass'].isin(vehicle_classes)].copy() + + # Use the extract_weight_bins function to get data-driven weight bins + weight_dict = extract_weight_bins(survey_data2, operation_dict) + + # Print the extracted weight bins + print("\nExtracted weight bins:") + for (lower, upper), label in sorted(weight_dict.items(), key=lambda x: x[0][0]): + print(f" {label}: {lower} to {upper} lbs") + + # Extract base durations + base_durations = get_base_duration(survey_data2, weight_dict) + print("\nExtracted base durations (seconds):") + for vc, duration in base_durations.items(): + print(f" {vc}: {duration} seconds") + + # Extract weight factors + weight_factors = get_weight_factor(survey_data2, base_durations, operation_dict) + print("\nExtracted weight factors (seconds per lb):") + for vc, factor in weight_factors.items(): + print(f" {vc}: {factor:.6f} seconds per lb") + + # Extract operation factors + operation_factors = get_operation_factor(survey_data2, operation_dict) + print("\nExtracted operation factors:") + for vc, factors in operation_factors.items(): + print(f" {vc}: loading={factors['loading']:.2f}, unloading={factors['unloading']:.2f}") + + # Calculate variability factors from the data + variability_factors = {} + for vehicle_class in vehicle_classes: + # Filter data for this vehicle class + class_data = survey_data2[survey_data2['vehicleClass'] == vehicle_class] + # Calculate coefficient of variation (std/mean) + cv = class_data['operationDurationInMin'].std() / class_data['operationDurationInMin'].mean() + # Adjust CV to work with our utility model + variability_factors[vehicle_class] = min(0.5, max(0.1, cv)) + + print("\nCalculated variability factors:") + for vc, factor in variability_factors.items(): + print(f" {vc}: {factor:.2f}") + + return operation_dict, weight_dict, base_durations, weight_factors, operation_factors, variability_factors + + +def update_operation_duration(study_area_config, payloads, tours, carriers, vehicle_types): + """ + Update operation durations based on factors extracted from survey data. + """ + survey_file_path = os.path.join(study_area_config["work_dir"], + study_area_config["freight"]["stops_data"]) + + # Create and load the model + duration_model = SimpleStopDurationModel() + duration_model.load_survey_data(survey_file_path) + + # # Build the model from Austin survey data + # duration_model = build_operation_duration_model_from_austin_survey(survey_file_path) + + # Print model summary + duration_model.print_summary() + + # Create a copy to avoid modifying the original DataFrame + updated_payloads = payloads.copy() + + # Merge tours with carriers and vehicle_types to get vehicle information + tours_with_vehicle = tours.merge( + carriers, + on='tourId', + how='left' + ) + + # Now merge with vehicle_types + tours_with_vehicle = tours_with_vehicle.merge( + vehicle_types, + on='vehicleTypeId', + how='left' + ) + + tours_with_vehicle = tours_with_vehicle.drop_duplicates(subset=['tourId', 'vehicleTypeId'], keep='first') + + # Then, merge payloads with the combined tours/vehicle data to get vehicle info for each payload + payload_with_vehicle = updated_payloads.merge( + tours_with_vehicle[['tourId', 'vehicleCategory']], + on='tourId', + how='left' + ) + + # Calculate updated durations + def calculate_duration(row): + # Sample from the model + duration_min = duration_model.sample_duration( + row['vehicleCategory'], + row['requestType'], + row['weightInKg'] * 2.20462, # Convert kg to lbs + randomize_factor=0 + ) + # Convert to seconds + return duration_min * 60 + + # Apply the calculation to each row + payload_with_vehicle['operationDurationInSec'] = payload_with_vehicle.apply(calculate_duration, axis=1) + + updated_columns = payloads.columns.tolist() + return payload_with_vehicle[updated_columns] + + +class OperationDurationModel: + def __init__(self, operation_dict, weight_dict, base_durations, weight_factors, operation_factors, + variability_factors, variability_exponent=0.7): + """ + Initialize the operation duration model. + + Args: + operation_dict: Dictionary mapping operation keys to operation types + weight_dict: Dictionary mapping weight ranges to bin labels + base_durations: Dictionary mapping vehicle classes to base durations (in seconds) + weight_factors: Dictionary mapping vehicle classes to weight factors (seconds per lb) + operation_factors: Nested dictionary mapping vehicle classes and operation types to factors + variability_factors: Dictionary mapping vehicle classes to variability factors + variability_exponent: Exponent for the utility-based variability model (default: 0.7) + """ + self.operation_dict = operation_dict + self.weight_bins = weight_dict + self.base_durations = base_durations + self.weight_factors = weight_factors + self.operation_factors = operation_factors + self.variability_factors = variability_factors + self.variability_exponent = variability_exponent + + # Build the model structure + self.model = self._build_model() + + def _build_model(self): + """Build the nested model structure from the provided factors.""" + model = {} + + # First level: Vehicle Class + for vehicle_class in vehicle_classes: + model[vehicle_class] = {} + + # Get the variability factor for this vehicle class + variability = self.variability_factors[vehicle_class] + + # Second level: Operation Type + for operation_key, standard_op_type in self.operation_dict.items(): + model[vehicle_class][operation_key] = {} + + # Get operation factor for this combination + op_factor = self.operation_factors[vehicle_class][operation_key] + + # Third level: Weight Bins + for (lower_bound, upper_bound), bin_label in self.weight_bins.items(): + # Calculate the midpoint of the weight bin for reference + if upper_bound == float('inf'): + midpoint = lower_bound * 1.5 + else: + midpoint = (lower_bound + upper_bound) / 2 + + # Get the base duration for this vehicle class (in seconds) + base = self.base_durations[vehicle_class] + + # Get the weight factor for this vehicle class (seconds per lb) + weight_factor = self.weight_factors[vehicle_class] + + # Calculate mean duration using the formula + mean_duration_sec = (base + midpoint * weight_factor) * op_factor + + # Convert to minutes + mean_duration_min = mean_duration_sec / 60 + + # Utility approach: variability is a non-linear function of duration + std_duration_min = variability * mean_duration_min ** self.variability_exponent + + # Create the distribution parameters + model[vehicle_class][operation_key][bin_label] = { + 'distribution': 'lognormal', + 'params': calculate_lognormal_params(mean_duration_min, std_duration_min), + 'mean': mean_duration_min, + 'std': std_duration_min, + 'count': 10, + 'bounds': { + 'min': max(1, mean_duration_min - 2.5 * std_duration_min), + 'max': mean_duration_min + 3 * std_duration_min + } + } + + return model + + + def sample_operation_duration(self, vehicle_class, operation_type, weight_lbs, fallback_duration=30): + """ + Sample an operation duration from the model based on vehicle class, operation type, and weight. + + Args: + vehicle_class: The vehicle class (e.g., 'Class456Vocational') + operation_type: Either 'loading' or 'unloading' + weight_lbs: The weight in pounds (lbs) + fallback_duration: Default duration if sampling fails + + Returns: + Duration in minutes + """ + # Handle empty model + if not self.model or vehicle_class not in self.model or operation_type not in self.model[vehicle_class]: + return fallback_duration + + # Determine weight bin + weight_bin = get_weight_bin(weight_lbs, self.weight_bins) + + # If weight bin isn't found in the model for this combination, find closest bin + if weight_bin not in self.model[vehicle_class][operation_type]: + available_bins = list(self.model[vehicle_class][operation_type].keys()) + if not available_bins: + return fallback_duration + weight_bin = find_closest_bin(weight_lbs, self.weight_bins, available_bins) + + + # Get the distribution for this combination + distribution = self.model[vehicle_class][operation_type][weight_bin] + + # Sample a duration using the distribution parameters + return sample_from_distribution(distribution) + + def print_summary(self): + """Print a summary of the model statistics.""" + print("Operation Duration Model Summary:") + for vehicle_class in self.model: + print(f"\nVehicle Class: {vehicle_class}") + for op_type in self.model[vehicle_class]: + print(f" Operation Type: {op_type}") + for weight_bin in self.model[vehicle_class][op_type]: + stats = self.model[vehicle_class][op_type][weight_bin] + print(f" {weight_bin}: mean={stats['mean']:.1f}min, std={stats['std']:.1f}min") + + +class SimpleStopDurationModel: + """ + A simplified decision tree model for stop durations based on: + - Vehicle class + - Operation type (loading/unloading) + - Weight bins + + The model samples actual durations from the survey data and adds randomness. + """ + + def __init__(self): + """Initialize the model with empty structure.""" + # Main structure to hold the decision tree + self.duration_tree = defaultdict( + lambda: defaultdict( + lambda: defaultdict(list) + ) + ) + + # Weight bins dictionary + self.weight_bins = {} + + # Operation type mapping + self.operation_dict = { + 'loading': 'Pick up Cargo', + 'unloading': 'Delivery of Cargo' + } + + # For reporting statistics + self.stats = {} + + def load_survey_data(self, survey_file_path): + """ + Load the Austin survey data and organize it into the decision tree. + + Args: + survey_file_path: Path to the survey data CSV file + """ + print(f"Loading survey data from: {survey_file_path}") + + # Load the survey data + survey_data = pd.read_csv(survey_file_path) + + # Print summary of the survey data + print(f"Found {len(survey_data)} records in survey data") + print(f"Vehicle classes: {', '.join(survey_data['vehicleClass'].unique())}") + print(f"Activity types: {', '.join(survey_data['activityType'].unique())}") + + # Filter data for relevant activity types and vehicle classes + filtered_data = survey_data[ + survey_data['activityType'].isin(self.operation_dict.values()) & + survey_data['vehicleClass'].isin(vehicle_classes) + ].copy() + + print(f"Filtered to {len(filtered_data)} relevant records") + + self.weight_bins = extract_weight_bins(filtered_data, self.operation_dict) + + # Build the decision tree from the filtered data + self._build_decision_tree(filtered_data) + + # Calculate statistics for reporting + self._calculate_statistics() + + return self + + def _build_decision_tree(self, data): + """ + Build the decision tree from the filtered data. + + Args: + data: Filtered DataFrame with survey data + """ + # Process each row in the data + for _, row in data.iterrows(): + # Get the vehicle class + vehicle_class = row['vehicleClass'] + + # Get the operation type + activity = row['activityType'] + operation_type = 'loading' if activity == self.operation_dict['loading'] else 'unloading' + + # Get the weight and determine its bin + weight = row['cargoWeightPU'] if operation_type == 'loading' else row['cargoWeightDO'] + + weight_bin = get_weight_bin(weight, self.weight_bins) + + # Get the duration + duration = row['operationDurationInMin'] + + # Add the duration to the appropriate leaf in the tree + self.duration_tree[vehicle_class][operation_type][weight_bin].append(duration) + + def _calculate_statistics(self): + """Calculate and store statistics for each leaf in the tree.""" + for vehicle_class in self.duration_tree: + self.stats[vehicle_class] = {} + + for operation_type in self.duration_tree[vehicle_class]: + self.stats[vehicle_class][operation_type] = {} + + for weight_bin in self.duration_tree[vehicle_class][operation_type]: + durations = self.duration_tree[vehicle_class][operation_type][weight_bin] + + if durations: + self.stats[vehicle_class][operation_type][weight_bin] = { + 'count': len(durations), + 'min': min(durations), + 'max': max(durations), + 'mean': sum(durations) / len(durations), + 'median': sorted(durations)[len(durations) // 2], + 'std': np.std(durations) if len(durations) > 1 else 0 + } + else: + # Empty leaf + self.stats[vehicle_class][operation_type][weight_bin] = { + 'count': 0, + 'min': 0, + 'max': 0, + 'mean': 0, + 'median': 0, + 'std': 0 + } + + + def sample_duration(self, vehicle_class, operation_type, weight_lbs, randomize_factor=1.0, fallback_duration=30): + """ + Sample a duration for the given vehicle class, operation type, and weight. + + Args: + vehicle_class: The vehicle class + operation_type: The operation type (loading/unloading) + weight_lbs: The weight in pounds + randomize_factor: Whether to add randomness to the sampled duration + + Returns: + The sampled duration in minutes + """ + # Get the weight bin + weight_bin = get_weight_bin(weight_lbs, self.weight_bins) + + # If the bin has no data, find the closest bin with data + if weight_bin not in self.duration_tree[vehicle_class][operation_type] or not \ + self.duration_tree[vehicle_class][operation_type][weight_bin]: + available_bins = list(self.duration_tree[vehicle_class][operation_type].keys()) + if not available_bins: + return fallback_duration + weight_bin = find_closest_bin(weight_lbs, self.weight_bins, available_bins) + + # Get the durations for this leaf + durations = self.duration_tree[vehicle_class][operation_type][weight_bin] + + # Sample a random duration from the available ones + duration = random.choice(durations) + + # Add randomness based on the randomize_factor + if randomize_factor > 0: + # Calculate standard deviation of durations in this bin + std = np.std(durations) if len(durations) > 1 else duration * 0.2 + + # Scale the standard deviation by the randomize_factor + scaled_std = std * randomize_factor * 0.5 + + # Add Gaussian noise, but ensure the duration remains positive + randomized_duration = max(1, duration + random.gauss(0, scaled_std)) + return randomized_duration + else: + return duration + + def print_summary(self): + """Print a summary of the model statistics.""" + print("\nSimple Stop Duration Model Summary:") + + for vehicle_class in sorted(self.stats.keys()): + print(f"\nVehicle Class: {vehicle_class}") + + for operation_type in sorted(self.stats[vehicle_class].keys()): + print(f" Operation Type: {operation_type}") + + for weight_bin in sorted(self.stats[vehicle_class][operation_type].keys(), + key=lambda x: next( + (lower for (lower, upper), label in self.weight_bins.items() if + label == x), 0)): + stats = self.stats[vehicle_class][operation_type][weight_bin] + print(f" {weight_bin}: " + f"n={stats['count']}, " + f"mean={stats['mean']:.1f}min, " + f"std={stats['std']:.1f}min, " + f"range=[{stats['min']:.1f}-{stats['max']:.1f}]") + + +if __name__ == '__main__': + STUDY_AREA_CONFIG = get_area_config("sfbay") + work_dir = STUDY_AREA_CONFIG["work_dir"] + scenario_config = STUDY_AREA_CONFIG["freight"]["2018_Baseline"] + + _payload_plans = pd.read_csv(str(os.path.join(work_dir, scenario_config["payloads_file"]))) + _tours = pd.read_csv(str(os.path.join(work_dir, scenario_config["tours_file"]))) + _carriers = pd.read_csv(str(os.path.join(work_dir, scenario_config["carriers_file"]))) + _vehicle_types = pd.read_csv(str(os.path.join(work_dir, scenario_config["ft_vehicle_types_file"]))) + + _payload_plans["operationDurationInSecOG"] = _payload_plans["operationDurationInSec"] + _payload_plans = update_operation_duration(STUDY_AREA_CONFIG, _payload_plans, _tours, _carriers, _vehicle_types) + _payload_plans.to_csv("outputs/payloads_test.csv", index=False) + + diff --git a/src/main/python/freight/freight_events_filtering.py b/src/main/python/freight/freight_events_filtering.py new file mode 100644 index 00000000000..276b9798c44 --- /dev/null +++ b/src/main/python/freight/freight_events_filtering.py @@ -0,0 +1,51 @@ +import pandas as pd +import os +import sys + +city = "austin" +# city = "sfbay" +scenario = "parking-sensitivity" +# batch = "Oct30/" +batch = "2018_unlimited/" +iteration = 0 +prefix = "" +filename = prefix+str(iteration)+'.events.csv.gz' +local_work_directory = '~/Workspace/Data/FREIGHT/'+city+'/beam/runs/'+scenario+'/'+batch +full_filename = os.path.expanduser(local_work_directory + filename) + +if len(sys.argv) >= 2: + full_filename = str(sys.argv[1]) + +def print2(msg): + with open(full_filename + ".out", 'w') as f: + print(msg) + print(msg, file=f) + +dirname = os.path.dirname(full_filename) +basename = os.path.basename(full_filename) + +compression = None +if basename.endswith(".gz"): + compression = 'gzip' + + +print2("reading: " + full_filename) +data = pd.read_csv(full_filename, sep=",", index_col=None, header=0, compression=compression) +print2(data.type.unique()) +data_filtered = data.loc[data.type.isin(["PathTraversal", "actstart", "actend"])] +print2(data_filtered.type.unique()) +data_filtered = data_filtered.loc[data_filtered.vehicle.str.startswith("freight", na=True)] +print2(data_filtered.type.unique()) +data_filtered2 = data_filtered.loc[data_filtered.actType.isin(["Warehouse", "Unloading", "Loading"]) | data_filtered.actType.isnull()] +print2(data_filtered.type.unique()) +# data_filtered2 = data_filtered[ +# ["time","type","vehicleType","vehicle","secondaryFuelLevel", +# "primaryFuelLevel","driver","mode","seatingCapacity","startX", +# "startY", "endX", "endY", "capacity", "arrivalTime", "departureTime", +# "secondaryFuel", "secondaryFuelType", "primaryFuelType", +# "numPassengers", "length", "primaryFuel", "actType", "fuel", "person", +# "locationY", "locationX", "duration", "chargingPointType", "parkingType", "parkingTaz"] +# ] +print2("writing to " + dirname + "/" + "filtered." + basename) +data_filtered2.to_csv(dirname + "/" + "filtered." + basename) +print2("END") diff --git a/src/main/python/freight/freight_events_processing.py b/src/main/python/freight/freight_events_processing.py index e96cabd5d31..fa77f1d470e 100644 --- a/src/main/python/freight/freight_events_processing.py +++ b/src/main/python/freight/freight_events_processing.py @@ -7,40 +7,50 @@ ## Main # city, batch, scenario, sample = "sfbay", "baseline", "2018", 0.1 -city, batch, scenario, sample = "sfbay", "2024-08-07", "2018_Baseline", 0.1 +# city, batch, scenario, sample = "sfbay", "2024-08-07", "2018_Baseline", 0.1 +city, batch, scenario, run, sample = "seattle", "2024-04-20", "2018_Baseline", "2018_Baseline_RPS", 0.1 +# city, batch, scenario, run, sample = "seattle", "2024-04-20", "2018_Baseline", "2018_Baseline", 0.1 # city, batch, scenario, sample = "seattle", "2024-09-24", "2018_Baseline", 0.1 # city, batch, scenario, sample = "seattle", "2024-04-20", "2018_Baseline", 0.3 # work_dir = os.path.expanduser(f"/Volumes/HG40/Workspace/Simulation/{city}") work_dir = os.path.expanduser(f"~/Workspace/Simulation/{city}") +run_directory = f'{work_dir}/beam-runs/{batch}/{run}/' +scenario_directory = f'{work_dir}/beam-freight/{batch}/{scenario}/' events_filename = f"0.events.csv.gz" linkstats_filename = f"0.linkstats.csv.gz" +scenario_label = scenario.replace("_", "-") +run_label = run.replace("_", "-") +batch_label = batch.replace("-", "") # pd.set_option('display.max_columns',10) scale_up_factor = 1 / sample def main(): - setup_logging(f'{work_dir}/beam-runs/{batch}/{scenario}/freight_events_processing.log') - log_and_print(f"Run: {city}/{batch}/{scenario}/{sample}") - scenario_dir = os.path.join(work_dir, "beam-freight", batch, scenario) + setup_logging(f'{run_directory}/freight_events_processing_{run}.log') - linkstats_file = os.path.join(get_local_work_directory(scenario), linkstats_filename) + linkstats_file = os.path.join(run_directory, linkstats_filename) if os.path.exists(linkstats_file): linkstats_df = pd.read_csv(linkstats_file) - calc_vmt_from_linkstats(linkstats_df, scenario) + calc_vmt_from_linkstats(linkstats_df) - scenario_label = scenario.replace("_", "-") - batch_label = batch.replace("-", "") - carrier_df = pd.read_csv(os.path.join(scenario_dir, f"carriers--{scenario_label}.csv")) - tour_df = pd.read_csv(os.path.join(scenario_dir, f"tours--{scenario_label}.csv")) - payload_df = pd.read_csv(os.path.join(scenario_dir, f"payloads--{scenario_label}.csv")) + carrier_df = pd.read_csv(os.path.join(scenario_directory, f"carriers--{scenario_label}.csv")) + tour_df = pd.read_csv(os.path.join(scenario_directory, f"tours--{scenario_label}.csv")) + payload_df = pd.read_csv(os.path.join(scenario_directory, f"payloads--{scenario_label}.csv")) vehicle_types = pd.read_csv( - os.path.join(scenario_dir, "vehicle-tech", f"ft-vehicletypes--{batch_label}--{scenario_label}.csv")) + os.path.join(scenario_directory, "vehicle-tech", f"ft-vehicletypes--{batch_label}--{scenario_label}.csv")) vehicle_types_combined = merge_vehicle_types(vehicle_types, carrier_df, tour_df) - processed_event = process_events(scenario, vehicle_types_combined) - calc_vmt_from_events(processed_event, scenario) + + # Process events and get the processed events dataframe + processed_events = process_events(vehicle_types_combined) + + # Compare events with payloads and analyze missing tours + compare_events_and_payloads(processed_events, payload_df, scenario_directory, run, scenario_label) + + # Calculate VMT from events + calc_vmt_from_events(processed_events) log_and_print(f"[FRISM] Total number of vehicles: {int(len(carrier_df['vehicleId'].unique()) * scale_up_factor)}") - trips_df = convert_payload_to_trips(payload_df, scenario) + trips_df = convert_payload_to_trips(payload_df) summary = trips_by_vehicle_class(trips_df, carrier_df, vehicle_types) log_and_print("END") @@ -67,12 +77,12 @@ def merge_vehicle_types(vehicle_types: pd.DataFrame, carrier_df: pd.DataFrame, t return result2_df -def process_events(scenario, vehicle_types_combined): - events_filepath = os.path.join(get_local_work_directory(scenario), events_filename) - processed_events_filepath = os.path.join(get_local_work_directory(scenario), f"updated.filtered.{events_filename}") +def process_events(vehicle_types_combined): + events_filepath = os.path.join(run_directory, events_filename) + processed_events_filepath = os.path.join(run_directory, f"updated.filtered.{events_filename}") if not os.path.exists(processed_events_filepath): - events = read_events_file(events_filepath, scenario) + events = read_events_file(events_filepath, run) vehicle_types_combined['vehicleId'] = 'freightVehicle-' + vehicle_types_combined['vehicleId'].astype( str) processed_event_updated = pd.merge( @@ -152,7 +162,7 @@ def read_events_file(full_filename, run_name): return processed_events -def calc_vmt_from_linkstats(linkstats_df, scenario): +def calc_vmt_from_linkstats(linkstats_df): freight_classes = ["Class2b3Vocational", "Class456Vocational", "Class78Vocational", "Class78Tractor"] required_columns = ['length', 'hour'] + [f'volume_{col}' for col in freight_classes] missing_columns = [col for col in required_columns if col not in linkstats_df.columns] @@ -169,7 +179,7 @@ def calc_vmt_from_linkstats(linkstats_df, scenario): total_vmt = linkstats_df[ [f'vmt_{col}' for col in freight_classes]].sum().sum() * scale_up_factor / 1_000_000 log_and_print( - f"[BEAM] Total VMT from LinkStats for scenario {batch}/{scenario}: {total_vmt:.2f} million miles") + f"[BEAM] Total VMT from LinkStats ({batch}/{run}): {total_vmt:.2f} million miles") vmt_by_hour = linkstats_df.groupby('hour')[ [f'vmt_{col}' for col in freight_classes]].sum() * scale_up_factor / 1_000_000 @@ -191,14 +201,14 @@ def calc_vmt_from_linkstats(linkstats_df, scenario): plt.tight_layout() - plot_filename = os.path.join(get_local_work_directory(scenario), f"vmt_by_hour_category_{scenario}.png") + plot_filename = os.path.join(run_directory, f"vmt_by_hour_category_{run}.png") plt.savefig(plot_filename, bbox_inches='tight') # log_and_print(f"Bar plot saved as {plot_filename}") return vmt_by_hour -def calc_vmt_from_events(events, scenario): +def calc_vmt_from_events(events): # Filter for PathTraversal events and freight vehicles pt = events[ (events['type'] == 'PathTraversal') & @@ -212,10 +222,6 @@ def calc_vmt_from_events(events, scenario): log_and_print(f"This is a bug. Number of emergency vehicles found: {len(emergency_vehicles)}", logging.ERROR) log_and_print(f"Sample of emergency vehicles: {emergency_vehicles['vehicle'].head()}", logging.ERROR) - # log_and_print(f"powertrains: {pt["primaryFuelType"].unique()}") - # log_and_print(f"vehicletypes: {pt["vehicleType"].unique()}") - # Calculate total VMT - log_and_print( f"[BEAM] Total number of vehicles: {int(len(pt['vehicle'].unique()) * scale_up_factor)}") log_and_print( @@ -224,14 +230,33 @@ def calc_vmt_from_events(events, scenario): log_and_print( f"[BEAM] Total VMT: {total_vmt_million_miles:.2f} million miles") - vmt_by_category = pt.groupby(['business', 'vehicleCategory'])[ - 'length'].sum() * scale_up_factor / 1609.34 / 1_000_000 + # Calculate VMT by business + vmt_by_business = pt.groupby('business')['length'].sum() * scale_up_factor / 1609.34 / 1_000_000 + vmt_by_business = vmt_by_business.round(2) + business_table = pd.DataFrame({ + 'Business': vmt_by_business.index, + 'VMT (Million Miles)': vmt_by_business.values + }) + log_and_print("[BEAM] VMT by Business:" + business_table.to_string(index=False, float_format=lambda x: '%.2f' % x)) + + # Calculate VMT by vehicle category + vmt_by_category = pt.groupby('vehicleCategory')['length'].sum() * scale_up_factor / 1609.34 / 1_000_000 + vmt_by_category = vmt_by_category.round(2) + category_table = pd.DataFrame({ + 'Vehicle Category': vmt_by_category.index, + 'VMT (Million Miles)': vmt_by_category.values + }) + log_and_print( + "[BEAM] VMT by Vehicle Category:" + category_table.to_string(index=False, float_format=lambda x: '%.2f' % x)) - vmt_by_category = vmt_by_category.unstack(level='business') + # Create stacked bar plot + vmt_by_business_category = pt.groupby(['business', 'vehicleCategory'])[ + 'length'].sum() * scale_up_factor / 1609.34 / 1_000_000 + vmt_by_business_category = vmt_by_business_category.unstack(level='business') # Create bar plot - ax = vmt_by_category.plot(kind='bar', figsize=(12, 6), width=0.8) - plt.title(f'VMT by Business and Vehicle Category for {scenario}') + ax = vmt_by_business_category.plot(kind='bar', figsize=(12, 6), width=0.8) + plt.title(f'VMT by Business and Vehicle Category: ({batch}/{run})') plt.xlabel('Vehicle Category') plt.ylabel('VMT (Million Miles)') plt.legend(title='Business') @@ -242,15 +267,14 @@ def calc_vmt_from_events(events, scenario): ax.bar_label(container, fmt='%.2f', padding=3) plt.tight_layout() - png_output = os.path.join(get_local_work_directory(scenario), f"vmt_by_category_{scenario}.png") + png_output = os.path.join(run_directory, f"vmt_by_category_{run}.png") plt.savefig(png_output) return pt -def convert_payload_to_trips(payload_df, scenario): - output_file_path = os.path.join(work_dir, 'beam-freight', batch, scenario, - f'trips--{scenario.replace("_", "-")}.csv') +def convert_payload_to_trips(payload_df): + output_file_path = os.path.join(scenario_directory, f'trips--{scenario_label}.csv') # log_and_print(f"[FRISM] Total rows in payloads: {len(payload_df)}") # Count payloads per tour @@ -379,9 +403,30 @@ def trips_by_vehicle_class(trips_df, carriers_df, vehicle_types_df): return summary -def get_local_work_directory(scenario): - local_work_directory = f'{work_dir}/beam-runs/{batch}/{scenario}/' - return local_work_directory +def compare_events_and_payloads(events_df, payload_df, scenario_directory, run, scenario_label): + """ + Compare tours in events file with payload file and create a new payload file with missing tours. + """ + # Extract unique tourIds from events and payloads + events_tour_ids = set(events_df[events_df['type'] == 'PathTraversal']['tourId'].unique()) + payload_tour_ids = set(payload_df['tourId'].unique()) + + # Also check tours in payload but not in events + missing_from_events = payload_tour_ids - events_tour_ids + + # Log summary statistics + log_and_print(f"\n[ANALYSIS] Tour comparison summary:") + log_and_print(f"Tours in events file: {len(events_tour_ids):,}") + log_and_print(f"Tours in payload file: {len(payload_tour_ids):,}") + log_and_print(f"Tours missing from events: {len(missing_from_events):,}") + + if len(missing_from_events) > 0: + log_and_print( + f"\n[WARNING] Found {len(missing_from_events)} tours in payload file that are not in events file!") + payload_filtered_df = payload_df[payload_df['tourId'].isin(missing_from_events)].copy() + missing_events_file = os.path.join(run_directory, f"payloads--{run_label}--tours-missing-in-events.csv") + payload_filtered_df.to_csv(missing_events_file, index=False) + log_and_print(f"List of payloads which tours are missing from events saved to: {missing_events_file}") def determine_powertrain(row): @@ -427,6 +472,7 @@ def setup_logging(log_file): format='%(asctime)s - %(levelname)s - %(message)s', handlers=[logging.FileHandler(log_file, mode='w'), logging.StreamHandler()]) + log_and_print(f"Run >> city:{city}, batch:{batch}, scenario:{scenario}, run:{run}, sample:{sample}") def log_and_print(message, level=logging.INFO): diff --git a/src/main/python/freight/freight_parking_events.py b/src/main/python/freight/freight_parking_events.py new file mode 100644 index 00000000000..a245f7829e9 --- /dev/null +++ b/src/main/python/freight/freight_parking_events.py @@ -0,0 +1,75 @@ +import pandas as pd +import os +import sys +import utils + +workspace = '~/Workspace/Data/FREIGHT/' +city = "austin" # "sfbay" +scenario = "parking-sensitivity" +batch = "2018_unlimited/" + +events_file = utils.construct_events_file_path(workspace, city, scenario, batch) +if len(sys.argv) >= 2: + events_file = str(sys.argv[1]) +dir_name = os.path.dirname(events_file) +basename = os.path.basename(events_file) +log_file = dir_name + "/log." + basename + +## ***************************************************** + +file_to_read = dir_name + "/park." + basename +if not os.path.exists(file_to_read): + file_to_read = dir_name + "/" + basename + +utils.print2(log_file, "reading: " + file_to_read) +#ParkingEvent, LeavingParkingEvent, ChargingPlugInEvent, ChargingPlugOutEvent, RefuelSessionEvent +data = utils.read_csv_in_chunks(file_to_read) +#data = utils.read_csv(dir_name + "/park." + basename) +utils.print2(log_file, "Read... " + str(data.type.unique())) + +# filtering +data_filtered = data.loc[data.type.isin(["ParkingEvent", "LeavingParkingEvent", "ChargingPlugInEvent", "ChargingPlugOutEvent", "RefuelSessionEvent"])] +data_filtered2 = data_filtered.loc[data_filtered.vehicle.str.startswith("carrier", na=False)] +utils.print2(log_file, data_filtered2.vehicleType.unique()) + +# saving +file_to_write = dir_name + "/park." + basename +data_filtered2.to_csv(file_to_write) +utils.print2(log_file, "writing to " + file_to_write) + +# second filtering +data_filtered3 = data_filtered2.loc[data.type.isin(["ParkingEvent", "LeavingParkingEvent", "ChargingPlugInEvent", "ChargingPlugOutEvent"])] +utils.print2(log_file, "Filtered and now counting number of vehicles parked at each parking zone") +# parkingTaz, parkingZoneId + +# Mapping for event to increment/decrement values +import numpy as np +event_mapping = { + 'ParkingEvent': (1, 0), + 'LeavingParkingEvent': (-1, 0), + 'ChargingPlugInEvent': (0, 1), + 'ChargingPlugOutEvent': (0, -1), +} + +# Map the type column to increment/decrement values +#data_filtered3['EventCounts'] = data_filtered3['type'].map(event_mapping) +data_filtered3['numVehicles'] = 0 +data_filtered3['numChargingVehicles'] = 0 +df_mapped = data_filtered3['type'].map(event_mapping) +df_mapped2 = pd.DataFrame(df_mapped.tolist(), columns=['numVehicles', 'numChargingVehicles'], index=data_filtered3.index) +data_filtered3.update(df_mapped2) +print(data_filtered3) +for col in ['numVehicles', 'numChargingVehicles']: + data_filtered3[col] = data_filtered3.groupby(['parkingTaz', 'parkingZoneId'])[col].fillna(0).cumsum() +print(data_filtered3) +#data_filtered3[['numVehicles', 'numChargingVehicles']] = data_filtered3['type'].map(event_mapping) +#data_filtered3[['numVehicles', 'numChargingVehicles']] = data_filtered3.groupby(['parkingTaz', 'parkingZoneId'])[['numVehicles', 'numChargingVehicles']].cumsum() + +# Use groupby with cumsum to get the cumulative sum for each group +# for col in ['numVehicles', 'numChargingVehicles']: +# data_filtered3[col] = 0 +# data_filtered3[col] = data_filtered3.groupby(['parkingTaz', 'parkingZoneId'])[col].cumsum() +# data_filtered2[['numVehicles', 'numChargingVehicles']] = data_filtered2['type'].map(event_mapping) + +data_filtered3.to_csv(dir_name + "/" + "park2." + basename) +utils.print2(log_file, "END") diff --git a/src/main/python/freight/frism_to_beam_freight_plans.py b/src/main/python/freight/frism_to_beam_freight_plans.py index e5ecc42d784..c5f2f6fe79c 100644 --- a/src/main/python/freight/frism_to_beam_freight_plans.py +++ b/src/main/python/freight/frism_to_beam_freight_plans.py @@ -1,40 +1,211 @@ -import pandas as pd +import multiprocessing as mp import os +import random +import sys +import warnings +from concurrent.futures import ThreadPoolExecutor, as_completed from pathlib import Path -import numpy as np +from typing import Tuple, List -primary_energy_files = { - "freight-md-D-Diesel-Baseline": "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(Diesel,_2020,_no_program).csv", - "freight-md-E-BE-Baseline": "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(BEV,_2025,_no_program).csv", - # "freight-md-E-H2FC-Baseline": np.nan, - "freight-md-E-PHEV-Baseline": "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(BEV,_2025,_no_program).csv", - "freight-hdt-D-Diesel-Baseline": "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(Diesel,_2020,_no_program).csv", - "freight-hdt-E-BE-Baseline": "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(BEV,_2025,_no_program).csv", - # "freight-hdt-E-H2FC-Baseline": np.nan, - "freight-hdt-E-PHEV-Baseline": "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(BEV,_2025,_no_program).csv", - "freight-hdv-D-Diesel-Baseline": "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(Diesel,_2020,_no_program).csv", - "freight-hdv-E-BE-Baseline": "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(BEV,_2025,_no_program).csv", - # "freight-hdv-E-H2FC-Baseline": np.nan, - "freight-hdv-E-PHEV-Baseline": "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(BEV,_2025,_no_program).csv" -} - -secondary_energy_profile_for_phev = { - # "freight-md-D-Diesel-Baseline": np.nan, - # "freight-md-E-BE-Baseline": np.nan, - # "freight-md-E-H2FC-Baseline": np.nan, - "freight-md-E-PHEV-Baseline": ("Diesel", 9595.796035186175, 12000000000000000, - "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(HEV,_2025,_no_program).csv"), - # "freight-hdt-D-Diesel-Baseline": np.nan, - # "freight-hdt-E-BE-Baseline": np.nan, - # "freight-hdt-E-H2FC-Baseline": np.nan, - "freight-hdt-E-PHEV-Baseline": ("Diesel", 13817.086117829229, 12000000000000000, - "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(HEV,_2025,_no_program).csv"), - # "freight-hdv-D-Diesel-Baseline": np.nan, - # "freight-hdv-E-BE-Baseline": np.nan, - # "freight-hdv-E-H2FC-Baseline": np.nan, - "freight-hdv-E-PHEV-Baseline": ("Diesel", 14026.761465378302, 12000000000000000, - "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(HEV,_2025,_no_program).csv") -} +import geopandas as gpd +import numpy as np +import pandas as pd +from pandas import DataFrame +from pyrosm import OSM +from scipy.spatial import cKDTree +from shapely.geometry import Point + +from estimate_stop_duration import update_operation_duration + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) + +# Go up to the parent directory that contains the 'python' directory +# If your file is in /path/to/python/freight/frism_to_beam_freight_plans.py +# This will add /path/to to sys.path +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +# Now use absolute import +from python.utils.study_area_config import get_area_config +from python.utils.study_area_config import generate_network_name +from python.utils.study_area_config import constants + + +warnings.filterwarnings('ignore') + +# ************************************************************************************************ + +AREA = "sfbay" # sfbay +BATCH_NAME = "2024-01-23" +SCENARIO_NAME = "Baseline" +SCENARIO_SUFFIX = "" +FRISM_VERSION = 1.0 +# Coordinate snapping constants +BUFFER_DISTANCE_METERS = 100 # 100 meters +MAX_DISTANCE_METERS = 200000 # 200km +STUDY_AREA_CONFIG = get_area_config(AREA) +STUDY_AREA_CONFIG["network"]["graph_layers"]["residential"]["min_density_per_km2"] = 5500 +SNAP_COORDINATES = True + +# ************************************************************************************************ + + + + +# System and general constants +CHUNK_SIZE = 10000 # this affects speed and parallelization of the script +CONFIG_NAME = generate_network_name(STUDY_AREA_CONFIG) +NETWORK_DIR = f'{STUDY_AREA_CONFIG["work_dir"]}/network/{CONFIG_NAME}' +NETWORK_OSM_PBF = f'{NETWORK_DIR}/{CONFIG_NAME}.osm.pbf' +UTM_CRS = STUDY_AREA_CONFIG["geo"]["utm_epsg"] +YEAR = STUDY_AREA_CONFIG["census_year"] +SCENARIO_LABEL = SCENARIO_NAME.replace("_", "") +PRIMARY_ENERGY_PROFILE = STUDY_AREA_CONFIG["fastsim_routee_files"]["primary_powertrain"] +SECONDARY_ENERGY_PROFILE = STUDY_AREA_CONFIG["fastsim_routee_files"]["secondary_powertrain"] + +# File paths and directories +DIRECTORY_INPUT = f'{STUDY_AREA_CONFIG["work_dir"]}/frism/{BATCH_NAME}/{SCENARIO_NAME}' +DIRECTORY_BATCH = f'{STUDY_AREA_CONFIG["work_dir"]}/beam-ft/{BATCH_NAME}' +DIRECTORY_OUTPUT = f'{DIRECTORY_BATCH}/{YEAR}_{SCENARIO_LABEL}{SCENARIO_SUFFIX}' +DIRECTORY_VEHICLE_TECH = f'{STUDY_AREA_CONFIG["work_dir"]}/vehicle-tech' +DIRECTORY_SCENARIO = f'{DIRECTORY_OUTPUT}' +# if SNAP_COORDINATES: +# # Define the snapped directory path +# DIRECTORY_SCENARIO = f'{DIRECTORY_OUTPUT}--snapped-to-{CONFIG_NAME}' +# else: +# DIRECTORY_SCENARIO = f'{DIRECTORY_OUTPUT}' + +# Create necessary directories if they don't exist +Path(DIRECTORY_SCENARIO).mkdir(parents=True, exist_ok=True) +Path(DIRECTORY_VEHICLE_TECH).mkdir(parents=True, exist_ok=True) + +# Variables +_carriers = None +_payload_plans = None +_ondemand_plans = None +_tours = None +_vehicle_types = None +_tourId_with_prefix = {} + +# ****************************** + +def load_osm_network(pbf_path, min_distance_from_edge): + """ + Load OSM network and create/load buffered network with proper metric distances + + Args: + pbf_path (str): Path to original OSM PBF file + min_distance_from_edge (float): Buffer distance in meters + + Returns: + gpd.GeoDataFrame: Network edges with original and buffered geometries + + Raises: + ValueError: If the PBF file doesn't exist or if network extraction fails + """ + # Input validation + if not os.path.exists(pbf_path): + raise ValueError(f"PBF file not found: {pbf_path}") + + print(f"Loading OSM network from {pbf_path}...") + try: + osm = OSM(pbf_path) + edges = osm.get_network(network_type="driving") + except Exception as e: + raise ValueError(f"Failed to load OSM network: {str(e)}") + + # Ensure we have a GeoDataFrame + if not isinstance(edges, gpd.GeoDataFrame): + edges = gpd.GeoDataFrame(edges) + + if edges.empty: + raise ValueError("No network edges found in the PBF file") + + print(f"Creating {str(int(BUFFER_DISTANCE_METERS / 1000))}km road buffer...") + # Convert to UTM for proper metric distances + try: + edges_utm = edges.to_crs(epsg=UTM_CRS) + except Exception as e: + raise ValueError(f"Failed to convert to UTM (EPSG:{UTM_CRS}): {str(e)}") + + # Create buffer in UTM coordinates (where distances are in meters) + buffered_edges = edges_utm.copy() + buffered_edges['geometry'] = edges_utm['geometry'].buffer( + min_distance_from_edge, + cap_style=2, # flat ends + join_style=2 # mitered joins + ) + + # Add buffered geometry as a new column + edges_utm['buffered_geometry'] = buffered_edges.geometry + + # Create buffered pbf if it doesn't exist + path_without_ext, ext = os.path.splitext(pbf_path) + buffer_path = f"{path_without_ext}_{str(int(BUFFER_DISTANCE_METERS / 1000))}km_road_buffer.geojson" + + # Check if file exists and handle overwriting + if os.path.exists(buffer_path): + try: + os.remove(buffer_path) + print(f"Removed existing file: {buffer_path}") + except Exception as e: + print(f"Warning: Failed to remove existing file: {str(e)}") + + # Save buffered network + try: + # Save the buffered edges as GeoJSON + # Convert to geographic coordinates (EPSG:4326) for better compatibility + save_gdf = buffered_edges.to_crs(epsg=4326) + + # Make sure all columns are serializable + for col in save_gdf.columns: + if save_gdf[col].dtype == 'object': + save_gdf[col] = save_gdf[col].astype(str) + + # Save to GeoJSON + save_gdf.to_file(buffer_path, driver='GeoJSON') + print(f"Saved buffered network to: {buffer_path}") + except Exception as e: + print(f"Warning: Failed to save buffered network: {str(e)}") + raise e + + return edges_utm + + +def generate_random_point_near_line( + nearest_edge: gpd.GeoSeries, + point_geom: Point, + max_dist_meters: float +) -> Tuple[float, float]: + """ + Generate a random point within max_dist_meters of the nearest point on the road + + Args: + nearest_edge: GeoSeries row containing the road geometry + point_geom: Original point (Shapely Point) + max_dist_meters: Maximum distance from road (e.g., 200) + + Returns: + Tuple of (x, y) coordinates for the new random point + """ + # Find nearest point on the road + proj_distance = nearest_edge.geometry.project(point_geom) + nearest_point = nearest_edge.geometry.interpolate(proj_distance) + + # Generate random angle and distance + angle = random.uniform(0, 2 * np.pi) # Random angle between 0 and 2π + distance = random.uniform(0, max_dist_meters) # Random distance up to max + + # Convert to x,y offset + dx = distance * np.cos(angle) + dy = distance * np.sin(angle) + + # Create new point + new_x = nearest_point.x + dx + new_y = nearest_point.y + dy + + return new_x, new_y def read_csv_file(filename_): @@ -71,180 +242,17 @@ def add_prefix(prefix, column, row, to_num=True, store_dict=None, veh_type=False return new -frism_version = 1.5 -city = "seattle" -scenario_name = "2024-04-20" -year, run_name = "2018", "Baseline" -# year, run_name = "2050", "Ref_highp6" -run_name_label = run_name.replace("_", "") - -# work_dir = os.path.expanduser(f'/Volumes/HG40/Workspace') -work_dir = os.path.expanduser(f'~/Workspace') -directory_input = f'{work_dir}/Simulation/{city}/frism/{scenario_name}/{run_name}' -directory_output = f'{work_dir}/Simulation/{city}/beam-freight/{scenario_name}/{year}_{run_name_label}' -Path(directory_output).mkdir(parents=True, exist_ok=True) -directory_vehicle_tech = f'{directory_output}/vehicle-tech' -Path(directory_vehicle_tech).mkdir(parents=True, exist_ok=True) -carriers = None -payload_plans = None -ondemand_plans = None -tours = None -vehicle_types = None -tourId_with_prefix = {} - -for filename in sorted(os.listdir(directory_input)): - filepath = f'{directory_input}/{filename}' - print(filepath) - parts = filename.split('_', 2) - if len(parts) < 3: - print("Warning! could not read file: ", filename) - continue - business_type = parts[0].lower() - county = parts[1].lower() - filetype = parts[2].lower() - - if "carrier" in filetype: - df = pd.read_csv(filepath) - # df['carrierId'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'carrierId', row), axis=1) - # df['vehicleId'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'vehicleId', row), axis=1) - df['carrierId'] = df.apply(lambda row: add_prefix(f'', 'carrierId', row, False), axis=1).tolist() - df['vehicleTypeId'] = df.apply( - lambda row: add_prefix('', 'vehicleTypeId', row, to_num=True, store_dict=None, veh_type=True, - suffix=f"-{year}-{run_name_label}"), - axis=1).tolist() - df['vehicleId'] = df.apply(lambda row: add_prefix(row['carrierId'] + '-', 'vehicleId', row), axis=1).tolist() - # df['tourId'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'tourId', row), axis=1) - df['tourId'] = df.apply(lambda row: add_prefix(f'{business_type}-', 'tourId', row, True, tourId_with_prefix), - axis=1).tolist() - if carriers is None: - carriers = df - else: - carriers = pd.concat([carriers, df]) - elif "freight_tours" in filetype: - df = pd.read_csv(filepath) - # df['tour_id'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'tour_id', row), axis=1) - df['tour_id'] = df.apply(lambda row: tourId_with_prefix[str(int(row['tour_id']))], axis=1).tolist() - if tours is None: - tours = df - else: - tours = pd.concat([tours, df]) - elif "payload" in filetype: - df = pd.read_csv(filepath) - if "ondemand" in county: - df['tourId'] = df.apply(lambda row: add_prefix(f'ridehail-', 'tourId', row), axis=1) - if ondemand_plans is None: - ondemand_plans = df - else: - ondemand_plans = pd.concat([ondemand_plans, df]) - else: - df['tourId'] = df.apply(lambda row: tourId_with_prefix[str(int(row['tourId']))], axis=1).tolist() - df['payloadId'] = df.apply(lambda row: add_prefix('', 'payloadId', row, False), axis=1).tolist() - tourId_with_prefix = {} - if payload_plans is None: - payload_plans = df - else: - payload_plans = pd.concat([payload_plans, df]) - elif "vehicle_types" in filename: - df = pd.read_csv(filepath) - empty_vectors = list(np.repeat("", len(df.index))) - # JoulePerMeter = 121300000/(mpgge*1609.34) - vehicle_types_ids = df.apply( - lambda row: add_prefix('', 'veh_type_id', row, to_num=True, store_dict=None, veh_type=True, - suffix=f"-{year}-{run_name_label}"), axis=1).tolist() - vehicles_techs = { - "vehicleTypeId": vehicle_types_ids, - "seatingCapacity": list(np.repeat(1, len(df.index))), - "standingRoomCapacity": list(np.repeat(0, len(df.index))), - "lengthInMeter": list(np.repeat(12, len(df.index))), - "primaryFuelType": df["primary_fuel_type"], - "primaryFuelConsumptionInJoulePerMeter": np.divide(121300000, - np.float64(df["primary_fuel_rate"]) * 1609.34), - "primaryFuelCapacityInJoule": list(np.repeat(12000000000000000, len(df.index))), - "primaryVehicleEnergyFile": [primary_energy_files[id] if id in primary_energy_files else np.nan for id in - vehicle_types_ids], - "secondaryFuelType": [ - secondary_energy_profile_for_phev[id][0] if id in secondary_energy_profile_for_phev else np.nan for id - in vehicle_types_ids], - "secondaryFuelConsumptionInJoulePerMeter": [ - secondary_energy_profile_for_phev[id][1] if id in secondary_energy_profile_for_phev else np.nan for id - in vehicle_types_ids], - "secondaryVehicleEnergyFile": [ - secondary_energy_profile_for_phev[id][3] if id in secondary_energy_profile_for_phev else np.nan for id - in vehicle_types_ids], - "secondaryFuelCapacityInJoule": [ - secondary_energy_profile_for_phev[id][2] if id in secondary_energy_profile_for_phev else np.nan for id - in vehicle_types_ids], - "automationLevel": list(np.repeat(1, len(df.index))), - "maxVelocity": df["max_speed(mph)"], # convert to meter per second - "passengerCarUnit": empty_vectors, - "rechargeLevel2RateLimitInWatts": empty_vectors, - "rechargeLevel3RateLimitInWatts": empty_vectors, - "vehicleCategory": list(np.repeat("Class456Vocational", len(df.index))), - "sampleProbabilityWithinCategory": empty_vectors, - "sampleProbabilityString": empty_vectors, - "payloadCapacityInKg": df["payload_capacity_weight"], - "vehicleClass": df["veh_class"] - } - df2 = pd.DataFrame(vehicles_techs) - df2["vehicleCategory"] = np.where(df2["vehicleTypeId"].str.contains('hdv'), 'Class78Vocational', - df2.vehicleCategory) - df2["vehicleCategory"] = np.where(df2["vehicleTypeId"].str.contains('hdt'), 'Class78Tractor', - df2.vehicleCategory) - df2["vehicleCategory"] = np.where(df2["vehicleTypeId"].str.contains('ld'), 'Class2b3Vocational', - df2.vehicleCategory) - if vehicle_types is None: - vehicle_types = df2 - else: - vehicle_types = pd.concat([vehicle_types, df2]) - else: - print(f'SKIPPING {filename}') - -vehicle_types.to_csv( - f'{directory_vehicle_tech}/ft-vehicletypes--{scenario_name.replace("-", "")}--{year}-{run_name_label}.csv', - index=False) - -# In[9]: - - -# carrierId,tourId,vehicleId,vehicleTypeId,warehouseZone,warehouseX,warehouseY,MESOZONE,BoundaryZONE -# carrierId,tourId,vehicleId,vehicleTypeId,warehouseZone,warehouseX,warehouseY,MESOZONE,BoundaryZONE -carriers_renames = { - 'depot_zone': 'warehouseZone', - 'depot_zone_x': 'warehouseX', - 'depot_zone_y': 'warehouseY', - 'true_depot_zone': 'mesoZone' -} -carriers_drop = ['x', 'y', 'index'] -carriers.rename(columns=carriers_renames, inplace=True) -carriers.drop(carriers_drop, axis=1, inplace=True, errors='ignore') -carriers['warehouseZone'] = carriers['warehouseZone'].astype(int) -carriers.to_csv(f'{directory_output}/carriers--{year}-{run_name_label}.csv', index=False) - -# In[10]: - - -# tourId,departureTimeInSec,departureLocationZone,maxTourDurationInSec,departureLocationX,departureLocationY -# tourId,departureTimeInSec,departureLocationZone,maxTourDurationInSec,departureLocationX,departureLocationY -tours_renames = { - 'tour_id': 'tourId', - 'departureLocation_zone': 'departureLocationZone', - 'departureLocation_x': 'departureLocationX', - 'departureLocation_y': 'departureLocationY', - 'true_depot_zone': 'mesoZone' -} -tours.rename(columns=tours_renames, inplace=True) -tours['departureTimeInSec'] = tours['departureTimeInSec'].astype(int) -tours['maxTourDurationInSec'] = tours['maxTourDurationInSec'].astype(int) -tours['departureLocationZone'] = tours['departureLocationZone'].astype(int) -tours.drop(['index'], axis=1, inplace=True, errors='ignore') -tours.to_csv(f'{directory_output}/tours--{year}-{run_name_label}.csv', index=False) - - -# In[11]: - - -# payloadId,sequenceRank,tourId,payloadType,weightInKg,requestType,locationZone,estimatedTimeOfArrivalInSec,arrivalTimeWindowInSecLower,arrivalTimeWindowInSecUpper,operationDurationInSec,locationX,locationY -def format_payload(_payload): +def format_payload(_payload_plans: pd.DataFrame) -> pd.DataFrame: + """ + Format payload and adjust coordinates where needed using road buffer for efficiency + + Args: + _payload_plans (DataFrame): Input payload data + + Returns: + DataFrame: Formatted payload data + """ + # Rename columns and convert data types payload_plans_renames = { 'arrivalTimeWindowInSec_lower': 'arrivalTimeWindowInSecLower', 'arrivalTimeWindowInSec_upper': 'arrivalTimeWindowInSecUpper', @@ -254,10 +262,16 @@ def format_payload(_payload): 'BuyerNAICS': "buyerNAICS", "SellerNAICS": "sellerNAICS" } - payload_plans_drop = ['truck_mode', 'weightInlb', 'cummulativeWeightInlb', 'index'] - int_columns = ['sequenceRank', 'payloadType', 'requestType', 'estimatedTimeOfArrivalInSec', - 'arrivalTimeWindowInSecLower', 'arrivalTimeWindowInSecUpper', - 'operationDurationInSec', 'locationZone'] + _payload_plans.rename(columns=payload_plans_renames, inplace=True) + + int_columns = [ + 'sequenceRank', 'payloadType', 'requestType', 'estimatedTimeOfArrivalInSec', + 'arrivalTimeWindowInSecLower', 'arrivalTimeWindowInSecUpper', + 'operationDurationInSec', 'locationZone' + ] + _payload_plans[int_columns] = _payload_plans[int_columns].astype(int) + + # Map payload types and process weights payload_type_map = { 1: 'bulk', 2: 'fuel_fert', @@ -265,47 +279,568 @@ def format_payload(_payload): 4: 'mfr_goods', 5: 'others' } - - _payload.rename(columns=payload_plans_renames, inplace=True) - - # Convert columns to integer type - for col in int_columns: - _payload[col] = _payload[col].astype(int) - - _payload['payloadType'] = _payload['payloadType'].map(payload_type_map) - # Convert weightInlb to weightInKg without applying abs yet - _payload['weightInKg'] = _payload['weightInlb'].astype(float) * 0.45359237 - - # Apply modifications for frism version > 1.0 - if frism_version > 1.0: - # Create DeliveryType column - _payload['deliveryType'] = _payload['requestType'].map({1: 'delivery-only', 3: 'pickup-delivery'}) - - # Update requestType based on weightInKg - _payload['requestType'] = _payload['requestType'].astype('object') - _payload.loc[_payload['weightInKg'] < 0, 'requestType'] = 'unloading' - _payload.loc[_payload['weightInKg'] >= 0, 'requestType'] = 'loading' - - # Now make weightInKg positive - _payload['weightInKg'] = np.abs(_payload['weightInKg']) - - _payload['fleetType'] = _payload['truck_mode'].map({ + _payload_plans['payloadType'] = _payload_plans['payloadType'].map(payload_type_map) + _payload_plans['weightInKg'] = _payload_plans['weightInlb'].astype(float) * 0.45359237 + + # Handle different FRISM versions + if FRISM_VERSION > 1.0: + _payload_plans['deliveryType'] = _payload_plans['requestType'].map({ + 1: 'delivery-only', + 3: 'pickup-delivery' + }) + _payload_plans['requestType'] = _payload_plans['requestType'].astype('object') + _payload_plans.loc[_payload_plans['weightInKg'] < 0, 'requestType'] = 'unloading' + _payload_plans.loc[_payload_plans['weightInKg'] >= 0, 'requestType'] = 'loading' + _payload_plans['weightInKg'] = np.abs(_payload_plans['weightInKg']) + + _payload_plans['fleetType'] = _payload_plans['truck_mode'].map({ 'Private Truck': 'private', 'For-hire Truck': 'for-hire' - }, na_action='ignore') # This keeps NA values as they are + }, na_action='ignore') else: - # For frism version 1.0, just ensure weightInKg is positive - _payload['requestType'] = _payload['requestType'].map({1: 'unloading', 0: 'loading'}) - _payload['weightInKg'] = np.abs(_payload['weightInKg']) + # _payload_plans['requestType'] = _payload_plans['requestType'].map({1: 'unloading', 0: 'loading'}) + _payload_plans.loc[_payload_plans['weightInKg'] < 0, 'requestType'] = 'unloading' + _payload_plans.loc[_payload_plans['weightInKg'] >= 0, 'requestType'] = 'loading' + _payload_plans['weightInKg'] = np.abs(_payload_plans['weightInKg']) + + # Clean up unnecessary columns + payload_plans_drop = ['truck_mode', 'weightInlb', 'cummulativeWeightInlb', 'index'] + _payload_plans.drop(payload_plans_drop, axis=1, inplace=True, errors='ignore') + + return _payload_plans + + +## ################################ +## Snapping coordinates section + +def create_spatial_index_kdtree(edges_gdf_utm: gpd.GeoDataFrame) -> Tuple[np.ndarray, cKDTree]: + """Create KD-tree spatial index from UTM coordinates for faster nearest neighbor queries""" + # Extract centroids of line segments in UTM coordinates + centroids = np.array([[geom.centroid.x, geom.centroid.y] for geom in edges_gdf_utm.geometry]) + return centroids, cKDTree(centroids) + + +def find_nearest_edge_kdtree( + point_utm: Point, + edges_gdf_utm: gpd.GeoDataFrame, + kdtree: cKDTree, + k: int = 5 +) -> Tuple[float, gpd.GeoSeries]: + """ + Find nearest edge using KD-tree with vectorized distance calculations in UTM coordinates + + Args: + point_utm: Point geometry in UTM coordinates + edges_gdf_utm: GeoDataFrame containing network edges in UTM + kdtree: cKDTree spatial index + k: Number of nearest neighbors to check + + Returns: + Tuple of (minimum distance in meters, nearest edge) + """ + # Find k nearest neighbors using KD-tree + distances, indices = kdtree.query([point_utm.x, point_utm.y], k=k) + + # Calculate actual distances to the k nearest edges in meters (UTM) + candidate_edges = edges_gdf_utm.iloc[indices] + actual_distances = candidate_edges.geometry.distance(point_utm) + + min_idx = actual_distances.idxmin() + return actual_distances.min(), edges_gdf_utm.loc[min_idx] + + +def generate_random_point_near_line_utm( + nearest_edge_utm: gpd.GeoSeries, + point_utm: Point, + max_dist_meters: float +) -> Tuple[float, float]: + """ + Generate a random point within max_dist_meters of the nearest point on the road in UTM coordinates + """ + # Find nearest point on the road + proj_distance = nearest_edge_utm.geometry.project(point_utm) + nearest_point = nearest_edge_utm.geometry.interpolate(proj_distance) + + # Generate random angle and distance + angle = np.random.uniform(0, 2 * np.pi) + distance = np.random.uniform(0, max_dist_meters) + + # Convert to x,y offset (in meters since we're in UTM) + dx = distance * np.cos(angle) + dy = distance * np.sin(angle) + + # Create new UTM coordinates + new_x_utm = nearest_point.x + dx + new_y_utm = nearest_point.y + dy + + return new_x_utm, new_y_utm + + +def process_points_chunk_vectorized( + points_chunk: np.ndarray, + edges_gdf_utm: gpd.GeoDataFrame, + kdtree: cKDTree, + min_distance: float, + max_distance: float, + chunk_start_idx: int, + coordinate_lookup: dict +) -> List[Tuple[int, float, float, bool, bool]]: + """ + Process a chunk of points using vectorized operations with proper CRS handling + + Args: + points_chunk: Array of coordinate pairs to process + edges_gdf_utm: GeoDataFrame containing network edges in UTM + kdtree: Spatial index for quick nearest neighbor lookups + min_distance: Minimum allowed distance from road + max_distance: Maximum allowed distance from road + chunk_start_idx: Starting index of current chunk + coordinate_lookup: Dictionary storing previously processed coordinates + """ + results = [] + cache_hits = 0 + + # Convert input points to UTM for distance calculations + points_gdf = gpd.GeoDataFrame( + geometry=[Point(x, y) for x, y in points_chunk], + crs=4326 + ).to_crs(UTM_CRS) + + for idx, (point_utm, orig_point) in enumerate(zip(points_gdf.geometry, points_chunk)): + try: + # Check lookup table first + coord_key = (orig_point[0], orig_point[1]) + if coord_key in coordinate_lookup: + cached_result = coordinate_lookup[coord_key] + results.append(( + chunk_start_idx + idx, + cached_result[0], + cached_result[1], + cached_result[2], + cached_result[3] + )) + cache_hits += 1 + continue + + # Find nearest edge using UTM coordinates + min_dist, nearest_edge_utm = find_nearest_edge_kdtree(point_utm, edges_gdf_utm, kdtree) + + is_far = min_dist > max_distance + needs_adjustment = min_dist > min_distance and not is_far + + if needs_adjustment: + # Generate new point in UTM coordinates + new_x_utm, new_y_utm = generate_random_point_near_line_utm( + nearest_edge_utm, + point_utm, + min_distance + ) + + # Convert back to original CRS (WGS84) + point_updated = gpd.GeoDataFrame( + geometry=[Point(new_x_utm, new_y_utm)], + crs=UTM_CRS + ).to_crs(4326).geometry[0] + + result = ( + chunk_start_idx + idx, + point_updated.x, + point_updated.y, + is_far, + True + ) + else: + result = ( + chunk_start_idx + idx, + orig_point[0], + orig_point[1], + is_far, + False + ) + + # Store in lookup table + coordinate_lookup[coord_key] = result[1:] + results.append(result) + + except Exception as e: + print(f"Warning: Error processing point {chunk_start_idx + idx}: {str(e)}") + results.append(( + chunk_start_idx + idx, + orig_point[0], + orig_point[1], + False, + False + )) + + if cache_hits > 0: + print(f"Cache hits in chunk: {cache_hits}/{len(points_chunk)}") + return results + + +def snap_coordinates_when_too_far(_df: pd.DataFrame, + osm_edges_utm: gpd.GeoDataFrame, + x_column: str, + y_column: str, + coordinate_lookup: dict = None) -> tuple[pd.DataFrame, dict]: + """ + Optimized version of coordinate snapping using KD-tree spatial indexing and lookup table + + Args: + _df: DataFrame with coordinate columns in WGS84 + osm_edges_utm: GeoDataFrame with network in UTM + x_column: Name of the column containing X coordinates (longitude) + y_column: Name of the column containing Y coordinates (latitude) + coordinate_lookup: Optional existing lookup table to use + + Returns: + Tuple of (DataFrame with snapped coordinates in WGS84, coordinate lookup dictionary) + """ + min_distance_from_edge = BUFFER_DISTANCE_METERS + max_distance_from_edge = MAX_DISTANCE_METERS + + if coordinate_lookup is None: + coordinate_lookup = {} + print("Creating new coordinate lookup table...") + else: + print(f"Using existing lookup table with {len(coordinate_lookup)} entries...") + + print("Creating KD-tree spatial index...") + centroids, kdtree = create_spatial_index_kdtree(osm_edges_utm) + + # Extract coordinates in original CRS (WGS84) + coords = np.column_stack(( + _df[x_column].values, + _df[y_column].values + )) + + # Calculate optimal chunk size based on available CPU cores + num_cores = max(1, mp.cpu_count() - 1) + chunk_size = min(CHUNK_SIZE, max(1000, len(coords) // (num_cores * 2))) + n_chunks = (len(coords) + chunk_size - 1) // chunk_size + + print(f"Processing {len(coords)} points in {n_chunks} chunks using {num_cores} cores...") + + all_results = [] + far_points = 0 + total_adjusted = 0 + + # Process chunks in parallel using ThreadPoolExecutor + with ThreadPoolExecutor(max_workers=num_cores) as executor: + futures = [] + + for chunk_idx in range(n_chunks): + start_idx = chunk_idx * chunk_size + end_idx = min((chunk_idx + 1) * chunk_size, len(coords)) + chunk_coords = coords[start_idx:end_idx] + + future = executor.submit( + process_points_chunk_vectorized, + chunk_coords, + osm_edges_utm, + kdtree, + min_distance_from_edge, + max_distance_from_edge, + start_idx, + coordinate_lookup + ) + futures.append(future) + + # Collect results as they complete + for future in as_completed(futures): + try: + results = future.result() + for _, _, _, is_far, is_adjusted in results: + if is_far: + far_points += 1 + if is_adjusted: + total_adjusted += 1 + all_results.extend(results) + except Exception as e: + print(f"Error processing chunk: {str(e)}") + + if far_points > 0: + print(f"Warning: {far_points} points are farther than {int(max_distance_from_edge / 1000)} km from any road") + if total_adjusted > 0: + print(f"Adjusted {total_adjusted} points to be within {int(min_distance_from_edge / 1000)} km of nearest road") + + # Sort results and update DataFrame efficiently + all_results.sort(key=lambda r: r[0]) + result_indices = [r[0] for r in all_results] + x_coords = [r[1] for r in all_results] + y_coords = [r[2] for r in all_results] + + result_df = _df.copy() + result_df[x_column] = pd.Series(x_coords, index=result_indices) + result_df[y_column] = pd.Series(y_coords, index=result_indices) + + return result_df, coordinate_lookup + + + +############################# +## MAIN + +if __name__ == '__main__': + # Add these at the beginning of your main code, after the variables section + # Dictionary to store vehicle class and fuel rate mappings + vehicle_class_fuel_rates = {} + + for filename in sorted(os.listdir(DIRECTORY_INPUT)): + filepath = f'{DIRECTORY_INPUT}/{filename}' + print(filepath) + parts = filename.split('_', 2) + if len(parts) < 3: + print("Warning! could not read file: ", filename) + continue + business_type = parts[0].lower() + county = parts[1].lower() + filetype = parts[2].lower() + + if "carrier" in filetype: + df = pd.read_csv(filepath) + # df['carrierId'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'carrierId', row), axis=1) + # df['vehicleId'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'vehicleId', row), axis=1) + df['carrierId'] = df.apply(lambda row: add_prefix(f'', 'carrierId', row, False), axis=1).tolist() + df['vehicleTypeId'] = df.apply( + lambda row: add_prefix('', 'vehicleTypeId', row, to_num=True, store_dict=None, veh_type=True, + suffix=f"-{YEAR}-{SCENARIO_LABEL}"), + axis=1).tolist() + df['vehicleId'] = df.apply(lambda row: add_prefix(row['carrierId'] + '-', 'vehicleId', row), + axis=1).tolist() + # df['tourId'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'tourId', row), axis=1) + df['tourId'] = df.apply( + lambda row: add_prefix(f'{business_type}-', 'tourId', row, True, _tourId_with_prefix), + axis=1).tolist() + if _carriers is None: + _carriers = df + else: + _carriers = pd.concat([_carriers, df]) + elif "freight_tours" in filetype: + df = pd.read_csv(filepath) + # df['tour_id'] = df.apply(lambda row: add_prefix(f'{business_type}-{county}-', 'tour_id', row), axis=1) + df['tour_id'] = df.apply(lambda row: _tourId_with_prefix[str(int(row['tour_id']))], axis=1).tolist() + if _tours is None: + _tours = df + else: + _tours = pd.concat([_tours, df]) + elif "payload" in filetype: + df = pd.read_csv(filepath) + if "ondemand" in county: + df['tourId'] = df.apply(lambda row: add_prefix(f'ridehail-', 'tourId', row), axis=1) + if _ondemand_plans is None: + _ondemand_plans = df + else: + _ondemand_plans = pd.concat([_ondemand_plans, df]) + else: + df['tourId'] = df.apply(lambda row: _tourId_with_prefix[str(int(row['tourId']))], axis=1).tolist() + df['payloadId'] = df.apply(lambda row: add_prefix('', 'payloadId', row, False), axis=1).tolist() + _tourId_with_prefix = {} + if _payload_plans is None: + _payload_plans = df + else: + _payload_plans = pd.concat([_payload_plans, df]) + elif "vehicle_types" in filename: # Modify the "vehicle_types" section in the main loop + df = pd.read_csv(filepath) + + # First pass: collect vehicle class and fuel rate information for non-PHEV vehicles + for _, row in df.iterrows(): + veh_class = row['veh_class'] + fuel_type = row['primary_fuel_type'] + fuel_rate = row['primary_fuel_rate'] + + if 'PHEV' not in str(row['veh_type_id']): + vehicle_class_fuel_rates[f"{veh_class}-{fuel_type}"] = fuel_rate + + # Process all vehicles, handling PHEVs specially + empty_vectors = list(np.repeat("", len(df.index))) + vehicle_types_ids = [] + original_vehicle_types_ids = [] + primary_fuel_types = [] + primary_fuel_consumption = [] + primary_fuel_capacities = [] + secondary_fuel_types = [] + secondary_fuel_consumption = [] + secondary_fuel_capacities = [] + + for _, row in df.iterrows(): + veh_type_id = add_prefix('', 'veh_type_id', row, to_num=True, + store_dict=None, veh_type=True, suffix=f"-{YEAR}-{SCENARIO_LABEL}") + vehicle_types_ids.append(veh_type_id) + + original_veh_type_id = add_prefix('', 'veh_type_id', row, to_num=True, + store_dict=None, veh_type=True, suffix="") + original_vehicle_types_ids.append(original_veh_type_id) + + veh_class = row['veh_class'] + fuel_type = row['primary_fuel_type'] + + # Check if this is a PHEV vehicle + if 'PHEV' in str(row['veh_type_id']): + if f"{veh_class}-Electricity" in vehicle_class_fuel_rates and f"{veh_class}-{fuel_type}" in vehicle_class_fuel_rates: + # Primary + primary_fuel_types.append('Electricity') + fuel_rate_1 = vehicle_class_fuel_rates[f"{veh_class}-Electricity"] + primary_fuel_consumption.append(constants["joule_per_meter_base_rate"] / (float(fuel_rate_1) * 1609.34)) + primary_fuel_capacities.append(12000000000000000 * 0.25) # 25% of standard capacity + + # Secondary + secondary_fuel_types.append(fuel_type) + fuel_rate_2 = vehicle_class_fuel_rates[f"{veh_class}-{fuel_type}"] + secondary_fuel_consumption.append(constants["joule_per_meter_base_rate"] / (float(fuel_rate_2) * 1609.34)) + secondary_fuel_capacities.append(12000000000000000 * 0.75) # 75% of standard capacity + else: + # For non-PHEV vehicles, use standard processing + primary_fuel_types.append(row["primary_fuel_type"]) + primary_fuel_consumption.append(constants["joule_per_meter_base_rate"] / + (np.float64(row["primary_fuel_rate"]) * 1609.34)) + primary_fuel_capacities.append(12000000000000000) + secondary_fuel_types.append(np.nan) + secondary_fuel_consumption.append(np.nan) + secondary_fuel_capacities.append(np.nan) + + # Create the vehicles techs dictionary with our processed values + vehicles_techs = { + "vehicleTypeId": vehicle_types_ids, + "seatingCapacity": list(np.repeat(1, len(df.index))), + "standingRoomCapacity": list(np.repeat(0, len(df.index))), + "lengthInMeter": list(np.repeat(12, len(df.index))), + "primaryFuelType": primary_fuel_types, + "primaryFuelConsumptionInJoulePerMeter": primary_fuel_consumption, + "primaryFuelCapacityInJoule": primary_fuel_capacities, + "primaryVehicleEnergyFile": [ + PRIMARY_ENERGY_PROFILE[index] if index in PRIMARY_ENERGY_PROFILE else np.nan + for index in original_vehicle_types_ids], + "secondaryFuelType": secondary_fuel_types, + "secondaryFuelConsumptionInJoulePerMeter": secondary_fuel_consumption, + "secondaryFuelCapacityInJoule": secondary_fuel_capacities, + "secondaryVehicleEnergyFile": [ + SECONDARY_ENERGY_PROFILE[index][3] if index in SECONDARY_ENERGY_PROFILE else np.nan for + index in original_vehicle_types_ids], + "automationLevel": list(np.repeat(1, len(df.index))), + "maxVelocity": df["max_speed(mph)"], + "passengerCarUnit": empty_vectors, + "rechargeLevel2RateLimitInWatts": empty_vectors, + "rechargeLevel3RateLimitInWatts": empty_vectors, + "vehicleCategory": list(np.repeat("Class456Vocational", len(df.index))), + "sampleProbabilityWithinCategory": empty_vectors, + "sampleProbabilityString": empty_vectors, + "payloadCapacityInKg": df["payload_capacity_weight"], + "vehicleClass": df["veh_class"] + } + + df2 = pd.DataFrame(vehicles_techs) + df2["vehicleCategory"] = np.where(df2["vehicleTypeId"].str.contains('hdv'), 'Class78Vocational', + df2.vehicleCategory) + df2["vehicleCategory"] = np.where(df2["vehicleTypeId"].str.contains('hdt'), 'Class78Tractor', + df2.vehicleCategory) + df2["vehicleCategory"] = np.where(df2["vehicleTypeId"].str.contains('ld'), 'Class2b3Vocational', + df2.vehicleCategory) + + if _vehicle_types is None: + _vehicle_types = df2 + else: + _vehicle_types = pd.concat([_vehicle_types, df2]) + else: + print(f'SKIPPING {filename}') - _payload.drop(payload_plans_drop, axis=1, inplace=True, errors='ignore') - return _payload + _vehicle_types.to_csv( + f'{DIRECTORY_VEHICLE_TECH}/ft-vehicletypes--{BATCH_NAME.replace("-", "")}--{YEAR}-{SCENARIO_LABEL}.csv', + index=False) -# Save the modified DataFrame -format_payload(payload_plans).to_csv(f'{directory_output}/payloads--{year}-{run_name_label}.csv', index=False) + # Load OSM network and create buffer + _osm_edges_utm = load_osm_network( + NETWORK_OSM_PBF, + min_distance_from_edge=BUFFER_DISTANCE_METERS + ) -if ondemand_plans is not None: - format_payload(ondemand_plans).to_csv(f'{directory_output}/ondemand--{year}-{run_name_label}.csv', index=False) + _coordinate_lookup = {} -print("END") + # carrierId,tourId,vehicleId,vehicleTypeId,warehouseZone,warehouseX,warehouseY,MESOZONE,BoundaryZONE + carriers_renames = { + 'depot_zone': 'warehouseZone', + 'depot_zone_x': 'warehouseX', + 'depot_zone_y': 'warehouseY', + 'true_depot_zone': 'mesoZone' + } + carriers_drop = ['x', 'y', 'index'] + _carriers.rename(columns=carriers_renames, inplace=True) + _carriers.drop(carriers_drop, axis=1, inplace=True, errors='ignore') + _carriers['warehouseZone'] = _carriers['warehouseZone'].astype(int) + if SNAP_COORDINATES: + _carriers, _coordinate_lookup = snap_coordinates_when_too_far( + _carriers, + _osm_edges_utm, + "warehouseX", + "warehouseY", + _coordinate_lookup + ) + # Write + _carriers.to_csv(f'{DIRECTORY_SCENARIO}/carriers--{YEAR}-{SCENARIO_LABEL}.csv', index=False) + + # tourId,departureTimeInSec,departureLocationZone,maxTourDurationInSec,departureLocationX,departureLocationY + tours_renames = { + 'tour_id': 'tourId', + 'departureLocation_zone': 'departureLocationZone', + 'departureLocation_x': 'departureLocationX', + 'departureLocation_y': 'departureLocationY', + 'true_depot_zone': 'mesoZone' + } + _tours.rename(columns=tours_renames, inplace=True) + _tours['departureTimeInSec'] = _tours['departureTimeInSec'].astype(int) + _tours['maxTourDurationInSec'] = _tours['maxTourDurationInSec'].astype(int) + _tours['departureLocationZone'] = _tours['departureLocationZone'].astype(int) + _tours.drop(['index'], axis=1, inplace=True, errors='ignore') + if SNAP_COORDINATES: + _tours, _coordinate_lookup = snap_coordinates_when_too_far( + _tours, + _osm_edges_utm, + "departureLocationX", + "departureLocationY", + _coordinate_lookup + ) + # Write + _tours.to_csv(f'{DIRECTORY_SCENARIO}/tours--{YEAR}-{SCENARIO_LABEL}.csv', index=False) + + # Process payloads + print("Processing payload plans...") + # Add random_state for reproducibility + # sampled_df = _payload_plans.sample(n=1000, random_state=42).copy().reset_index(drop=True) + # sampled_df.to_csv(f'{DIRECTORY_OUTPUT}/payloads-sampled--{YEAR}-{SCENARIO_LABEL}.csv', index=False) + # Then format and save + # Create shared coordinate lookup table + _payload_plans = format_payload(_payload_plans) + if SNAP_COORDINATES: + # Snap coordinates and save + _payload_plans, _coordinate_lookup = snap_coordinates_when_too_far( + _payload_plans, + _osm_edges_utm, + "locationX", + "locationY", + _coordinate_lookup + ) + _payload_plans["operationDurationInSecOG"] = _payload_plans["operationDurationInSec"] + _payload_plans = update_operation_duration(STUDY_AREA_CONFIG, _payload_plans, _tours, _carriers, _vehicle_types) + _payload_plans.to_csv(f'{DIRECTORY_SCENARIO}/payloads--{YEAR}-{SCENARIO_LABEL}.csv', index=False) + + if _ondemand_plans is not None: + print("Processing ondemand plans...") + _ondemand_plans = format_payload(_ondemand_plans) + if SNAP_COORDINATES: + # Snap coordinates and save, reusing the lookup table + _ondemand_plans, _coordinate_lookup = snap_coordinates_when_too_far( + _ondemand_plans, + _osm_edges_utm, + "locationX", + "locationY", + _coordinate_lookup + ) + _ondemand_plans.to_csv(f'{DIRECTORY_SCENARIO}/ondemand--{YEAR}-{SCENARIO_LABEL}.csv', index=False) + + # Create combined plans file with both regular plans and ondemand plans + if _payload_plans is not None: + print("Creating combined plans file of payloads and crowdshipments...") + # Save the combined file + pd.concat([_payload_plans, _ondemand_plans], ignore_index=True).to_csv( + f'{DIRECTORY_SCENARIO}/payloads+crowdshipments--{YEAR}-{SCENARIO_LABEL}.csv', index=False + ) diff --git a/src/main/python/freight/process_frism_plans.py b/src/main/python/freight/process_frism_plans.py new file mode 100644 index 00000000000..1f9b6ab7489 --- /dev/null +++ b/src/main/python/freight/process_frism_plans.py @@ -0,0 +1,1189 @@ +import os + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from scipy import stats +import seaborn as sns + + +# Load the CSV file +import matplotlib.pyplot as plt + +def generate_duration_histogram(durations_minutes, label, output_file, bins=50, log_scale=False): + """ + Generate a histogram of operation durations. + + Parameters: + ----------- + durations_minutes : pandas.Series + Series containing operation durations in minutes + label : str + Label for the histogram title + output_file : str + Path to save the output histogram + bins : int, optional + Number of bins for the histogram (default is 50) + log_scale : bool, optional + Whether to use logarithmic scale for the x-axis (default is False) + + Returns: + -------- + dict + Dictionary containing basic statistics of the durations + """ + # Create a figure + plt.figure(figsize=(12, 6)) + + # Generate histogram + plt.hist(durations_minutes, bins=bins, alpha=0.75, color='steelblue', edgecolor='black') + + # Set logarithmic scale if specified + if log_scale: + plt.xscale('log') + + # Add title and labels + plt.title(f'Distribution of {label}', fontsize=14) + plt.xlabel('Operation Duration (minutes)', fontsize=12) + plt.ylabel('Frequency', fontsize=12) + + # Add grid + plt.grid(axis='y', linestyle='--', alpha=0.7) + + # Calculate and display statistics + mean_duration = durations_minutes.mean() + median_duration = durations_minutes.median() + + # Add text with statistics + stats_text = f'Mean: {mean_duration:.2f} minutes\nMedian: {median_duration:.2f} minutes' + plt.annotate(stats_text, xy=(0.95, 0.95), xycoords='axes fraction', + fontsize=10, ha='right', va='top', + bbox=dict(boxstyle='round,pad=0.5', facecolor='white', alpha=0.7)) + + # Show the plot + plt.tight_layout() + plt.savefig(output_file) + plt.show() + + print(f"Histogram saved as {output_file}") + + # Return basic statistics + return { + 'mean': mean_duration, + 'median': median_duration, + 'min': durations_minutes.min(), + 'max': durations_minutes.max() + } + +def plot_duration_comparison(df, duration_col1, duration_col2, group_col=None, output_file='duration_comparison.png'): + """ + Create a scatter plot comparing two sets of durations, + with optional grouping by a categorical variable. + + Parameters: + ----------- + df : pandas.DataFrame + The DataFrame containing the data + duration_col1 : str + Column name for the first duration in minutes + duration_col2 : str + Column name for the second duration in minutes + group_col : str, optional + Column name for grouping variable (categorical) + output_file : str + Path to save the output plot + + Returns: + -------- + dict + Dictionary containing correlation statistics + """ + # Ensure clean data by removing NaN values + plot_df = df.dropna(subset=[duration_col1, duration_col2]).copy() + + if plot_df.empty: + print(f"No valid data points found with non-null values in both {duration_col1} and {duration_col2}") + return None + + durations1 = plot_df[duration_col1] + durations2 = plot_df[duration_col2] + + # Create a figure + plt.figure(figsize=(12, 8)) + + if group_col is not None and group_col in plot_df.columns: + # Create a grouped scatter plot with different colors + groups = plot_df[group_col].unique() + + # Create a colormap with distinct colors + colors = plt.cm.tab10(np.linspace(0, 1, len(groups))) + + # Plot each group separately + for i, group in enumerate(groups): + group_data = plot_df[plot_df[group_col] == group] + plt.scatter(group_data[duration_col1], group_data[duration_col2], + alpha=0.6, color=colors[i], edgecolor='none', + label=f'{group}') + + # Calculate correlation for this group if enough data points + if len(group_data) > 2: + group_corr, _ = stats.pearsonr(group_data[duration_col1], group_data[duration_col2]) + + # Calculate and plot best fit line for this group + group_slope, group_intercept = np.polyfit(group_data[duration_col1], group_data[duration_col2], 1) + x_line = np.array([group_data[duration_col1].min(), group_data[duration_col1].max()]) + y_line = group_slope * x_line + group_intercept + plt.plot(x_line, y_line, color=colors[i], linewidth=2, + linestyle='--') + + # Add correlation text near the group in the plot + plt.annotate(f'r = {group_corr:.2f}', + xy=(group_data[duration_col1].median(), group_data[duration_col2].median()), + xytext=(10, 0), textcoords='offset points', + fontsize=9, color=colors[i]) + + plt.title(f'Comparison of Two Durations by {group_col}', fontsize=14) + else: + # Generate simple scatter plot if no grouping + plt.scatter(durations1, durations2, alpha=0.5, color='steelblue', edgecolor='none') + plt.title('Comparison of Two Durations', fontsize=14) + + # Add labels and grid + plt.xlabel(f'{duration_col1} (minutes)', fontsize=12) + plt.ylabel(f'{duration_col2} (minutes)', fontsize=12) + plt.grid(linestyle='--', alpha=0.7) + + # Save the plot to a file + plt.savefig(output_file) + plt.close() + + # Return correlation statistics + overall_corr, _ = stats.pearsonr(durations1, durations2) + return {'correlation': overall_corr} + +def plot_duration_vs_weight(df, duration_col, weight_col, group_col=None, output_file='duration_vs_weight.png'): + """ + Create a scatter plot showing the relationship between stop durations and weight, + with optional grouping by a categorical variable. + + Parameters: + ----------- + df : pandas.DataFrame + The DataFrame containing the data + duration_col : str + Column name for operation duration in minutes + weight_col : str + Column name for weight in pounds + group_col : str, optional + Column name for grouping variable (categorical) + output_file : str + Path to save the output plot + + Returns: + -------- + dict + Dictionary containing correlation statistics + """ + # Ensure clean data by removing NaN values + plot_df = df.dropna(subset=[duration_col, weight_col]).copy() + + if plot_df.empty: + print(f"No valid data points found with non-null values in both {duration_col} and {weight_col}") + return None + + # Use durations in minutes directly if already in minutes + durations_minutes = plot_df[duration_col] + weights_lbs = plot_df[weight_col] + + # Create a figure + plt.figure(figsize=(12, 8)) + + if group_col is not None and group_col in plot_df.columns: + # Create a grouped scatter plot with different colors + groups = plot_df[group_col].unique() + + # Create a colormap with distinct colors + colors = plt.cm.tab10(np.linspace(0, 1, len(groups))) + + # Plot each group separately + for i, group in enumerate(groups): + group_data = plot_df[plot_df[group_col] == group] + plt.scatter(group_data[duration_col], group_data[weight_col], + alpha=0.6, color=colors[i], edgecolor='none', + label=f'{group}') + + # Calculate correlation for this group if enough data points + if len(group_data) > 2: + group_corr, _ = stats.pearsonr(group_data[duration_col], group_data[weight_col]) + + # Calculate and plot best fit line for this group + group_slope, group_intercept = np.polyfit(group_data[duration_col], group_data[weight_col], 1) + x_line = np.array([group_data[duration_col].min(), group_data[duration_col].max()]) + y_line = group_slope * x_line + group_intercept + plt.plot(x_line, y_line, color=colors[i], linewidth=2, + linestyle='--') + + # Add correlation text near the group in the plot + plt.annotate(f'r = {group_corr:.2f}', + xy=(group_data[duration_col].median(), group_data[weight_col].median()), + xytext=(10, 0), textcoords='offset points', + fontsize=9, color=colors[i]) + + plt.title(f'Relationship Between Operation Duration and Weight by {group_col}', fontsize=14) + else: + # Generate simple scatter plot if no grouping + plt.scatter(durations_minutes, weights_lbs, alpha=0.5, color='steelblue', edgecolor='none') + plt.title('Relationship Between Operation Duration and Weight', fontsize=14) + + # Add labels and grid + plt.xlabel('Operation Duration (minutes)', fontsize=12) + plt.ylabel('Weight (lbs)', fontsize=12) + plt.grid(linestyle='--', alpha=0.7) + + # Calculate overall correlation coefficient and p-value + corr, p_value = stats.pearsonr(durations_minutes, weights_lbs) + + # Calculate and plot overall best fit line + slope, intercept = np.polyfit(durations_minutes, weights_lbs, 1) + x_line = np.array([durations_minutes.min(), durations_minutes.max()]) + y_line = slope * x_line + intercept + + if group_col is None: + # Only show the overall trend line when not grouping + plt.plot(x_line, y_line, color='red', linewidth=2, + label=f'y = {slope:.2f}x + {intercept:.2f}') + + # Add text with statistics + stats_text = (f'Overall Statistics:\n' + f'Pearson Correlation: {corr:.4f}\n' + f'P-value: {p_value:.4e}\n' + f'Slope: {slope:.4f}\n' + f'Intercept: {intercept:.2f}\n' + f'N = {len(durations_minutes)}') + + plt.annotate(stats_text, xy=(0.05, 0.95), xycoords='axes fraction', + fontsize=10, ha='left', va='top', + bbox=dict(boxstyle='round,pad=0.5', facecolor='white', alpha=0.7)) + + # Add legend if groups are present + if group_col is not None and group_col in plot_df.columns: + plt.legend(title=group_col) + else: + plt.legend() + + # Save the plot + plt.tight_layout() + plt.savefig(output_file) + plt.close() + + print(f"Scatter plot saved as '{output_file}'") + + # Return correlation statistics + return { + 'correlation': corr, + 'p_value': p_value, + 'slope': slope, + 'intercept': intercept, + 'n': len(durations_minutes) + } + + +def load_and_process_austin_data(trip_data_path, output_dir): + """ + Load and process the Austin Commercial Vehicle Survey data + with specific handling for the observed structure + """ + print("Loading Austin data files...") + + # Load both sheets from the trip data file + rec_20 = pd.read_excel(trip_data_path, sheet_name='Rec_20') + rec_21 = pd.read_excel(trip_data_path, sheet_name='Rec_21') + + print(f"Loaded sheet Rec_20 with {len(rec_20)} records") + print(f"Loaded sheet Rec_21 with {len(rec_21)} records") + + # Filter Rec_20 to keep only cargo vehicles (type=1) + if '23. Veh Type 1=Cargo, 2=Service, 3=Service with some Cargo' in rec_20.columns: + rec_20_filtered = rec_20[rec_20['23. Veh Type 1=Cargo, 2=Service, 3=Service with some Cargo'] == 1].copy() + print(f"Filtered Rec_20 to {len(rec_20_filtered)} cargo vehicles") + + # Keep only required columns from Rec_20 + vehicle_columns = [ + '3. Vehicle ID Number', + '22. Year of Vehicle', + '25. Vehicle Fuel Type', + '27. Vehicle Class.' + ] + + # Check if all required columns exist + missing_cols = [col for col in vehicle_columns if col not in rec_20_filtered.columns] + if missing_cols: + print(f"Warning: Missing columns in Rec_20: {missing_cols}") + vehicle_columns = [col for col in vehicle_columns if col in rec_20_filtered.columns] + + rec_20_filtered = rec_20_filtered[vehicle_columns].copy() + + # Create fuel type mapping + fuel_type_map = { + 1: 'Gasoline', + 2: 'Diesel', + 3: 'Propane', + 4: 'Natural Gas', + 5: 'Electricity', + 6: 'Gas/Electric Hybrid', + 96: 'Other', + 98: 'Don\'t Know', + 99: 'Refused' + } + + # Create vehicle class mapping + vehicle_class_map = { + 1: 'Passenger Car', + 2: 'Pick-up', + 3: 'Van (Cargo or Mini)', + 4: 'Sport Utility Vehicle (SUV)', + 5: 'Single Unit 2-axle (6 wheels)', + 6: 'Single Unit 3-axle (10 wheels)', + 7: 'Single Unit 4-axle (14 wheels)', + 8: 'Semi (all Tractor-Trailer Combinations)', + 96: 'Other' + } + + vehicle_class_mapping = { + "Semi (all Tractor-Trailer Combinations)": "Class78Tractor", + "Single Unit 2-axle (6 wheels)": "Class456Vocational", + "Single Unit 3-axle (10 wheels)": "Class456Vocational", + "Single Unit 4-axle (14 wheels)": "Class78Vocational" + } + + # Apply mappings if columns exist + if '25. Vehicle Fuel Type' in rec_20_filtered.columns: + rec_20_filtered['vehicleFuelType'] = rec_20_filtered['25. Vehicle Fuel Type'].map(fuel_type_map) + + if '27. Vehicle Class.' in rec_20_filtered.columns: + rec_20_filtered['vehicleClass'] = rec_20_filtered['27. Vehicle Class.'].map(vehicle_class_map).map(vehicle_class_mapping) + rec_20_filtered.dropna(subset=['vehicleClass'], inplace=True) + + # Rename columns for clarity + rec_20_filtered.rename(columns={ + '3. Vehicle ID Number': 'vehicleId', + '22. Year of Vehicle': 'vehicleModelYear', + }, inplace=True) + + # Drop original columns that have been mapped + if '25. Vehicle Fuel Type' in rec_20_filtered.columns: + rec_20_filtered.drop('25. Vehicle Fuel Type', axis=1, inplace=True) + + if '27. Vehicle Class.' in rec_20_filtered.columns: + rec_20_filtered.drop('27. Vehicle Class.', axis=1, inplace=True) + else: + print("Vehicle type column not found in Rec_20") + return None + + # Filter Rec_21 to keep only records with activity types 4, 5, and 6 + if '8. Type of Activity' in rec_21.columns: + cargo_activity_types = [4, 5, 6] # 4-Delivery of Cargo, 5-Pick up Cargo, 6-Deliver and Pick up Cargo + + # Create activity type mapping + activity_map = { + 4: 'Delivery of Cargo', + 5: 'Pick up Cargo', + 6: 'Deliver and Pick up Cargo' + } + + # Filter records + rec_21_filtered = rec_21[rec_21['8. Type of Activity'].isin(cargo_activity_types)].copy() + print(f"Filtered to {len(rec_21_filtered)} records with cargo activities (types 4, 5, 6)") + + # Add human-readable activity type + rec_21_filtered['activityType'] = rec_21_filtered['8. Type of Activity'].map(activity_map) + else: + print("Column '8. Type of Activity' not found in dataset") + return None + + # Calculate operation duration in minutes + if '29. Arrival Minute' in rec_21_filtered.columns and '31. Departure Minute' in rec_21_filtered.columns: + print("Calculating operation duration from minute-based time columns") + + # Create a mask for first trips (where arrival fields are blank/NaN) + first_trip_mask = rec_21_filtered['28. Arrival Hour'].isna() + + # Create a mask for last trips (where departure fields are blank/NaN) + last_trip_mask = rec_21_filtered['30. Departure Hour'].isna() + + # Initialize the operation duration column with NaN values + rec_21_filtered['operationDurationInMin'] = float('nan') + + # Make a copy of departure hour column to modify + departure_hours = rec_21_filtered['30. Departure Hour'].copy() + + # Replace 0 hour with 24 hours (regardless of minutes) + departure_hours.loc[departure_hours == 0] = 24 + + # Calculate duration only for regular trips (not first or last) + regular_trips = ~(first_trip_mask | last_trip_mask) + rec_21_filtered.loc[regular_trips, 'operationDurationInMin'] = ( + (departure_hours.loc[regular_trips] - + rec_21_filtered.loc[regular_trips, '28. Arrival Hour']) * 60 + + (rec_21_filtered.loc[regular_trips, '31. Departure Minute'] - + rec_21_filtered.loc[regular_trips, '29. Arrival Minute']) + ) + else: + print("Could not find minute-based time columns") + return None + + # Extract cargo weights + if '25. Cargo Weight PU' in rec_21_filtered.columns: + rec_21_filtered['cargoWeightPU'] = rec_21_filtered['25. Cargo Weight PU'] + else: + print("Column '25. Cargo Weight PU' not found, adding empty column") + rec_21_filtered['cargoWeightPU'] = np.nan + + if '26. Cargo Weight DO' in rec_21_filtered.columns: + rec_21_filtered['cargoWeightDO'] = rec_21_filtered['26. Cargo Weight DO'] + else: + print("Column '26. Cargo Weight DO' not found, adding empty column") + rec_21_filtered['cargoWeightDO'] = np.nan + + # Rename Vehicle ID in rec_21_filtered for merging + if '3. Vehicle ID Number' in rec_21_filtered.columns: + rec_21_filtered.rename(columns={'3. Vehicle ID Number': 'vehicleId'}, inplace=True) + + # Merge rec_21_filtered with rec_20_filtered + if 'vehicleId' in rec_21_filtered.columns and 'vehicleId' in rec_20_filtered.columns: + print("Merging trip data with vehicle information") + merged_data = pd.merge( + rec_21_filtered, + rec_20_filtered, + on='vehicleId', + how='inner' # Keep only records that exist in both datasets + ) + print(f"Merged data has {len(merged_data)} records") + else: + print("Vehicle ID column not found for merging") + return None + + # Create output CSV with only the required columns + output_columns = [ + 'vehicleId', + 'vehicleModelYear', + 'vehicleFuelType', + 'vehicleClass', + 'operationDurationInMin', + 'activityType', + 'cargoWeightPU', + 'cargoWeightDO' + ] + + # Check that all output columns exist + missing_cols = [col for col in output_columns if col not in merged_data.columns] + if missing_cols: + print(f"Warning: Missing columns in merged data: {missing_cols}") + output_columns = [col for col in output_columns if col in merged_data.columns] + + output_df = merged_data[output_columns] + + # Save to CSV + csv_path = os.path.join(output_dir, 'austin_cargo_operations.csv') + output_df.to_csv(csv_path, index=False) + print(f"CSV file saved to {csv_path}") + + return merged_data + + +def analyze_durations_by_key(df, key_column, duration_column, output_dir='.', prefix=''): + """ + Analyze and visualize stop durations by a key column (e.g., activity type, land use, vehicle type) + + Parameters: + ----------- + df : pandas.DataFrame + DataFrame containing the data + key_column : str + Column name to group by (e.g., 'activity_type', 'place_type') + duration_column : str + Column name for duration data + output_dir : str + Directory to save output files + prefix : str + Prefix for output filenames + + Returns: + -------- + pandas.DataFrame + DataFrame with aggregated statistics + """ + # Ensure output directory exists + os.makedirs(output_dir, exist_ok=True) + + # Check if columns exist + if key_column not in df.columns: + print(f"Column '{key_column}' not found in DataFrame") + return None + + if duration_column not in df.columns: + print(f"Column '{duration_column}' not found in DataFrame") + return None + + # Group by key column and calculate statistics + stats = df.groupby(key_column)[duration_column].agg([ + 'count', 'mean', 'median', 'std', 'min', 'max' + ]).reset_index() + + # Convert key column to string for plotting + stats[key_column] = stats[key_column].astype(str) + + # Create visualization + plt.figure(figsize=(12, 6)) + plt.bar(stats[key_column], stats['mean'], color='steelblue') + plt.title(f'Average Duration by {key_column}', fontsize=14) + plt.xlabel(key_column, fontsize=12) + plt.ylabel(f'Average Duration (minutes)', fontsize=12) + plt.xticks(rotation=45, ha='right') + plt.grid(axis='y', linestyle='--', alpha=0.7) + plt.tight_layout() + + # Save the plot + output_path = os.path.join(output_dir, f'{prefix}_{key_column.lower()}_duration_analysis.png') + plt.savefig(output_path) + plt.close() + + # Save the data + csv_path = os.path.join(output_dir, f'{prefix}_{key_column.lower()}_duration_analysis.csv') + stats.to_csv(csv_path, index=False) + + print(f"Analysis for {key_column} saved to {output_dir}") + + return stats + +def analyze_austin_operation_durations(data, output_dir='.'): + """ + Analyze operation durations from the Austin CV Survey data + """ + print("Analyzing Austin operation durations...") + + # Ensure output directory exists + os.makedirs(output_dir, exist_ok=True) + + # Check if we have the necessary columns + if 'stop_duration' not in data.columns: + print("Cannot analyze durations - stop_duration column not found") + return None + + # Generate histogram of stop durations + plt.figure(figsize=(12, 6)) + plt.hist(data['stop_duration'], bins=50, alpha=0.75, color='steelblue', edgecolor='black') + plt.title('Distribution of Austin CV Survey Operation Durations', fontsize=14) + plt.xlabel('Operation Duration (minutes)', fontsize=12) + plt.ylabel('Frequency', fontsize=12) + plt.grid(axis='y', linestyle='--', alpha=0.7) + + # Calculate and display statistics + mean_duration = data['stop_duration'].mean() + median_duration = data['stop_duration'].median() + + stats_text = f'Mean: {mean_duration:.2f} minutes\nMedian: {median_duration:.2f} minutes' + plt.annotate(stats_text, xy=(0.95, 0.95), xycoords='axes fraction', + fontsize=10, ha='right', va='top', + bbox=dict(boxstyle='round,pad=0.5', facecolor='white', alpha=0.7)) + + plt.tight_layout() + plt.savefig(os.path.join(output_dir, 'austin_duration_histogram.png')) + plt.close() + + # Analyze by activity type if available + if 'activity_type' in data.columns: + analyze_durations_by_key( + data, + 'activity_type', + 'stop_duration', + output_dir=output_dir, + prefix='austin' + ) + + # Analyze by place type if available + if 'place_type' in data.columns: + analyze_durations_by_key( + data, + 'place_type', + 'stop_duration', + output_dir=output_dir, + prefix='austin' + ) + + # Return statistics + stats = { + 'mean': mean_duration, + 'median': median_duration, + 'min': data['stop_duration'].min(), + 'max': data['stop_duration'].max() + } + + return stats + + +def analyze_cargo_operations(df, output_dir): + """ + Comprehensive analysis of cargo operations data + + Parameters: + ----------- + file_path : str + Path to the CSV file containing cargo operations data + """ + # Display basic information + print("\n===== BASIC INFORMATION =====") + print(f"Dataset shape: {df.shape}") + print("\nFirst few rows:") + print(df.head()) + print("\nColumn information:") + print(df.info()) + print("\nSummary statistics:") + print(df.describe()) + + # Check for missing values + print("\n===== MISSING VALUES =====") + missing = df.isnull().sum() + print(missing[missing > 0]) + + # Clean the data + print("\n===== DATA CLEANING =====") + # Convert operation duration to numeric if not already + if df['operationDurationInMin'].dtype == 'object': + df['operationDurationInMin'] = pd.to_numeric(df['operationDurationInMin'], errors='coerce') + print("Converted operationDurationInMin to numeric") + + # Handle missing values in cargo weights + if 'cargoWeightPU' in df.columns and df['cargoWeightPU'].isnull().sum() > 0: + print(f"Missing values in cargoWeightPU: {df['cargoWeightPU'].isnull().sum()}") + # For analysis purposes, we'll separate pickup and delivery operations + pickup_ops = df[df['activityType'] == 'Pick up Cargo'].copy() + delivery_ops = df[df['activityType'] == 'Delivery of Cargo'].copy() + print(f"Pickup operations: {pickup_ops.shape[0]}, Delivery operations: {delivery_ops.shape[0]}") + + # Remove extreme outliers (if needed) + q1 = df['operationDurationInMin'].quantile(0.01) + q3 = df['operationDurationInMin'].quantile(0.99) + iqr = q3 - q1 + + print(f"Duration statistics before outlier treatment:") + print(f"Min: {df['operationDurationInMin'].min()}, Max: {df['operationDurationInMin'].max()}") + print(f"Mean: {df['operationDurationInMin'].mean():.2f}, Median: {df['operationDurationInMin'].median():.2f}") + print(f"1% percentile: {q1}, 99% percentile: {q3}") + + # Create a copy for analysis without extreme outliers + df_no_outliers = df[(df['operationDurationInMin'] >= q1 - 1.5 * iqr) & + (df['operationDurationInMin'] <= q3 + 1.5 * iqr)].copy() + + print(f"\nRemoved {df.shape[0] - df_no_outliers.shape[0]} extreme outliers") + print(f"Duration statistics after outlier treatment:") + print( + f"Min: {df_no_outliers['operationDurationInMin'].min()}, Max: {df_no_outliers['operationDurationInMin'].max()}") + print( + f"Mean: {df_no_outliers['operationDurationInMin'].mean():.2f}, Median: {df_no_outliers['operationDurationInMin'].median():.2f}") + + # Create visualizations + print("\n===== CREATING VISUALIZATIONS =====") + + # Set up the plotting environment + plt.style.use('ggplot') + sns.set(font_scale=1.2) + + # 1. Distribution of operation durations + plt.figure(figsize=(12, 6)) + + plt.subplot(1, 2, 1) + sns.histplot(df['operationDurationInMin'], kde=True, bins=30) + plt.title('Distribution of Operation Durations') + plt.xlabel('Duration (minutes)') + plt.ylabel('Frequency') + + plt.subplot(1, 2, 2) + sns.histplot(df['operationDurationInMin'], kde=True, log_scale=True, bins=30) + plt.title('Distribution of Operation Durations (Log Scale)') + plt.xlabel('Duration (minutes) - Log Scale') + plt.ylabel('Frequency') + + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_distribution.png") + plt.close() + print("Created duration distribution plot") + + # 2. Operation Duration by Vehicle Model Year + plt.figure(figsize=(14, 8)) + + # Calculate average duration by model year + year_duration = df.groupby('vehicleModelYear')['operationDurationInMin'].agg(['mean', 'median', 'count']) + year_duration = year_duration.reset_index() + + # Plot with size representing count + plt.subplot(1, 2, 1) + sns.scatterplot(data=year_duration, x='vehicleModelYear', y='mean', size='count', sizes=(20, 500), alpha=0.7) + plt.title('Average Operation Duration by Vehicle Model Year') + plt.xlabel('Vehicle Model Year') + plt.ylabel('Average Duration (minutes)') + + plt.subplot(1, 2, 2) + sns.boxplot(data=df, x='vehicleModelYear', y='operationDurationInMin') + plt.title('Operation Duration Distribution by Vehicle Model Year') + plt.xlabel('Vehicle Model Year') + plt.ylabel('Duration (minutes)') + plt.xticks(rotation=45) + + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_by_year.png") + plt.close() + print("Created duration by vehicle year plot") + + # 3. Operation Duration by Activity Type + if 'activityType' in df.columns: + plt.figure(figsize=(14, 6)) + + plt.subplot(1, 2, 1) + sns.boxplot(data=df, x='activityType', y='operationDurationInMin') + plt.title('Operation Duration by Activity Type') + plt.xlabel('Activity Type') + plt.ylabel('Duration (minutes)') + + plt.subplot(1, 2, 2) + activity_counts = df['activityType'].value_counts() + sns.barplot(x=activity_counts.index, y=activity_counts.values) + plt.title('Count by Activity Type') + plt.xlabel('Activity Type') + plt.ylabel('Count') + + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_by_activity.png") + plt.close() + print("Created duration by activity type plot") + + # 4. Operation Duration by Cargo Weight (for pickup operations) + pickup_ops = df[df['activityType'] == 'Pick up Cargo'].copy() + if 'cargoWeightPU' in df.columns and not pickup_ops.empty: + plt.figure(figsize=(14, 8)) + + # Remove NaN values for this analysis + pickup_with_weight = pickup_ops.dropna(subset=['cargoWeightPU']) + + if not pickup_with_weight.empty: + plt.subplot(1, 2, 1) + sns.scatterplot(data=pickup_with_weight, x='cargoWeightPU', y='operationDurationInMin', alpha=0.5) + plt.title('Operation Duration vs Cargo Weight (Pick Up)') + plt.xlabel('Cargo Weight (Pick Up)') + plt.ylabel('Duration (minutes)') + + plt.subplot(1, 2, 2) + # Create weight bins + pickup_with_weight['weight_bin'] = pd.cut(pickup_with_weight['cargoWeightPU'], bins=10) + sns.boxplot(data=pickup_with_weight, x='weight_bin', y='operationDurationInMin') + plt.title('Operation Duration by Cargo Weight Range (Pick Up)') + plt.xlabel('Cargo Weight Range') + plt.ylabel('Duration (minutes)') + plt.xticks(rotation=90) + + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_by_weight_pickup.png") + plt.close() + print("Created duration by cargo weight plot for pickup operations") + + # 5. Operation Duration by Cargo Weight (for delivery operations) + delivery_ops = df[df['activityType'] == 'Delivery of Cargo'].copy() + if 'cargoWeightDO' in df.columns and not delivery_ops.empty: + plt.figure(figsize=(14, 8)) + + # Remove NaN values for this analysis + delivery_with_weight = delivery_ops.dropna(subset=['cargoWeightDO']) + + if not delivery_with_weight.empty: + plt.subplot(1, 2, 1) + sns.scatterplot(data=delivery_with_weight, x='cargoWeightDO', y='operationDurationInMin', alpha=0.5) + plt.title('Operation Duration vs Cargo Weight (Delivery)') + plt.xlabel('Cargo Weight (Delivery)') + plt.ylabel('Duration (minutes)') + + plt.subplot(1, 2, 2) + # Create weight bins + delivery_with_weight['weight_bin'] = pd.cut(delivery_with_weight['cargoWeightDO'], bins=10) + sns.boxplot(data=delivery_with_weight, x='weight_bin', y='operationDurationInMin') + plt.title('Operation Duration by Cargo Weight Range (Delivery)') + plt.xlabel('Cargo Weight Range') + plt.ylabel('Duration (minutes)') + plt.xticks(rotation=90) + + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_by_weight_delivery.png") + plt.close() + print("Created duration by cargo weight plot for delivery operations") + + # 6. Operation Duration by Vehicle Fuel Type + plt.figure(figsize=(12, 6)) + + fuel_counts = df['vehicleFuelType'].value_counts() + + plt.subplot(1, 2, 1) + sns.boxplot(data=df, x='vehicleFuelType', y='operationDurationInMin') + plt.title('Operation Duration by Fuel Type') + plt.xlabel('Fuel Type') + plt.ylabel('Duration (minutes)') + + plt.subplot(1, 2, 2) + sns.barplot(x=fuel_counts.index, y=fuel_counts.values) + plt.title('Count of Vehicles by Fuel Type') + plt.xlabel('Fuel Type') + plt.ylabel('Count') + + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_by_fuel_type.png") + plt.close() + print("Created duration by fuel type plot") + + # 7. Operation Duration by Vehicle Class + plt.figure(figsize=(12, 6)) + + class_counts = df['vehicleClass'].value_counts() + + plt.subplot(1, 2, 1) + sns.boxplot(data=df, x='vehicleClass', y='operationDurationInMin') + plt.title('Operation Duration by Vehicle Class') + plt.xlabel('Vehicle Class') + plt.ylabel('Duration (minutes)') + plt.xticks(rotation=45) + + plt.subplot(1, 2, 2) + sns.barplot(x=class_counts.index, y=class_counts.values) + plt.title('Count of Vehicles by Class') + plt.xlabel('Vehicle Class') + plt.ylabel('Count') + plt.xticks(rotation=45) + + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_by_vehicle_class.png") + plt.close() + print("Created duration by vehicle class plot") + + # 8. Correlation heatmap for numerical variables + plt.figure(figsize=(10, 8)) + + # Select only numeric columns + numeric_df = df.select_dtypes(include=[np.number]) + + # 9. Vehicle ID analysis - operations per vehicle + vehicle_ops = df.groupby('vehicleId').size().reset_index(name='operation_count') + vehicle_ops = vehicle_ops.sort_values('operation_count', ascending=False) + + plt.figure(figsize=(12, 6)) + plt.bar(range(len(vehicle_ops[:20])), vehicle_ops['operation_count'][:20]) + plt.xticks(range(len(vehicle_ops[:20])), vehicle_ops['vehicleId'][:20], rotation=45) + plt.title('Number of Operations by Vehicle ID (Top 20)') + plt.xlabel('Vehicle ID') + plt.ylabel('Number of Operations') + plt.tight_layout() + plt.savefig(f"{output_dir}/operations_by_vehicle.png") + plt.close() + print("Created operations by vehicle plot") + + # Statistical analysis + print("\n===== STATISTICAL ANALYSIS =====") + + # 1. Summary by vehicle class + class_summary = df.groupby('vehicleClass')['operationDurationInMin'].agg( + ['count', 'mean', 'median', 'std', 'min', 'max']) + print("\nOperation Duration Summary by Vehicle Class:") + print(class_summary) + + # 2. Summary by fuel type + fuel_summary = df.groupby('vehicleFuelType')['operationDurationInMin'].agg( + ['count', 'mean', 'median', 'std', 'min', 'max']) + print("\nOperation Duration Summary by Fuel Type:") + print(fuel_summary) + + # 3. Summary by activity type + if 'activityType' in df.columns: + activity_summary = df.groupby('activityType')['operationDurationInMin'].agg( + ['count', 'mean', 'median', 'std', 'min', 'max']) + print("\nOperation Duration Summary by Activity Type:") + print(activity_summary) + + # 4. Summary by vehicle model year + year_summary = df.groupby('vehicleModelYear')['operationDurationInMin'].agg( + ['count', 'mean', 'median', 'std', 'min', 'max']) + print("\nOperation Duration Summary by Vehicle Model Year:") + print(year_summary) + + # 5. Correlation analysis + print("\nCorrelation with Operation Duration:") + for col in numeric_df.columns: + if col != 'operationDurationInMin': + correlation = df['operationDurationInMin'].corr(df[col]) + print(f"{col}: {correlation:.4f}") + + # 6. Top 10 longest operations + print("\nTop 10 Longest Operations:") + print(df.nlargest(10, 'operationDurationInMin')[ + ['vehicleId', 'vehicleModelYear', 'vehicleFuelType', 'vehicleClass', 'operationDurationInMin', + 'activityType']]) + + # 7. Top 10 shortest operations (excluding zeros) + print("\nTop 10 Shortest Operations (excluding zeros):") + print(df[df['operationDurationInMin'] > 0].nsmallest(10, 'operationDurationInMin')[ + ['vehicleId', 'vehicleModelYear', 'vehicleFuelType', 'vehicleClass', 'operationDurationInMin', + 'activityType']]) + + # 8. Zero duration operations + zero_durations = df[df['operationDurationInMin'] == 0] + print( + f"\nNumber of zero-duration operations: {zero_durations.shape[0]}") + + # 9. Duration buckets analysis + duration_buckets = [ + (0, 0), + (0, 15), + (15, 30), + (30, 60), + (60, 120), + (120, 240), + (240, 480), + (480, 1000), + (1000, float('inf')) + ] + + bucket_labels = [ + 'Zero', + '0-15 min', + '15-30 min', + '30-60 min', + '1-2 hours', + '2-4 hours', + '4-8 hours', + '8-16 hours', + '16+ hours' + ] + + bucket_counts = [] + for i, (lower, upper) in enumerate(duration_buckets): + if i == 0: # Zero duration case + count = (df['operationDurationInMin'] == 0).sum() + else: + count = ((df['operationDurationInMin'] > lower) & (df['operationDurationInMin'] <= upper)).sum() + bucket_counts.append(count) + + plt.figure(figsize=(12, 6)) + plt.bar(bucket_labels, bucket_counts) + plt.title('Operation Counts by Duration Buckets') + plt.xlabel('Duration Bucket') + plt.ylabel('Count') + plt.xticks(rotation=45) + plt.tight_layout() + plt.savefig(f"{output_dir}/duration_buckets.png") + plt.close() + print("Created duration buckets analysis") + + # Save summary to CSV + summary_df = pd.DataFrame({ + 'Metric': ['Total Operations', 'Average Duration (min)', 'Median Duration (min)', + 'Min Duration (min)', 'Max Duration (min)', 'Std Dev Duration (min)', + 'Zero Duration Operations', 'Operations > 60 min', 'Operations > 120 min', + 'Operations > 480 min', 'Operations > 1000 min'], + 'Value': [df.shape[0], + df['operationDurationInMin'].mean(), + df['operationDurationInMin'].median(), + df['operationDurationInMin'].min(), + df['operationDurationInMin'].max(), + df['operationDurationInMin'].std(), + zero_durations.shape[0], + df[df['operationDurationInMin'] > 60].shape[0], + df[df['operationDurationInMin'] > 120].shape[0], + df[df['operationDurationInMin'] > 480].shape[0], + df[df['operationDurationInMin'] > 1000].shape[0]] + }) + + summary_df.to_csv(f"{output_dir}/summary_statistics.csv", index=False) + class_summary.to_csv(f"{output_dir}/class_summary.csv") + fuel_summary.to_csv(f"{output_dir}/fuel_summary.csv") + year_summary.to_csv(f"{output_dir}/year_summary.csv") + + if 'activityType' in df.columns: + activity_summary.to_csv(f"{output_dir}/activity_summary.csv") + + # Create a comprehensive report + with open(f"{output_dir}/analysis_report.txt", "w") as f: + f.write("=== CARGO OPERATIONS ANALYSIS REPORT ===\n\n") + f.write(f"Total Records: {df.shape[0]}\n\n") + + f.write("=== SUMMARY STATISTICS ===\n") + for i, row in summary_df.iterrows(): + f.write(f"{row['Metric']}: {row['Value']}\n") + + f.write("\n=== VEHICLE INFORMATION ===\n") + f.write(f"Total unique vehicles: {df['vehicleId'].nunique()}\n") + f.write(f"Vehicle model years range: {df['vehicleModelYear'].min()} to {df['vehicleModelYear'].max()}\n") + f.write(f"Vehicle fuel types: {', '.join(df['vehicleFuelType'].unique())}\n") + f.write(f"Vehicle classes: {', '.join(df['vehicleClass'].unique())}\n") + + + f.write("\n=== CORRELATION ANALYSIS ===\n") + f.write("Correlation with Operation Duration:\n") + for col in numeric_df.columns: + if col != 'operationDurationInMin': + correlation = df['operationDurationInMin'].corr(df[col]) + f.write(f"{col}: {correlation:.4f}\n") + + f.write("\n=== NOTABLE OBSERVATIONS ===\n") + # Add any notable observations here based on the analysis + if df['operationDurationInMin'].max() > 1000: + f.write("- Some operations have extremely long durations (over 16 hours)\n") + + if zero_durations.shape[0] > 0: + f.write(f"- {zero_durations.shape[0]} operations have zero duration\n") + + # Add vehicle class specific observations + for vehicle_class in df['vehicleClass'].unique(): + class_data = df[df['vehicleClass'] == vehicle_class] + avg_duration = class_data['operationDurationInMin'].mean() + f.write(f"- {vehicle_class} vehicles have an average operation duration of {avg_duration:.2f} minutes\n") + + f.write("\n=== CONCLUSION ===\n") + f.write( + "This analysis provides insights into the cargo operations data, highlighting patterns in operation durations across different vehicle types, model years, and activity types.\n") + + print(f"\nAnalysis complete. Results saved to {output_dir}/") + print(f"A comprehensive report has been generated at {output_dir}/analysis_report.txt") + + return df + + +def main(): + payloads = pd.read_csv("outputs/payloads_test.csv") + payloads['operationDurationInMin'] = payloads['operationDurationInSec'] / 60 + payloads['operationDurationInMinOG'] = payloads['operationDurationInSecOG'] / 60 + payloads['weightInLbs'] = payloads['weightInKg'] * 2.20462 + + generate_duration_histogram( + payloads["operationDurationInMin"], + label="Model Durations", + output_file='outputs/model_duration_histogram.png', + log_scale=False + ) + + generate_duration_histogram( + payloads["operationDurationInMinOG"], + label="FRISM Durations", + output_file='outputs/frism_duration_histogram.png', + log_scale=False + ) + + plot_duration_comparison( + payloads, + duration_col1='operationDurationInMin', + duration_col2='operationDurationInMinOG', + group_col='requestType', + output_file='outputs/mode_duration_vs_frism_duration_by_pudo.png' + ) + + plot_duration_vs_weight( + payloads[payloads["requestType"] == "loading"], + duration_col='operationDurationInMin', + weight_col='weightInLbs', + group_col=None, + output_file='outputs/duration_vs_weight_pu.png' + ) + + plot_duration_vs_weight( + payloads[payloads["requestType"] == "unloading"], + duration_col='operationDurationInMin', + weight_col='weightInLbs', + group_col=None, + output_file='outputs/duration_vs_weight_do.png' + ) + + +def main2(): + """ + Main function to run the analysis + """ + print("Starting Commercial Vehicle Operation Duration Analysis") + + # File paths + austin_dir = os.path.expanduser("~/Workspace/Simulation/sfbay/data/Austin_2017") + frism_dir = os.path.expanduser("~/Workspace/Simulation/sfbay/frism/2024-01-23/Baseline") + output_dir = os.path.expanduser("~/Workspace/Simulation/sfbay/data/Austin_2017/output") + + # Ensure output directory exists + os.makedirs(output_dir, exist_ok=True) + + # Process Austin CV Survey data and generate CSV file + try: + print("\nProcessing Austin Commercial Vehicle Survey data...") + trip_data_path = f"{austin_dir}/Raw 2017-2018 Austin Commercial Vehicle Travel Survey Data for UT and ANL.xlsx" + + # Load, process, and generate CSV file + austin_data = load_and_process_austin_data(trip_data_path, output_dir) + austin_data["cargoWeightPUdiffDO"] = austin_data["cargoWeightPU"] - austin_data["cargoWeightDO"] + + analyze_cargo_operations(austin_data, output_dir) + + plot_duration_vs_weight( + austin_data[austin_data["activityType"]=="Pick up Cargo"], + duration_col='operationDurationInMin', + weight_col='cargoWeightPU', + group_col=None, + output_file=os.path.join(output_dir, 'austin_duration_vs_weight_pu.png') + ) + + plot_duration_vs_weight( + austin_data[austin_data["activityType"]=="Delivery of Cargo"], + duration_col='operationDurationInMin', + weight_col='cargoWeightDO', + group_col=None, + output_file=os.path.join(output_dir, 'austin_duration_vs_weight_do.png') + ) + + plot_duration_vs_weight( + austin_data[austin_data["activityType"]=="Deliver and Pick up Cargo"], + duration_col='operationDurationInMin', + weight_col='cargoWeightPUdiffDO', + group_col=None, + output_file=os.path.join(output_dir, 'austin_duration_vs_weight_pu_diff_do.png') + ) + + except Exception as e: + print(f"Error processing Austin data: {e}") + import traceback + traceback.print_exc() + + # Process FRISM plan data + try: + print("\nProcessing FRISM plan data...") + frism_b2b = pd.read_csv(f"{frism_dir}/B2B_all_payload_sBase_y2018.csv") + frism_b2c = pd.read_csv(f"{frism_dir}/B2C_all_payload_sBase_y2018.csv") + frism_data = pd.concat([frism_b2b, frism_b2c], ignore_index=True) + + # Ensure weight column is processed + if 'weightInlb' in frism_data.columns: + frism_data["weightInlbAbs"] = frism_data["weightInlb"].abs() + + # Generate histogram + generate_duration_histogram( + frism_data["operationDurationInSec"], + ) + + # Analyze by categorical variables if available + if 'operationType' in frism_data.columns: + analyze_durations_by_key( + frism_data, + 'operationType', + 'operationDurationInSec', + output_dir=output_dir, + prefix='frism' + ) + + print("FRISM data processing complete.") + except Exception as e: + print(f"Error processing FRISM data: {e}") + + print("\nAnalysis complete!") + print(f"Results saved to {output_dir} directory") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/main/python/freight/utils.py b/src/main/python/freight/utils.py new file mode 100644 index 00000000000..49c66731524 --- /dev/null +++ b/src/main/python/freight/utils.py @@ -0,0 +1,44 @@ + + +def read_csv(file_path): + import pandas as pd + compression = None + if file_path.endswith(".gz"): + compression = 'gzip' + return pd.read_csv(file_path, sep=",", index_col=None, header=0, compression=compression) + + +def read_csv_in_chunks(file_path): + import pandas as pd + compression = None + if file_path.endswith(".gz"): + compression = 'gzip' + # Read the large csv file in chunks + chunk_size = 5_000_000 # This will depend on your available memory + chunks = [] + for chunk in pd.read_csv(file_path, chunksize=chunk_size, sep=",", index_col=None, header=0, compression=compression): + # Process each chunk here if necessary, for example: + chunks.append(chunk) + # Concatenate all chunks into one DataFrame + return pd.concat(chunks, ignore_index=True) + + +def read_csv_in_parallel(file_path): + import dask.dataframe as dd + compression = None + if file_path.endswith(".gz"): + compression = 'gzip' + return dd.read_csv(file_path, compression=compression, blocksize=None) + + +def print2(file_path, msg): + with open(file_path + ".out", 'w') as f: + print(msg) + print(msg, file=f) + + +def construct_events_file_path(workspace, city, scenario, batch, iteration=0): + import os + base_dir = workspace+city+'/beam/runs/'+scenario+'/'+batch+"/" + filename = str(iteration)+'.events.csv.gz' + return os.path.expanduser(base_dir + filename) \ No newline at end of file diff --git a/src/main/python/network_validation/DownloadSFBay-2-OSMNX_3.ipynb b/src/main/python/network_validation/DownloadSFBay-2-OSMNX_3.ipynb new file mode 100644 index 00000000000..6b8fe828c1f --- /dev/null +++ b/src/main/python/network_validation/DownloadSFBay-2-OSMNX_3.ipynb @@ -0,0 +1,1141 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "22eeb57e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0.1\n" + ] + } + ], + "source": [ + "import osmnx as ox\n", + "import networkx as nx\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "import osmnx as ox\n", + "import matplotlib.colors as mcolors\n", + "import pickle\n", + "import contextily as ctx\n", + "import subprocess\n", + "import xml.etree.ElementTree as ET\n", + "import numpy as np\n", + "\n", + "print(ox.__version__)\n", + "\n", + "#in the settings specify a single date" + ] + }, + { + "cell_type": "markdown", + "id": "2198fe24", + "metadata": {}, + "source": [ + "# Define Scenario Configs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "697e0f9d", + "metadata": {}, + "outputs": [], + "source": [ + "studyArea = 'sfbay'\n", + "\n", + "simpl_intersections = 2\n", + "splitLinksBy = [\"highway\",\"lanes\", \"maxspeed\", \"hgv\", \"mgv\"]\n", + "#Define custom filters\n", + "cf1 = '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'\n", + "cf2 = '[\"highway\"~\"residential\"]'\n", + "cf3 = '[\"highway\"~\"motorway|primary|residential|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'\n", + "\n", + "desired_tags = [\"maxweight\", \"hgv\", \"maxweight:hgv\", \"maxlength\", \"maxaxleload\"]\n", + "ox.settings.useful_tags_way = list(ox.settings.useful_tags_way) + desired_tags\n", + "\n", + "# Filter access = private ... look at edge and nodes attirbtues for more\n", + "\n", + "if studyArea == 'sfbay':\n", + " is_addresses = False\n", + " is_bboxes = False\n", + " is_places = True\n", + " is_points = False\n", + " is_polygons = False\n", + " is_xmls = False\n", + " ######## PLACE ##############################\n", + "\n", + " # Input places (list of place names)\n", + " places = [\n", + " {\"county\": \"San Francisco\", \"state\": \"California\"},\n", + " {\"county\": \"San Francisco\", \"state\": \"California\"},\n", + " {\"county\": \"Alameda\", \"state\": \"California\"},\n", + " {\"county\": \"Contra Costa\", \"state\": \"California\"},\n", + " {\"county\": \"Marin\", \"state\": \"California\"},\n", + " {\"county\": \"Napa\", \"state\": \"California\"},\n", + " {\"county\": \"San Mateo\", \"state\": \"California\"},\n", + " {\"county\": \"Santa Clara\", \"state\": \"California\"},\n", + " {\"county\": \"Solano\", \"state\": \"California\"},\n", + " {\"county\": \"Sonoma\", \"state\": \"California\"},\n", + " ]\n", + "\n", + "\n", + " places_filters = {\n", + " \"network_type\": \"drive\", \n", + " \"simplify\": False, \n", + " \"retain_all\": True, \n", + " \"truncate_by_edge\": True,\n", + " \"which_result\": None, \n", + " \"custom_filter\": [\n", + " cf3,cf1,cf1,cf1,cf1,cf1,cf1,cf1,cf1\n", + " ]}\n", + " \n", + "\n", + "else:\n", + "\n", + " is_addresses = False\n", + " is_bboxes = False\n", + " is_places = True\n", + " is_points = False\n", + " is_polygons = False\n", + " is_xmls = False\n", + "\n", + " studyArea = 'NewYork'\n", + "\n", + "\n", + " # 0.00008983 = 10m\n", + " simpl_intersections = 2\n", + " splitLinksBy = [\"highway\",\"lanes\", \"maxspeed\"]\n", + "\n", + " #Define custom filters\n", + " cf1 = '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'\n", + " cf3 = '[\"highway\"~\"residential|motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'\n", + " cf2 = '[\"highway\"~\"residential\"]'\n", + " cf_main_highways = '[\"highway\"=\"motorway\"]'\n", + "\n", + " ############################## ADDRESS ##############################\n", + " addresses = [\"San Francisco, CA, USA\", \"San Francisco, CA, USA\"]\n", + " # addresses = [\"Milano, IT\", \"Milano, IT\"]\n", + " addresses_filters = {\n", + " \"dist\": 5000, \n", + " \"dist_type\": 'bbox', # \"network\", \"bbox\" if “bbox”, retain only those nodes within a \n", + " # bounding box of the distance parameter. if “network”, retain \n", + " # only those nodes within some network distance from the center-most node.\n", + " \"network_type\": \"drive\", #all\", \"all_public\", \"bike\", \"drive\", \"drive_service\", \"walk\"\n", + " \"simplify\": False, \n", + " \"retain_all\": True, # if True, return the entire graph even if it is not connected. otherwise, \n", + " # retain only the largest weakly connected component.\n", + " \"truncate_by_edge\": None, # if True, retain nodes outside bounding box if at least one \n", + " # of node’s neighbors is within the bounding box\n", + " \"custom_filter\": [cf2, cf1] #'[\"highway\"~\"motorway|trunk\"]' ‘[“power”~”line”]’ or ‘[“highway”~”motorway|trunk”]’.\n", + " }\n", + "\n", + " ############################## BBOX ##############################\n", + "\n", + " #Input bounding boxes (list of tuples representing bounding box coordinates)\n", + " bboxes = [(37.8, 37.7, -122.5, -122.4), (37.9, 37.8, -122.3, -122.2)]\n", + " bboxes_filters = {\n", + " \"network_typeTrue\": [\"drive\", \"bike\"], \n", + " \"simplify\": [False, False], \n", + " \"retain_all\": True, \n", + " \"truncate_by_edge\": [True, True], \n", + " \"custom_filter\": [cf2, cf1] \n", + " }\n", + "\n", + " ############################## PLACE ##############################\n", + "\n", + " # Input places (list of place names)\n", + " places = [\n", + " {\"county\": \"San Francisco\", \"state\": \"California\"},\n", + " {\"county\": \"San Francisco\", \"state\": \"California\"},\n", + " {\"county\": \"Alameda\", \"state\": \"California\"},\n", + " {\"county\": \"Contra Costa\", \"state\": \"California\"},\n", + " {\"county\": \"Marin\", \"state\": \"California\"},\n", + " {\"county\": \"Napa\", \"state\": \"California\"},\n", + " {\"county\": \"San Mateo\", \"state\": \"California\"},\n", + " {\"county\": \"Santa Clara\", \"state\": \"California\"},\n", + " {\"county\": \"Solano\", \"state\": \"California\"},\n", + " {\"county\": \"Sonoma\", \"state\": \"California\"},]\n", + "\n", + "\n", + " places_filters = {\n", + " \"network_type\": \"drive\",\n", + " \"simplify\": False, \n", + " \"retain_all\": True, \n", + " \"truncate_by_edge\": False, \n", + " \"which_result\": None, \n", + " \"custom_filter\": [\n", + " cf3,cf1,cf1,cf1,cf1,cf1,cf1,cf1,cf1,cf1\n", + " ]}\n", + "\n", + " ############################## POINT ##############################\n", + "\n", + " # Input points (list of tuples, each containing (latitude, longitude))\n", + " points = [(37.556036, -122.268709)]\n", + "\n", + " # San Francisco and Oakland\n", + " points_filters = {\n", + " \"dist\": [1000], # Retain only those nodes within this many meters of the center of the graph\n", + " \"dist_type\": 'bbox', \n", + " \"network_type\": [\"drive\", \"bike\"], \n", + " \"simplify\": [False, False], \n", + " \"retain_all\": True, \n", + " \"truncate_by_edge\": [False, True], \n", + " \"custom_filter\": cf1\n", + " }\n", + "\n", + " # Input polygons (using geocode to get polygon boundaries)\n", + " # (shapely.geometry.Polygon or shapely.geometry.MultiPolygon) – the shape to get network data within. \n", + " # coordinates should be in unprojected latitude-longitude degrees (EPSG:4326).\n", + "\n", + " ############################## POLYGON ##############################\n", + "\n", + "\n", + " # polygons = [ox.geocode_to_gdf(\"Downtown San Francisco\"), ox.geocode_to_gdf(\"Oakland\")]\n", + " polygons_filters = {\n", + " \"network_type\": [\"drive\", \"bike\"], \n", + " \"simplify\": [False, False], \n", + " \"retain_all\": True, \n", + " \"truncate_by_edge\": [True, True], \n", + " \"custom_filter\": '[\"building\"~\"yes\"]' \n", + " }\n", + "\n", + " # Input XML files (paths to files that contain OSM data in XML format)\n", + " xmls = [\"/path/to/sf.osm\", \"/path/to/berkeley.osm\"]\n", + " xmls_filters = {\n", + " \"bidirectional\": False, ####\n", + " \"simplify\": [False, False], \n", + " \"retain_all\": True, \n", + " \"encoding\": \"utf-8\", #### \n", + " \"custom_filter\": '[\"highway\"~\"residential\"]' \n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "522e01b1", + "metadata": {}, + "source": [ + "# INPUTS" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3b5761ae", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate the graph in 6 different ways\n", + "# Turn on the methods to be used, and insert the inputs\n", + "# Use lists to combine multiple graphs, and single values for common filter parameters\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "6002d0ff", + "metadata": {}, + "source": [ + "# FUNCTIONS" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "938734be", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Helper function to get the appropriate value from the filter\n", + "def get_filter_value(filter_param, index, total_count):\n", + " if isinstance(filter_param, list):\n", + " # If the parameter is a list, return the value for the current index\n", + " return filter_param[index % len(filter_param)]\n", + " else:\n", + " # If the parameter is a single value, return the same value for all\n", + " return filter_param\n", + "\n", + "# Helper function to apply filters dynamically\n", + "def apply_filters(filters, index, total_count):\n", + " return {key: get_filter_value(value, index, total_count) for key, value in filters.items()}\n", + "\n", + "# Generic function to generate graphs based on a method and a list of inputs\n", + "def generate_graphs(inputs, filters, graph_function):\n", + " graphs = []\n", + " for i, input_data in enumerate(inputs):\n", + " # Dynamically apply filters based on index\n", + " print(input_data)\n", + " dynamic_filters = apply_filters(filters, i, len(inputs))\n", + " print(dynamic_filters)\n", + " graph = graph_function(input_data, **dynamic_filters)\n", + "# plot(graph, f'{input_data}_{str(simpl_intersections)}_original_graph')\n", + " graphs.append(graph)\n", + " return nx.compose_all(graphs) if graphs else None\n", + "\n", + "# Specific functions using the generate_graphs utility\n", + "\n", + "def get_graph_from_address(addresses, filters):\n", + " return generate_graphs(addresses, filters, ox.graph_from_address)\n", + "\n", + "def get_graph_from_bbox(bboxes, filters):\n", + " return generate_graphs(bboxes, filters, lambda bbox, **kwargs: ox.graph_from_bbox(*bbox, **kwargs))\n", + "\n", + "def get_graph_from_place(places, filters):\n", + " return generate_graphs(places, filters, ox.graph_from_place)\n", + "\n", + "def get_graph_from_point(points, filters):\n", + " return generate_graphs(points, filters, ox.graph_from_point)\n", + "\n", + "def get_graph_from_polygon(polygons, filters):\n", + " return generate_graphs(polygons, filters, lambda polygon, **kwargs: ox.graph_from_polygon(polygon.geometry[0], **kwargs))\n", + "\n", + "def get_graph_from_xml(xmls, filters):\n", + " return generate_graphs(xmls, filters, ox.graph_from_xml)\n", + "\n", + "\n", + "# Function to generate and combine graphs\n", + "def combine_graphs():\n", + " combined_graphs = []\n", + "\n", + " if is_addresses:\n", + " address_graph = get_graph_from_address(addresses, addresses_filters)\n", + " if address_graph is not None:\n", + " combined_graphs.append(address_graph)\n", + " \n", + " if is_bboxes:\n", + " bbox_graph = get_graph_from_bbox(bboxes, bboxes_filters)\n", + " if bbox_graph is not None:\n", + " combined_graphs.append(bbox_graph)\n", + " \n", + " if is_places:\n", + " place_graph = get_graph_from_place(places, places_filters)\n", + " if place_graph is not None:\n", + " combined_graphs.append(place_graph)\n", + " \n", + " if is_points:\n", + " point_graph = get_graph_from_point(points, points_filters)\n", + " if point_graph is not None:\n", + " combined_graphs.append(point_graph)\n", + " \n", + " if is_polygons:\n", + " polygon_graph = get_graph_from_polygon(polygons, polygons_filters)\n", + " if polygon_graph is not None:\n", + " combined_graphs.append(polygon_graph)\n", + " \n", + " if is_xmls:\n", + " xml_graph = get_graph_from_xml(xmls, xmls_filters)\n", + " if xml_graph is not None:\n", + " combined_graphs.append(xml_graph)\n", + "\n", + " # Return the combined graph if there are any valid graphs, else return None\n", + " return nx.compose_all(combined_graphs) if combined_graphs else None\n", + "\n", + "def plot(G, name):\n", + " fig, ax = ox.plot.plot_graph(\n", + " G,\n", + " bgcolor=\"#FFFFFF\", # Light background\n", + "# node_color=\"#00FFAA\", # Bright teal nodes\n", + " node_color=\"#333333\", # Bright teal nodes\n", + " node_size=0.02,\n", + " node_edgecolor='none', # Node size 2.5\n", + "# node_alpha=0.8, # Node transparency\n", + "# node_edgecolor=\"#333333\", # Dark edges around nodes\n", + " node_zorder=3, # Nodes above edges\n", + " edge_color=\"#FF5A5F\", # Bright coral edges\n", + " edge_linewidth=0.2, # Edge thickness 0.5\n", + " edge_alpha=0.8, # Edge transparency\n", + " show=False, # Do not display immediately\n", + " close=False # Keep the plot open for saving\n", + " )\n", + " \n", + " ctx.add_basemap(ax, source=ctx.providers.CartoDB.Positron)\n", + "\n", + " # 3. Calculate statistics\n", + " num_nodes = len(G.nodes)\n", + " num_edges = len(G.edges)\n", + " # Total length in meters\n", + " total_length = sum(data.get('length', 0) for u, v, key, data in G.edges(keys=True, data=True))\n", + "\n", + " # 4. Add title with statistics\n", + " title = (\n", + " f\"Nodes: {num_nodes} | Edges: {num_edges} | Total Length: {total_length/1000:.2f} km\"\n", + " )\n", + " ax.set_title(title, fontsize=15, fontweight='bold', color='black', pad=20)\n", + " \n", + "\n", + " # 5. Save the figure with 600 DPI\n", + " fig.savefig(f'{name}.png', dpi=600, bbox_inches='tight')\n", + " \n", + "# Helper function to plot graph by attribute with legend\n", + "def plot_graph_by_attribute(G, attribute, title, figsize=(12, 12)):\n", + " # Extract values of the specified attribute from the edges\n", + " attribute_values = [G.edges[edge].get(attribute, 'unknown') for edge in G.edges]\n", + "\n", + " # Determine if the attribute is categorical or numerical\n", + " if isinstance(attribute_values[0], str) or isinstance(attribute_values[0], bool): # Categorical\n", + " unique_values = list(set(attribute_values))\n", + " colors = plt.cm.get_cmap('tab20', len(unique_values))(range(len(unique_values)))\n", + " colors = colors[np.random.permutation(len(unique_values))]\n", + " color_map = dict(zip(unique_values, colors))\n", + " edge_colors = [color_map[val] for val in attribute_values]\n", + " else: # Numerical\n", + " norm = mcolors.Normalize(vmin=min(attribute_values), vmax=max(attribute_values))\n", + " color_map = plt.cm.ScalarMappable(norm=norm, cmap='plasma')\n", + " edge_colors = [color_map.to_rgba(val) for val in attribute_values]\n", + "\n", + " # Plot the graph with edges colored by the specified attribute\n", + " fig, ax = plt.subplots(figsize=figsize)\n", + " ox.plot_graph(\n", + " G,\n", + " ax=ax,\n", + " bgcolor=\"#222222\",\n", + " node_color=\"#00FFAA\",\n", + " node_size=0.2,\n", + " node_alpha=0.9,\n", + " node_edgecolor=\"#333333\",\n", + " edge_color=edge_colors,\n", + " edge_linewidth=0.7,\n", + " edge_alpha=1,\n", + " show=False,\n", + " close=False\n", + " )\n", + " ctx.add_basemap(ax, source=ctx.providers.CartoDB.Positron)\n", + "\n", + " # Set title\n", + " ax.set_title(title, color=\"white\")\n", + "\n", + " # Add legend for categorical attributes\n", + " if isinstance(attribute_values[0], str) or isinstance(attribute_values[0], bool):\n", + " handles = [plt.Line2D([0], [0], color=color_map[val], lw=4) for val in unique_values]\n", + " ax.legend(handles, unique_values, title=attribute, loc=\"lower right\", frameon=False, fontsize=10)\n", + " elif isinstance(attribute_values[0], (int, float)):\n", + " # Add a color bar for numerical attributes\n", + " cbar = plt.colorbar(color_map, ax=ax)\n", + " cbar.set_label(attribute)\n", + "\n", + " fig.savefig(f'{studyArea}_{attribute}.png', dpi=600, bbox_inches='tight')\n", + " plt.show()\n", + " \n", + "def analyze_specific_edge_attributes(df):\n", + " # Descriptive stats for numeric attributes\n", + " numeric_summary = df[['length', 'speed_kph']].describe().T.round(2)\n", + " print(\"\\nDescriptive statistics for numeric attributes in edges:\")\n", + " display(numeric_summary)\n", + " \n", + " # Value counts for each categorical attribute in edges\n", + " categorical_attributes = ['oneway', 'maxspeed', 'lanes', 'sidewalk', 'cycleway', \n", + " 'access', 'maxweight', 'hgv', 'highway']\n", + " for attr in categorical_attributes:\n", + " print(f\"\\nValue counts for '{attr}' in edges:\")\n", + " value_counts_df = df[attr].value_counts(dropna=False).to_frame(name=\"Count\")\n", + " display(value_counts_df)\n", + "\n", + "def analyze_specific_node_attributes(df):\n", + " # Value counts for each categorical attribute in nodes\n", + " node_categorical_attributes = ['street_count', 'traffic_signals']\n", + " for attr in node_categorical_attributes:\n", + " print(f\"\\nValue counts for '{attr}' in nodes:\")\n", + " value_counts_df = df[attr].value_counts(dropna=False).to_frame(name=\"Count\")\n", + " display(value_counts_df)\n", + "\n", + "def save_graph_to_osm(G, filename=\"output.osm\"):\n", + " # Bounding box\n", + " xs = [d['x'] for _, d in G.nodes(data=True) if 'x' in d]\n", + " ys = [d['y'] for _, d in G.nodes(data=True) if 'y' in d]\n", + " minlon, maxlon = min(xs), max(xs)\n", + " minlat, maxlat = min(ys), max(ys)\n", + "\n", + " root = ET.Element(\"osm\", version=\"0.6\", generator=\"OSMnx2OSM\")\n", + " ET.SubElement(root, \"bounds\",\n", + " minlat=str(minlat), minlon=str(minlon),\n", + " maxlat=str(maxlat), maxlon=str(maxlon))\n", + "\n", + " node_map = {}\n", + " node_id = 1\n", + "\n", + " # Write nodes + attributes as tags\n", + " for n, d in G.nodes(data=True):\n", + " lat, lon = d.get('y'), d.get('x')\n", + " if lat is None or lon is None: continue\n", + " node = ET.SubElement(root, \"node\",\n", + " id=str(node_id), lat=str(lat), lon=str(lon),\n", + " version=\"1\", changeset=\"1\", user=\"osmnx\", uid=\"1\",\n", + " timestamp=\"2020-01-01T00:00:00Z\"\n", + " )\n", + " node_map[n] = node_id\n", + " for k, v in d.items():\n", + " if k not in (\"x\", \"y\") and v is not None:\n", + " ET.SubElement(node, \"tag\", k=str(k), v=str(v))\n", + " node_id += 1\n", + "\n", + " # Write ways (edges) + attributes as tags\n", + " way_id = -1\n", + " for u, v, edata in G.edges(data=True):\n", + " if u not in node_map or v not in node_map: \n", + " continue\n", + " way = ET.SubElement(root, \"way\",\n", + " id=str(way_id), version=\"1\", changeset=\"1\",\n", + " user=\"osmnx\", uid=\"1\", timestamp=\"2020-01-01T00:00:00Z\")\n", + " ET.SubElement(way, \"nd\", ref=str(node_map[u]))\n", + " ET.SubElement(way, \"nd\", ref=str(node_map[v]))\n", + " # At least one standard OSM tag\n", + " ET.SubElement(way, \"tag\", k=\"highway\", v=\"road\")\n", + " # Dump all other attributes\n", + " for k, v_ in edata.items():\n", + " if v_ is not None:\n", + " ET.SubElement(way, \"tag\", k=str(k), v=str(v_))\n", + " way_id -= 1\n", + "\n", + " ET.ElementTree(root).write(filename, encoding=\"utf-8\", xml_declaration=True)" + ] + }, + { + "cell_type": "markdown", + "id": "0939a512", + "metadata": {}, + "source": [ + "# FUNCTIONS FOR FREIGHT ATTRIBUTES" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0f86667b", + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "import pandas as pd\n", + "\n", + "# Example thresholds (adjust as needed)\n", + "MDV_LIMIT_LBS = 26000\n", + "HDV_LIMIT_LBS = 80000\n", + "MDV_LIMIT_FT = 40\n", + "HDV_LIMIT_FT = 53\n", + "\n", + "def parse_weight_to_lbs(w):\n", + " if not isinstance(w, str):\n", + " return None\n", + " s = w.strip().lower()\n", + " m = re.match(r\"(\\d+(\\.\\d+)?)\", s)\n", + " if not m:\n", + " return None\n", + " val = float(m.group(1))\n", + " # Simple pattern checks:\n", + " if ' lbs' in s: return val\n", + " if ' st' in s or 'st' in s: return val * 2000 # short tons\n", + " if ' t' in s: return val * 2204.6226 # metric tons\n", + " return val * 2000 # default to short tons\n", + "\n", + "def parse_length_to_feet(l):\n", + " if not isinstance(l, str):\n", + " return None\n", + " s = l.strip().lower()\n", + " m = re.match(r\"(\\d+)(\\'\\d+\\\"|\\'\\d+|\\'|\\\")?\", s)\n", + " if m:\n", + " return float(m.group(1))\n", + " try:\n", + " return float(s)\n", + " except:\n", + " return None\n", + "\n", + "def parse_hgv(h):\n", + " if h is True:\n", + " return True\n", + " if h is False:\n", + " return False\n", + " if isinstance(h, list) and True in h:\n", + " return True\n", + " return None\n", + "\n", + "def classify_truck_allowed(row):\n", + " w = row.get('maxweight_combined_lbs')\n", + " ft = row.get('maxlength_ft')\n", + " \n", + " # Helper to classify a numeric value (could be weight or length)\n", + " def classify_val(val, md_limit, hd_limit):\n", + " if val >= hd_limit:\n", + " return \"HD\"\n", + " elif val >= md_limit:\n", + " return \"MD\"\n", + " else:\n", + " return \"LD\"\n", + " \n", + " # Classify length if available\n", + " if pd.notnull(ft):\n", + " l_class = classify_val(ft, MDV_LIMIT_FT, HDV_LIMIT_FT)\n", + " else:\n", + " l_class = None\n", + " \n", + " # Classify weight if available\n", + " if pd.notnull(w):\n", + " w_class = classify_val(w, MDV_LIMIT_LBS, HDV_LIMIT_LBS)\n", + " else:\n", + " w_class = None\n", + " \n", + " # Combine logic\n", + " # Priority: if both exist, take the \"stricter\" (lower) class. \n", + " # If only one exists, use that. If neither, return None.\n", + " if w_class and l_class:\n", + " rank = {\"LD\": 0, \"MD\": 1, \"HD\": 2}\n", + " return w_class if rank[w_class] <= rank[l_class] else l_class\n", + " elif w_class:\n", + " return w_class\n", + " elif l_class:\n", + " return l_class\n", + " else:\n", + " return None\n", + " \n", + "def interpret_hgv_str(val):\n", + " \"\"\"\n", + " Example logic:\n", + " - \"no\" remains \"no\"\n", + " - everything else, treat as \"yes\"\n", + " \n", + " designated 4613\n", + " no 424\n", + " destination 34\n", + " delivery 12\n", + " discouraged 6\n", + " yes 6\n", + " [yes, designated] 3\n", + " Name: hgv, dtype: int64\n", + " \"\"\"\n", + " if val is None:\n", + " return None\n", + " \n", + " # Flatten list values like [yes, designated], turning them into a single string\n", + " if isinstance(val, list):\n", + " val = \" \".join(str(x) for x in val)\n", + " \n", + " # Basic logic: if the string includes 'no', treat it as 'no'; otherwise 'yes'\n", + " val_str = str(val).lower()\n", + " if \"no\" in val_str:\n", + " return \"no\"\n", + " return \"yes\"\n", + "\n", + "def compute_vehicle_allowed(row):\n", + " # Combines the original hgv flag and truck classification.\n", + " orig_hgv = interpret_hgv_str(row['old_hgv'])\n", + " truck_class = row['truck_allowed']\n", + " hgv_allowed = \"no\" if orig_hgv == \"no\" or truck_class in [\"LD\", \"MD\"] else \"yes\"\n", + " mgv_allowed = \"no\" if truck_class in [\"LD\"] else \"yes\"\n", + " return pd.Series({\"hgv\": hgv_allowed, \"mgv\": mgv_allowed})\n", + "\n", + "def compute_vehicle_allowed_from_truck(row):\n", + " # Bases allowed status solely on truck classification.\n", + " truck_class = row['truck_allowed']\n", + " hgv_allowed = \"no\" if truck_class in [\"LD\", \"MD\"] else \"yes\"\n", + " mgv_allowed = \"no\" if truck_class in [\"LD\"] else \"yes\"\n", + " return pd.Series({\"hgv\": hgv_allowed, \"mgv\": mgv_allowed})\n", + "\n", + "def update_freight_script(edges):\n", + " \n", + " print(\"Parsing columns if present...\")\n", + " for col in ['maxweight:hgv', 'maxweight', 'hgv', 'maxlength']:\n", + " if col in edges.columns:\n", + " print(f\" -> Found '{col}'; parsing...\")\n", + " if col in ['maxweight:hgv', 'maxweight']:\n", + " edges[col + '_lbs'] = edges[col].apply(parse_weight_to_lbs)\n", + " edges[col + '_str'] = edges[col + '_lbs'].apply(lambda x: f\"{x:,.0f} lbs\" if pd.notnull(x) else None)\n", + " elif col == 'hgv':\n", + " edges[col + '_bool'] = edges[col].apply(parse_hgv)\n", + " elif col == 'maxlength':\n", + " edges[col + '_ft'] = edges[col].apply(parse_length_to_feet)\n", + " else:\n", + " print(f\" -> '{col}' not found; skipping.\")\n", + "\n", + " print(\"Merging 'maxweight:hgv' over 'maxweight' if both exist...\")\n", + " if 'maxweight:hgv_lbs' not in edges.columns:\n", + " edges['maxweight:hgv_lbs'] = None\n", + " if 'maxweight_lbs' not in edges.columns:\n", + " edges['maxweight_lbs'] = None\n", + "\n", + " # Override: if 'maxweight:hgv_lbs' is not null, use it; otherwise use 'maxweight_lbs'\n", + " edges['maxweight_combined_lbs'] = edges.apply(\n", + " lambda x: x['maxweight:hgv_lbs'] if pd.notnull(x['maxweight:hgv_lbs']) else x['maxweight_lbs'],\n", + " axis=1\n", + " )\n", + " edges['maxweight_combined_str'] = edges['maxweight_combined_lbs'].apply(\n", + " lambda w: f\"{w:,.0f} lbs\" if pd.notnull(w) else None\n", + " )\n", + "\n", + " print(\"Classifying truck access based on weight & length thresholds...\")\n", + " edges['truck_allowed'] = edges.apply(classify_truck_allowed, axis=1)\n", + " \n", + " \n", + " if 'hgv' in edges.columns:\n", + " # Save the original HGV data.\n", + " edges['old_hgv'] = edges['hgv']\n", + " # Compute new hgv/mgv columns combining old_hgv and truck_allowed.\n", + " edges[['hgv', 'mgv']] = edges.apply(compute_vehicle_allowed, axis=1)\n", + " else:\n", + " # If no original hgv column exists, compute new columns solely from truck_allowed.\n", + " edges[['hgv', 'mgv']] = edges.apply(compute_vehicle_allowed_from_truck, axis=1)\n", + " \n", + " \n", + " if 'old_hgv' in edges.columns:\n", + " print('old_hgv', edges['old_hgv'].value_counts()) \n", + " if 'maxweight:hgv' in edges.columns:\n", + " print('maxweight:hgv', edges['maxweight:hgv'].value_counts()) \n", + " if 'maxweight:hgv_lbs' in edges.columns:\n", + " print('maxweight:hgv_lbs', edges['maxweight:hgv_lbs'].value_counts()) \n", + " if 'maxweight_combined_lbs' in edges.columns:\n", + " print('maxweight_combined_lbs', edges['maxweight_combined_lbs'].value_counts()) \n", + " if 'maxweight_combined_str' in edges.columns:\n", + " print('maxweight_combined_str', edges['maxweight_combined_str'].value_counts()) \n", + " if 'truck_allowed' in edges.columns:\n", + " print('truck_allowed', edges['truck_allowed'].value_counts()) \n", + " if 'maxweight' in edges.columns:\n", + " print('maxweight', edges['maxweight'].value_counts()) \n", + " if 'maxweight_lbs' in edges.columns:\n", + " print('maxweight_lbs', edges['maxweight_lbs'].value_counts()) \n", + " if 'maxweight_str' in edges.columns:\n", + " print('maxweight_str', edges['maxweight_str'].value_counts()) \n", + " if 'maxlength' in edges.columns:\n", + " print('maxlength', edges['maxlength'].value_counts()) \n", + " if 'maxlength_ft' in edges.columns:\n", + " print('maxlength_ft', edges['maxlength_ft'].value_counts()) \n", + " if 'hgv' in edges.columns:\n", + " print('hgv', edges['hgv'].value_counts()) \n", + " if 'mgv' in edges.columns:\n", + " print('mgv', edges['mgv'].value_counts()) \n", + " edges = edges.drop(['old_hgv','maxweight:hgv','maxweight:hgv_lbs','maxweight:hgv_str','maxweight_combined_lbs','maxweight_combined_str','truck_allowed','maxweight','maxweight_lbs','maxweight_str','maxlength','maxlength_ft'], axis=1, errors='ignore')\n", + "\n", + " \n", + " print(\"Freight script update complete!\")\n", + " return edges\n" + ] + }, + { + "cell_type": "markdown", + "id": "22b42922", + "metadata": {}, + "source": [ + "# EXECUTE" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "69e92e28", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'county': 'San Francisco', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|residential|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'San Francisco', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'Alameda', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'Contra Costa', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'Marin', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'Napa', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'San Mateo', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'Santa Clara', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'Solano', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "{'county': 'Sonoma', 'state': 'California'}\n", + "{'network_type': 'drive', 'simplify': False, 'retain_all': True, 'truncate_by_edge': True, 'which_result': None, 'custom_filter': '[\"highway\"~\"motorway|primary|residential|trunk|secondary|tertiary|motorway_link|trunk_link|primary_link|secondary_link|tertiary_link|unclassified\"]'}\n", + "Parsing columns if present...\n", + " -> Found 'maxweight:hgv'; parsing...\n", + " -> Found 'maxweight'; parsing...\n", + " -> Found 'hgv'; parsing...\n", + " -> Found 'maxlength'; parsing...\n", + "Merging 'maxweight:hgv' over 'maxweight' if both exist...\n", + "Classifying truck access based on weight & length thresholds...\n", + "old_hgv designated 70826\n", + "no 4103\n", + "destination 792\n", + "yes 584\n", + "delivery 54\n", + "discouraged 8\n", + "Name: old_hgv, dtype: int64\n", + "maxweight:hgv 7 st 2652\n", + "4.5 st 2459\n", + "4 st 270\n", + "3 st 265\n", + "5 st 196\n", + "3 148\n", + "9.5 st 32\n", + "3 t 26\n", + "9 st 18\n", + "5 15\n", + "3.5 st 9\n", + "8 st 8\n", + "6.35 8\n", + "3st 4\n", + "37 st 2\n", + "Name: maxweight:hgv, dtype: int64\n", + "maxweight:hgv_lbs 14000.0000 2652\n", + "9000.0000 2459\n", + "6000.0000 417\n", + "8000.0000 270\n", + "10000.0000 211\n", + "19000.0000 32\n", + "6613.8678 26\n", + "18000.0000 18\n", + "7000.0000 9\n", + "16000.0000 8\n", + "12700.0000 8\n", + "74000.0000 2\n", + "Name: maxweight:hgv_lbs, dtype: int64\n", + "maxweight_combined_lbs 14000.0000 2836\n", + "9000.0000 2555\n", + "6000.0000 2349\n", + "10000.0000 347\n", + "8000.0000 317\n", + "11000.0000 217\n", + "19000.0000 32\n", + "6613.8678 26\n", + "18000.0000 18\n", + "7000.0000 9\n", + "16000.0000 8\n", + "12700.0000 8\n", + "74000.0000 2\n", + "30000.0000 2\n", + "Name: maxweight_combined_lbs, dtype: int64\n", + "maxweight_combined_str 14,000 lbs 2836\n", + "9,000 lbs 2555\n", + "6,000 lbs 2349\n", + "10,000 lbs 347\n", + "8,000 lbs 317\n", + "11,000 lbs 217\n", + "19,000 lbs 32\n", + "6,614 lbs 26\n", + "18,000 lbs 18\n", + "7,000 lbs 9\n", + "16,000 lbs 8\n", + "12,700 lbs 8\n", + "74,000 lbs 2\n", + "30,000 lbs 2\n", + "Name: maxweight_combined_str, dtype: int64\n", + "truck_allowed LD 9540\n", + "HD 5126\n", + "MD 4\n", + "Name: truck_allowed, dtype: int64\n", + "maxweight 3 1557\n", + "3 st 263\n", + "5.5 217\n", + "7 st 132\n", + "6000 lbs 120\n", + "4.5 96\n", + "10000 lbs 87\n", + "7 54\n", + "5 st 46\n", + "8000 lbs 39\n", + "9000 lbs 34\n", + "4 8\n", + "14000 lbs 6\n", + "3st 4\n", + "5 3\n", + "15 st 2\n", + "Name: maxweight, dtype: int64\n", + "maxweight_lbs 6000.0 1944\n", + "11000.0 217\n", + "14000.0 192\n", + "10000.0 136\n", + "9000.0 130\n", + "8000.0 47\n", + "30000.0 2\n", + "Name: maxweight_lbs, dtype: int64\n", + "maxweight_str 6,000 lbs 1944\n", + "11,000 lbs 217\n", + "14,000 lbs 192\n", + "10,000 lbs 136\n", + "9,000 lbs 130\n", + "8,000 lbs 47\n", + "30,000 lbs 2\n", + "Name: maxweight_str, dtype: int64\n", + "maxlength 60' 5126\n", + "35'0\" 526\n", + "35' 276\n", + "30' 16\n", + "Name: maxlength, dtype: int64\n", + "maxlength_ft 60.0 5126\n", + "35.0 802\n", + "30.0 16\n", + "Name: maxlength_ft, dtype: int64\n", + "hgv yes 1285154\n", + "no 12880\n", + "Name: hgv, dtype: int64\n", + "mgv yes 1288494\n", + "no 9540\n", + "Name: mgv, dtype: int64\n", + "Freight script update complete!\n", + "Nodes: 781847, Edges: 1298034\n", + "consolidate intersections\n", + "simplify network\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAHhCAYAAAAyOPfvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd5wdVfn/32fKnVu2ZtN7JyEkhIQaOtKL0kGBr4AiqCgiFvT7U7FgQQW/dhEFFJHeew29h04S0ntPttw29fz+ODN3727u3b272QQ09/N6bTY7c+bMmTNnznnO83ye5xFSSqqooooqqqiiiir6AtpH3YAqqqiiiiqqqOK/B1XBoooqqqiiiiqq6DNUBYsqqqiiiiqqqKLPUBUsqqiiiiqqqKKKPkNVsKiiiiqqqKKKKvoMVcGiiiqqqKKKKqroM3QrWAghbhBCyPDnzU7nrig6d0BfNEgIcW5RnYf0RZ3b0JbRRW0p9zO6qHxX5RrK3OOCTuWGdzr/fSHE00KITFGZs7tpd5/X2el6KYS4oYJyS7voj9ndXHtIUdlzK23bxwFCiDOEEPcIIdYXPcN1JcqdIIT4txBigRAiLYTYJIR4QQhxSomys7voyxNLlD9WCPGkEKJZCJEVQiwKv2URnm8SQvxECPGiEGKtECIftuPPQojBJerrJ4T4oxBitRDCFkLME0J8Uwihdyo3QAjxKyHEh+H42hA+05kV9t1sIcTSbsp0Na6Kfw6p8J5fC+eycysp302bZndTrnh+u6K399ueCOe9K8Kf6Z3ObZfvUnQ91zZ3KnuEEOJWIcSKojJPlKgzFo7FF8MxW9FaJYS4sqisV+L8AUKI+4UQK8PvZqkQ4iYhxKQKn3WqEOIWIcSy8PqVQoh7hRB7dyp3qRDiESHE8qJy9wkh9qjgHsX9eUUl7epLGD0sP10IcayU8qHt0pr/PEgg09uLhRCNwE+7KfZ1oP6jrLOKHuPTwKcqKPdl4Kiiv1PALGCWEOJyKeUvenNzIcQ3gF92Ojw2/Pk84AETgP/tVGZ8+HO8EGJ3KeWmsL4EMBuYWlR2F+AqYCJwQVhOA57sVC4J9A+fqVFK+afePNN2xteAUcAzwA0faUs+HhgN/CD8/1LgrY+qIWVwHHB6BeWSwGU9qVgIMb6ra4QQ+6G+hWKBelT4c5wQYlcp5Zourh8NvIT61iMMC3+OFkLsI6V8Kzz+M8AqU+4TUsrnKnysHY7emEK+2+et+JhCSrlUSimKf1CTpB0WeUJKuaHEpYd2vk5K2Vyi3JVhfdkumnE9cD5wRYXN3h51bjNK9MchO+reHwGeAi4FttI8dEIOJQBMAmqALxWd+64QopTg/8MSfXlPdFIIsTvw8/DPp4HdURPsBNSEGRTVNSdsY114fk54fBhqfET4Gu3CwneAAcDd4d+fDydbwntF5V5FjcODAD88dl7JXughpJSji77HQ4tO3dipX2b3xf2q2OEY0+k9NnQ6/zpwOWpsdQUX+ANwFvDnCu/9f6jFvNz8eSbtQsV3UN/tH8K/G4CTuqn/JNqFij+G118e/h0DPlNUdjXwVWAI0ATcGB43i675WKKngoUP7C+E6PKFCiESQogfCyHmhyqoLaFK54BO5ZJCiGuFEC1CqYGvQXVuqTobhBC/Fkql64Qq1luEEBM6lTtdCPGKEGKzECIXqpHuFUIcWFSmYN7p4fODmhwjKbLSwVrqefYALgQ+oH2S3gpSykullNcDyz6KOncEhBC6EOLn4TttFULcSBmNihBirBDisfDdLhJCnF/ufQohJgllalgbjpllQoirhRC1ne79PSHEXKFU921Cqfn/KYQYWlSuIlU3gJTyt1LK39C+UJfDOVLKb0kp50spM+Fu/r3wXB1qAe8pvoya+NLAqVLKd6SUOSnlQinl1VLKSLB4B9hLSnmXlLJNSrmQjpqu8UX/jya7NuCXUsqNtAsvoDQ00C5AADwupdwU7qrWhscSvXieXkMIMVIIcb0QYlX4/leHY2VUeH50OGZGhZcc3Fl9LIT4djifbBBCuOFc9rgQ4tAyt+2rtmtCiIuFEG8KZcpKC2UmOrxTuchEtlQoM8Vr4bfxrhDiyE5lu/12wud+uuiy64v6ZHSnZsbC73adEGKjEOLvQojCTlxsJ7OJlPImKeUvutuxh9/UxVLKm4F13dUrhPgkcCzwGPBamWLFY/wOKWUGuKfoWHdjvPj6u8Pr7yxz/TQp5e+klGullJvpqEkp/j4rghBioFAmSimUmXay6Ggy+bEQ4hfh2rleCHF5eN1XhTLDbPWOy0JK2eUPSjUow59/h78fCc9dUXTugPCYCTxXdLz4xwOOL6r7HyXKrCn6/yFhuVrUhFuqzs3AhLDcfqgdWaly3yj1TN09f6e+EMCH4bWrAKPT+eheG1DS8gbgdmByiXpeiJ6xUx8PL3Pvc4vKnF2mbX1aZxf9IIEbKii3tJJ+Bn7UzTg4NywXAxaWKLu6831Qu+e2MmPhdcAKy327TBkJ7FniWWb3oJ9GF9V1XYXXLAjL54BY0fHZtI93O3y2Z4BjO10/Pyz3Aep73RiWvR/YpZt7n1XU3u+HxyzUZCiBt4rKNhSVfa5oDL4UHnsFtcs6qOj6X1fw/LOBpT3o40OK2nFD0fFRqMWk1HtdF54fXea8BK4I63m5zHkH2L2n44OO39wVXZQrNTdK1Px2eolxkQ3HRXHZNNDUk2+HjnN655/Rnfq7VP/+vMy7ObcH38p61Py5GqVdHdbNXCRR2uOu6i9+rgNKnI8Di8M+nFjUr16ncnugvk2J0hokURqL6N3s3k07hgGbwvJ/QGkvLi9q2wndXBuVe6oH/XkFag19I/x7E0po6VxuE1u/z3u7esdl71/Bh3tDUYV7Avnw/zNKvSw6fjg3AY2oySWa5JegJqCJtE84c4DhwBRgRdH1h4R1fi/820bZpC1gN9oH9i1hucvCv1tR9mQLGAd8Djiq1DNVOoGF132iqG0/7GKQd/5poWhSL+qjm0v0cW8Fiz6vs5uP+YYKyi3tok++FpZpKBoby1BmgZHA20Vlzw3Lfr7o2PXhtSdTJEwW3fvJ8NiHwK7hWDi56PqLwnL3h3+/ENZXA0xDCRxjSzxLlwtHFx93t4IFHRf2v3Y6N7uLvvxMUblsF+XWA0PK3DuB0mJE39nY8PiQouufLSqvFR2fX3S8DrXjLb6vB1wLxCvog9n0jWBxQ9Hxi8N2XVymbNl3i7LnT0JNzCYwE8WrksBvezo+qECwAA4sKvPdcEwOLurXVYBWYlz8ETXfFgvqZ/fi2ynu03O76O+NwF6ocR5tBBZWUk8330rnn5XAgC7mIsm2CxbR+Z926levRNkDgS2d2rgaOKPCMbsrHdc5Gdb31W6u+2tR+bN60J8/Q5lnJdAMzCxTrjV8n9PouEE/HxhI+xhf2O0zVtAJNxTdYDjwp/D/d5R6WbRrNSQwqqie64uOTwT+p+jvc4rK/bDo+CHhsRe7GHQSWBeWOzX8OwjbfTFwMBVMaBUOiNujwUaJxRr4CUrgSqF2RPcUtfGGsEw9SjXcCgwt1ccVTEhndzrX53V20w8dJuYuyi2l/Dv7WljmoKJj3yu69ryi4+eGx/5edGxEUdmChiz8Oxm+o67GzK1h2d/T/mFfHd53D0D0wXgZXXS/LgUL4Ajad0LvAfWdzn8ZJdj2Qy0e3y+qe2lRObfo+P+iFqX/LTp2ZYl7W8CDRWU+X3RuaNHxYsFCLzo+Lzym0S6odf55FhhfQZ/Npm8Ei2ihW9yp/JLw+OoS43R2ifpnAY+iFlGfjs/0SCV1dPHNXVGmzE+7GbuSUAtK+wLoArXhsclF5b7Tk2+nRJ+e20V//6Lo+K3hMbuX38oA1M59CkrInUy7BrarvorO91qwAMagvr3lQLJTv3bWWBRvaIt/MsCv6KTFLtGOobRrvYt/HNQamSpz3f8rKvvPCvpzdKe2SdT6sG8X5f5RdHxteGx50bGbK33HvSFvXoWatE9CSfKd0b/o/yvL/H8AaicUYVXR/1eXqLM7W3O/8PddqA/IBz4L/A41QNYIIY7rpo4uIYQYRDvT/0Ep5crOZaSU/09KOUcq294y4ItFp/cKf18ADEIJYAOFcufqV1RuVyHEyB42b3vU2aeQWxMOfxOe6sk4KFe287topCNruxSi/vkx8DxqB3cpavzMAeaVsClvF4S28PtQ6th5wBFSypbiMlLKP0gpn5RSbpZSbpFS/gg1QQGMEkJE38imost+J6VMo76DCLt3ureF+m6ODQ99XUpZ7Bq7iXbCZ13R8dqi/0cE5k8Cx4f/j3gyk1Hv6kC64P1sB0TzUOexEf3dLX8lfP+PAEeizDqd58v4NrSvK1TCrenX6e91Usq28P/5ouMRH6zSb6cnWFD0/+ieJTly3UFKuUFK+XMp5ftScYLmAt8oKrJXuWv7AJeh3uXfgInh/FkTnRRCTBftLtg/Qe3eA9R4TwIX0e6Bckk39/oWiigNan1IAieg5qtz6chdiu7/PdQ8BWpDf37nMt0gGf5ejZpfymF50f/zJY454e9u33GPBQsp5RLglvDaU0sU2Vj0/2FF/x/eqcyaMuWGsjWiOjcBeudFivBBpZSBlPJzqEnlEOALqI5sAH7T5YN1j8+hVKGgtDYdIJSrXWfIov9Hk3M0YL8AvBn+nFBU7lGUKrMn2B517ij0ZBwUCxvFE+WITuW20N7f95QQagRqsUBKuU5KeSBqfB6D+vDTKK1aZ3fMPkcoVNyLmtjeBQ6WndzVyowtKD2+3uzmlrmiei3UYn9sWNeXpZTXdLiBlDaKrwEwVrTHrZhYVCy6Z/FG42YpZauUch5KWwGwW5EAtL0RzRnDOx0f1uk8dOzHYhxFuwD1ZZTmU9BReNseKG7b9BJjV5NSvtDpmuJ4C6Wep9Jvp9z1pdDdPStGD+bP7YFo/ryC9vlzZnhMD/++KPw7GuPrpJT3SylzKE1DhMO6uVfxN/L3UIh6gHZyaYfrhRDfp33uvhk4U0rpdvtEHfEiqv92Ae4WQpQTDLaK2VHmWLfobeTNn6Feeqld4WNF//+JUN4cB9DuercMtdN6ifbBcqkQYpgQYldKS2OPhL+bgKuFEP2F8jzZRwjxd0LXGyHEoUKIr6MmjzdQpotoV1eY0DozobtDOOgvCP9c0ukZI3xRCPEXIcTeQoh4yDwvFkBerOReJe7dKIToT5EEDdSEfVD/calzG/AOaiEH5bo4SQgxAuXi2BnFffg9IUS9EOJklLq6AClllvbF7AQhxDlCiFQ4Fo8XQjxO6KomhPiCEOIslHD6NEqluzm8tnjMVOwVIoSoCfu3seiwFfZv/6JyR9EuVMxBuSmvL1HltJDNf6wQojZ8f99HTRQAC2QYcwIl9Ef4ihCiBvhK0bFnwntbKFPdMajv8PNSyj+WeaSbw9+1wDfDZ7i8xPligegzQog6oYIGRV5kHtsQ96WHiL7RMUKIL4X99iWU2rv4PChBFGBkp/FfPAGnAUMI8S3UPNQXGC+EOLrTzzDa5zuA3wghxgsV7GkXobw2bu/FvSr6dkJsKfr/rqJTELRK0UOvkB8LIa4SKnhULBw3vy7VfqG8CTt8S4AZHSsWUorKJYvK1ofHi+e/ShGN8UHhXJKgoxt1c9G9Cx47Ja4HOD9cx45HaZw7X/8DFDUAlPByjpSy2KukUjyOil0EasN9oxAqUN52QwW2mhsoYatH7XSKbUTFXiHlOBEe8KmiOkoxnzcW/f+QsFw9MLdMnQX7Gx3tl51/bin1TN09f1j+mKJ6Li9T5mtd3HsNRXbNSvs4PLe0i3rL2nO3R51F10u2nWOxtKhcKa+Q4nFwbtHYKsVsj+yBsqjOGajFoNz9DynRT51/LirxLJX0T1d1Frdxdlflito4vYsyLnBMUZ0aW5Mno5+3gURY7pBu7j27qM5iYmfnn78WlatFbRzK1fnXCvpuNn3DsRiNMtGUascGYHRR2b+UKHM4SnBzOh3fRDtxr7iPKhofdD1HFY/1m7soM7tTf3X+nkYXlY3mxp58O0mUcF1cbmWJ/j63qzm1XNky/fKbLp53LlBXVPaKbvqw+N12Va7sHEZ5jsWnKO956KE0jl29m73Y2nun+OfsCtsuu+nPUmPg90XHflWuXLnxXOodl/vZllwhJaM7SqWmOTw8vxA18bWgdgiHSSnvLSr+ReA6lFfAFhSr+Xsl6mxBuZL+GliE+tg3o7QSV6IEFFC+x/9A2f7SKLXvQhSp5gJ6jwvD3w7KBl8K96OCHb0Vts1F2af+gmLhrtiG+/+344co7s4m1Hv7N+19XkA4to4EnkB9nEvDcq+GRbYUlZ2D+oj/jVIzuigB72mUEBjFmLgTxW9YgbIrtqBUnxdLKXsdp6SPsQjlpfIsaiHwUILXvcD+UsqHo4JSxak4HjUWV6CeeyVqUjlYKtVtjxBecyhKA7cW9R18iDIbXVRUrg3YH2WrXhG2M4cSSr5DxwBg2xVSyqWo9/8P2vtsLfBPVPyOpUXFf4AaA82d6pgPnIEyp+ZR88tRqDGyvXE2KjjSm+G902E7rqUXJroefjtZ4Bzgfdrt6tsbN6DcL99H9a9D+9y9n5SydQe1o0uE69cJKC+LZhSfbzPK3HyElPKZbq5/DSVwPUA7IbgV9W2fJqW8aXu1HcX/iOaKy4QQX91eNxKhJFJFFRUjNCHdKKU89yO494HAO6GwiVDB2h5FmRPullKevKPbVEXfITQ1jZZSjv6Im/Jfh+q3U8WOQk9zhVRRxUeNHwCHCiHWoWzgkb27mR1Atqyiiv9gVL+dKnYIqmnTq/hPw30o74kalPvjcpR5aoZULmpVVFFFaVS/nSp2CKqmkCp6jI/SFFLFfzeqppAqqvjPR1WwqKKKKqqooooq+gxVU0gVVVRRRRVVVNFnqAoWVVRRRRVVVFFFn6EqWFRRRRVVVFFFFX2GqmBRRRVVVFFFFVX0GaqCRRVVVFFFFVVU0WeoChZVVFFFFVVUUUWfoSpYVFFFFVVUUUUVfYaqYFFFFVVUUUUVVfQZqoJFFVVUUUUVVVTRZ6gKFlVUUUUVVVRRRZ+hKlhUUUUVVVRRRRV9hqpgUUUVVVRRRRVV9BmqgkUVVVRRRRVVVNFnqAoWVVRRRRVVVFFFn6EqWFRRRRVVVFFFFX0G46NuwEcF17VlJeVaMzk836e+Jomu/efKYVJKpJT4vo8QAoRASokQAoFA04Q63gf3yeZtdE0jbsX6oOWl74GU+I6Lpuv4rouRiPdZ+/0gQNe0DvVF/Rf4Abqh98m9IgSBxPc9DEN9jn1ZdyWQUiI9Hy+fx6xJ7ZD7SylxPY+2bJ5UIk7MNNB28HP3BNH7d10Pz/NIpZIVX6Nt47wRBJLm1jbqalIYht7reqLvX9d7N36llGTyNp4fkIrHMHQ9rDPA6PRNeJ6H63okEvGK6/ZyeTRdR9+GeSMIAmzbIRaLoeta4diHS1fTUJsCYFNzK23pHEJAXU2SvO3SUF9DS2saCepZELS0pYnFYowaOoCBTQ0d2tqSzmLFTOIxkyAICAIJSKQEXdfRNNUXsVj84zuotyN2WsGiUtQk4rTl8tiuS9KyPurm9BrRRx8tXhGiyc/zAoQmEEXlhRBqAQ8X8komJCEEmqYRyIrktl4hEoyMuEXg+wSe1yf1qsXOZ8OWZvrV1ZKIt7/v6LmFrm3T5Nz5fqpuVX9fLEK9gRACdA3NNJB+ALq23YULIQSmYVCTiJPO5pEJi3jM3LpdHyMIITBNA8d1CYKg/RvZjnBdj2zextD1wkL5USAIJG25HJrQqEsmCmMWQC/xTfSmXzTDQGjb1p9CCGIxE8dxijZLAikD1m1sJpGIEQSSVDJOMhGntS1TeD4/CNA0DRlINF2jJpmgsb4G23HxfB9on9NSCQshlAAlNK2DwOd5PkLTP9aC8vZGVbDoDgKkDNC1//yuKvWxty9o7UIGKCk/Eg50TQMh8Dx/q51JKXi+D1LukMlXCIHQNAJPCRh6zERo27Yw1qdSmGbp9y2AvpKZJBD4Pmri+4gXUiHQDAMnncaqr9tBtxTETIOYaeD5AemcXRBsE1YMXf/4TMwd3o2U5PN54ok47aJ42Su36b7pbJ6YaZBMWH0iyPa2Dj8IkBJqkkrY7ixACCFKavp6dA/XRTMMtmWqjTY28bhVpEmAkUMGksnlMXQdQ1eCgKZpDBvUj0w2jxUzGdhUh+f5JOKWmvskBWFOCwWU9huFv3W2muN0XcP3fMQ2aJf+0/Gfv1r2EuU+smhxVeNKkrUdbMcjEds+av2PA0rtMqSUaJGpJBQ+IMDz/cLkUW4CiRkG2bxNLm+TrFAVuk3t1zSi3YSbzhCrq+1dPUULXTkEgaSvdDGRkKJp9IkGZJvaIgToOrplEbgu+g4a70IIEvEYLW1ZYjETXdfI5G1iMQP9Y0oBi8ctctk80pLQ7doh2RbhwjC0bZVNVCtCQV/bhoU/uqzz9dFi7nk+UvT+69BjsW3WWETtAfVN6eH7MU2DVDKO7wfk83kMTcOMNGRSYlmxivpFFu0qypVXcyP4vr9tD/IfjI/nl7sDkMnbBEHQ4ZiUEtf32dyWYUNzK23ZPJrQ6N9Q2+Vi89+IaLIoFjo0TUPXNPxACRhBIDt8aBGsmEl9baqDBmS7tVPTMJMJdNPEiFtopoHTlsZ3XJxMtk/vH/UBgO8HJevuyTOriV5s02TflxBCoBk6ge/jO84Ou6+uadTXJElaZrij1DG0j+duTwiBYRhYcYt8iTmkM5QVsfdjMBm3sF2PTDaH38W9lDnTw/W8sveTULRJqBxSSmzHJWaUnwOFEGqn3k1/dAXfcQi87bsY67rSZtiOSz6fx/P8HvPLIm1uuX5UfaF/JGbNjwt22idvy+QKajL1Ufq4nk9bJkfM0KmvSVKfSpKKx7ZJvfffhGhhNXRlPwyC8pOAAPxAEbt2ZPuMREIROXWlxZBBoH4KmqhtFTRkgZhVSjCttP6+2EFuD+imiaYbeHl7uwuFEaJFKSJ0GroWmiB3zP17isiOr2katu10+d63Vb+l6zq1yTiu69PSlsVx3K3uJ6WkLZOjuSVNS2umpLAjpey14sMPArwgIGYaXY7ViAjenbBVDnoshrYDzAe6rmNZMXJZG8/z0PWe3bMSgaF4E7IzYqd9csPQEZrA930c12NLOktLJocmBLXJBAkr1meeEv9tKNZmeL5fdmK1Yiau6+7QBUIIgW4qnoXyHHFwM1m8XB4vlwd6JgCUggyFi1J1VDpetsXevT0hpSTwPJx0ZisyiRKGZJe74m2CEHh+QC7v0NKW7TMuy/aAEALLiuEHAfm8XbaMJrQud7eVwDQMUgkLx3FpbsuyuSWNbTu4rkfOdmhuTZPL5amrSRKLmbRl8nid3lFEDO4p50lKST7UVnRHRowExCAIQu1Iz57Tt7e/xiKCaRrU1KZwHBeofE6I+q+62ewaO5d+vwiWadKSziKEspvrmqC+RrmQVQdM9yhI5KEKtrO3ScT6b8vbWFbQ411BX8BMKfcypCRwPaQM8LI5EILAdXtNUhSiffL0gwAtnGx6pE71A7Qd4H3RY0jlNmck4h12ub4fYDsOmZxN3DKpSSb69LbRIhw3DSzTIJN3Qpb+x9MkAqrNcStGujWNYegYxtY7eiGgL0g5ZsxkYFM9fiBxHJeWTB5DU14qybhFXU1SaRNjJvm8TVsmhwDqalMF84cQPd9Hur6P5wXUpirjIID6PlzH7bFgoVt9w7GoBJGHTy6nNI+K61T+G2734PqYfa8fU+y0Gotk3EJKSMXjNNamCnEq/pNjVexoqMVAuaRGbp/qd+gCGgToSDKZLK7jqnNFGo7t+dOpoUgZKJZ3LIYeM9Hj3ZNKS6mci8msgZS4vkcgS/MtuoKmawWexsdJ5e9mssz9183onoubzhTel9AEEtB0QaqPYoZ0hhBKk6hrgpipY+9gbVdPEdnSkzUp8nk79JyQW5URQmyz1iIS5E1Dx4qZWLpGfV2K2lQiJL3qhe8xEbeor61BSrDDHbmqo2f3lFKSt13illmx62SktQB6bAb1HQe5gwmPBUJqhdrpzvPBx+37/bhgp11FdU3Qry6FGbodVQWK3kEIgduW4Y7Lvklu02Z8x8F3HLy8TeA4xITANE3u+tblbHptDn7exk1n8HJ51r/8Cr/65EnY4XV2S2vhd+C6OK1t+I7D/DvvxcvbeLk8bjanzBvpDAsfeQJn3XpVdkszq+5/EKctTeCqRdF3HLxcDj9vA0IJNkGA3dKGm073aEKIykbcCD8ICGQQHutdv+m6hud5ZUmwHwXMmhS7nn46qx55gsyHC/Btm8B1EShhPB7beufaVxNstAhrmoapaTiuX3Kx/jgh2vnGrBjZMmThAvegjxYhXdeor68p652l+lAQs0xa09lCULyeCoNBONZjvQgIp/dCG6fHTMQO1mxKCY7j9jjmRDTe/S54ZjszdtrVNPrQqqqtbUcslSTZ0MgvTjyJ0w47nJ995iwuPuJI/nLppVh1tVhWjP3OPpsFzz7LQ9/6NkG6DSMRZ+C++7Dr8OFY9XXosVj777o6NNPErEmh+z43//53GLEYuhXDiFvKAySRYMyMadz07cvR1m/ArKtFNm/BTCbQDAMjEUczjJAQZqAZenitgdVQh25ZyG5IZqXGRyAlsowg0JMFtkCENYxQFfvxEC6EEGg1KUacehIyk2bNAw+z8K578PKKn5IIoyJKWUSM9XyctjREz78NwkCxcBEzdZrbsts12FpfQLkpm0gJ+TKkVyEi92LZ4X33RiirdO6y8za1qd6bd30/6FVMmM4eZZUicF0VoG0HQtMEsSLX6nLvolSfq7/LL6Efh+/5o4LYWR++0pDeOzt81y144gshlL1YU+YPoWnIIMBuTRNvrCcIAm7+8ld44+23uebZ2QhT+YlLKclnMtzxg58wZeJ49vjC5wof6MrZzzJ8zxlQU9Pxxp7Hfd/6Dum1a5h13vmMPuKwku3LrFjBm7fcTsuWjSRacxz2+2u6fJ7WxUuoHTNacS00gRGPQy4PugYlduPFiL4VPwjwPC/qFPUrYiMIMHSjvb8qgJQdQ61rH7HAK6XEy+cRQkOXAasfeJhBnzyOwPWUoGYa+LbSSukxExkE6FaMwHHRYqYKzRwz0Q0jDFoWC2ONVA7fDwiCgEzewTINEvGPfxyZtrY0fhAQt6yScREKWi/aQ1MUH4t2zX3x7qWUbG5uI5WMo4eRIXtK2szmHYQQJHvR934Q4DoO8QpMjtH9fNtBM3S0LtxaS10Xoaf9JqUk3ZYhnogXPL1KCRClzFuV1C2lxLISO+XOtSpYVFEWvuvi5fLosViBXyB9FVEuWkR8x8WwVPwIUESoBX/7O2s3bOTg715e+AillORWrOSJG/7BAQcfQL+DDwbA27iReY8+wbolS9i4eTNTx4xm1fq1rPhwIaf86Arqd9mlssZms2RWriI1cUJFxWUQ4LSladmwgZWvvsqcJ5/ic9dd2+2kEe04HdcDrfQkE8Vg0HrgchZ5XETf47bkhOgLyEDiZrMYcQt740Y2PfMcDTP2IDF6FF4+j6YbShNUFN8lWhgAfFeFOg6iPC493MFGLuBeEOC6PrWp8ryOcjyYHY1MJoth6GFsBI1YrDLPMimVU2oxQbAngmkp+H7A5tY0jXUpZCDLRpLtqk2tmTzJuInZg4W+/f4+juP2LFdI3lZaxh60VfGUgl4FmJNS0taaJpFMKG8WGSCE1sEsEvGpir24KrmP7/tkMzn6NTVVBYudCVXBontEZEyjTI6UcrsFKSUb35jD3Gef48BLLymcc12PZ/7yV9647Q6++IffsX7JYh7563UceMwx7P6Fz4Fh8PZNtxAXAYnGJkYee1SX7Xv/+n/Qb+wYhhx8YEXPIzMZWlaspGHSLqrtxap73ydobcUcMKCihcBxXRWjoIuyulAxP3q6oBbnXdiWHdm2IHI7DVwPzTTQTZPF113PmM+ejRQCUeFzBa6H5ziYyUTPVeNhILZs3im4XJZqJxCaS9qT6n0UgkU2m8M0DXRdx3FdvDAJV6UeUcU8ns4CUm/4EVua26hJxhVnpYeChR8EtGZy1Ncke5XzIggCnB5qLLx8PhQszO4viNoZ8qZKeeRUcs/W1jTJZBzDMEJCdhhbhvZ+76lgEQSSTDqDpms0NDTulILFTutuWkX3iOznlMm9Vu4DE0LQf+YMZgwcyIYHHiI2oD/1e+0JuSyT996Lh/91E6/ffge5pUsh77Epm4NwV7T72Wd226451/6N9ctXMPOA/dF1ned+8zuE0Djgki9vVXbZbXcyeI/d8XI5Nr79Hsvee5+DfvGTgtlBAOg6XiCZ+/QzjNlzJnrMJDViRJdtiPKnBDIoywHwZYAWhKS98JgmuveBF0IUhAuJeg87OthOFA+EoJ0zYUyZxPUXfYkzvns5qXHjKqtH19B6SciLdu6mrpO3HZLx8qYqEf27bRG0twlR2zRNw4rFEAjyeZtEIl5xUKXi/ytyoPJmijQflS6emhDU1iRJ5/LUJqwOC2N3UIKzh2no29iVPeRmaHqPTWZ9g04B70qMoUr7XkqVR8YwDeLx/9yklduKqsaiirLwXZfA8zATvYtZEI0tZ90GnDlvkg98Nrz+Os/Mncexl3+Hf37pIs750U/ItrUyfPw4aqZO2WqXHiH6qN+++d8M32UiTTNndji/5f33mf/kbFo3b2HmkUfQNGsfdSKfJ/3223jJFA1TdlWJObpoa+C6PHzlz5hxwicZuuceZZ/N9/yCi1oQSLzAKxmuQIt2PCgTiUDtJnVNK7vYKK1FRGJTtXYOr76jEPg+dksrVn0dmq4TtLbyf586lRMuOJ8FS5dRo+sc+M2vl+1XADeXU3yNCvMxQMfdezqbxw8k9bWld8+dd5Tw0cQbsG2VUdMs5hbZNkiVX6Q3bVLPhvJA6hRroRLN2sYtLdSlkhimUbHnm5SSlkyOVNzC7KVJLtJYWFZlzy2lxM1kC+7gPbkPVL7wd76n0lgkMAy9QKrVNL3dDbWH2sYoWFr0vk3T2ik1FlXBooqyUK6jLrGaVJfluhIEovMyl+OaTxzFp752Cdl0FqelGVatZM6WzXzm5z/nnp9cydRdd6Vh5AjmPP8SzW0tpCyLkVN2pU5oTD7rTDAM5v7zX9SOn8CISHDoDM/jw5tuJuc67H7B57tst9PaSsvipQyYPq1DW33HYdmTTzPmqCPK7rYVB8BTQa7CMMaBlASdxAtTNwpml0glrlzUBEYXO3kpVSAkpVhp3wnv6BDgUkr8vB0GL1IL0/NX/ZoDvn4JGAbuunXMu/0upp57ztYE3OJnaUsTq0lVvCMNwj4TQmXVbcvmMQwV3rocKfKj9vDK5210XSsIFhCSILM5dENXWoxetrGcmaQ7svHmljZqU4lCKP5K79WazRGPxbB6mSNJRQZ1SaWSPRQszB4lwNtW8mZLSxupVLIkp6kn9QVBQC6XRwCJMHhcVbDYCfHfKFj09buUvo/0A7SYWfYja3v3Pd5/5DEG7TGDgfvvSxAEJCwLXdfIb9hAfMAAAH4+6wDuA44GZu6xB7tOmMQr99zF647NVS88h+v5zLv7PtZ9+CF7f/pM5MCBJK0YgZQsmv0cK194npGTJrLgg3mc8KMfFILwlMMj3/8Bu87an5FHH1m+kOfx2h+vReoa9bU1rFy3jvpkkuYNm3j20Yc56eKvMP3Tp5ddDCP7biQweEWxLSKYuqFIYUWCRLTL6k497nk+nufh+b6y3WvaR5IF1WlLo1tWYScZNDfzxt9vZK+vX6L+3ryZR//v9xzzw++XvD5i/Ecp7StB57HseR4Z2yUeM4l32tF2J9juKGQyKkOr2YkjEAQBmWyOZA/4Fl1BcQFCTVYX2otIsKhLJRFa14Js5+tczydnO9Sles6NAbBtG9f1SVV4vZSSwHERht6l6axSD41KBA6lsWgjmUz2mIPSuR7bdnAcl1Qq0eEdVwWLnQwfF8FCkeR8tDDGvqZpKvpc6Mqp/KTDpkZeGbpemKh9x8HevJlYPIFeV4fv2OhmjMBTrHyJhEAiDKOQDtuzbQzLKvz2bbUj9W2H/Jq1JIYNVfwB30fTdcXqL/Nx5jduZm3O5v3b72LgpF1IjJ/AwKZ6HNfDXrWahnFjMHSNl//4F+69504EUAucfcKJNE6cwJxnn2X/73ybrNAxTYNNW1qpXb0KfdIu1GzaQGLwQERdHbbjseCRx+i/62SGThhXcA/rCnP/dQvPPfEEdYbBjJNOYmIXZNDnf3k1+x53NMbo0ZBMMv+W29ATSUYdeTiGFVN8jE59EAQS13UwDANN0/AD5cUAoIXs8ogQpmt6xRN7BN/3Vd6MTJb6miSJeAxN7HiNhZfPY1hWB6Hg8Z/8lGRDA/tf/CUAnrnq1zQMG8buZ23NkVGCha28E3oRClxKSeAHZGwHQ9e3cn8sxIII//6o3HXb2tLE4/GSi5TtOPieTzwer2jsVoJIwCgnXBQ0Fsk4um50K4wXI5CS1nSW2tBjoqfoFXkzl0c3DbQuyJsR7yRyzy31rovHQ1djQUpJW5syhUTCQG+0Ho7j4haIuh37amcVLHbaAFkfB4EqmnDdTIbA8/FyeQLPx83nkb4fJuXx8B0X31F8h8DzOgRoEppGLJBsmTMHoWvoloUw9DDegIluqsBSmqGjW1YhUFTxbz1uoekGetzCXbwY3VJ2TjOZ6JLNL6XEampkc0uaA845k2f/fh1SSlau3UhrOssGPcbi5WtYuGwN6/Iu9cBkBAGwwA/ITN2dutPP4pW77mPR8jWsXreJltVr+eC+B5l38+20Nbdi1NUVFpNdjz8GvamJvOMUMtN2hclnnckXrr+O067+Jc/ffTf3XPoNtrz/QcmyB3zz6xi77gpJFVBolzNPZ9WcOWitrax6/wNFYuzk1gjKvOGHiZN0TcfUjdAbRAs1DJo61ktSmmnoNNXXhEmgtv/nGgm6biYbjj1HBS3qNAaO+H/f5dn77i/8ffC3LiNobQHP26pOIYSKZaFrBL0I2VwwBQkBZRJviHCRiRbZaHHZUVC2ea3sIhwzldYvn89XNHYrQfTMUUTPcpE9bdcjCAJczwtTvVcQwA1CYXlbAlb1kLwZEqq7gkSRooPAL/ms0XsPouBtRcfKjYmCsNLDMRNxKmzbIZGw+kxg/G/ATitYfFyi+QWeT6y2Bj1mYhV+16LHYsRqUhhxq7DAG5aFmUyimwaxVFJFmIzHWffyK9RNnoSm62Haax3NNMJgMyrgjDpnIDStkP2z+Peihx4mu2YtdktLGKnSqIjN7wU+A/s3smDdZvr374/zztvoixbQ8tLL1KQSNNTVYOgakw8+kDXA60jWANPPO5e8BEsIbrvpBp746Y8xdJ2GIQORdbUkUwkap+5aCPErhMA0dBprU+Qdj7ZsruI+1mtrOf+vf2bmSSdzx/eu4Bf77c+LV/6C1/58LRvefrfsdTPOPYe7f/Zzhu46GSeT6fjepMT1VbwCURRcRxNK5Ry5PGqi97wIZUMndFndOk379kDgebjZLEJXGrPA9UoKl8///s9Q25FTMfqgg1hw2+2lKxYCgigZXO++PdPQsV1vq+yqnfkGQRDskL4qRnc8DyFEgdBn232Xkj4ac0IIKCFcxGMmfiBpy2RJZ20yeYe841R0f32bBYseooJPRAAx3SBmmGWF9aD4XSiqjiLABgFB0DFeDITnw3Pq7+77RkqJ63rYtoNlxSpr/E6EndbdtC2dobYm9ZFHORS6RjQot7z1Do1FRMJK4XgBiSFDtqkdI2fOYNkdd9N/9Ei16ywTFMfftIllr7zO2NCsEASSgf3r6Vdfy8hzzmb9ylWsfn8eQUsrbzz2ILvvuSfPPPYYR8zcEwNIApOAfg21DGpqwG7dyGjAEgHDamLUDRrE+O9chteWZtOjjxH0b0IOHkLtLhPU5GzFsF2vx2YFgBEHzeJzE8fy2wu/yKz//Xbh+JM/+xWf+M43tir/zr33k9m8BREEBUJZlCckDGkEbO0m2FcQIgqwpQQMtROTCNGzYD2VoiBIpJJouq524SXU0s0LFlCXSvCdOzsKEY1TJqPrgrev+zu4Lrt/8cIOz6LHLbxcrmCS6ykMXWmCWjM5Gmtrym5ui4Oy7ahvuxJhRgiVaj2Xy+M4LrEuuEs9QYfxR9GuXUoMQyduWWFfCTzfoy2dw9T1LqNxRoJ81raxTHOH7MalHyD1rhf1cmaP4nPql1YQxl1XJWJTnjWig8eH5/kF7xUpAwIpuo3bEcWacRynKAFcz5/3vxk7Lcdi3uIlsqE2RUNtzQ5n2keQUuJmcxhxi/zmzRiOS2bpUhr3nwWeR+uLL1M3a9+yi3wEL51m1cOPMeq0k7epLUEuy4pb7uD1l17mlGv/2GGCBnj1/35PoqGBqed8BjSNQEpsV4X9tQyzS5b6a9f+lauvv4GlwD7AFY8/jhmaON69/h9MO/+zZdu29s67qZ22G6kJKqpmc1uWmGmQsHo+Mb/59xuoS9Uw7oxTC8c2vf0Ob9x2B9OPOZqBB8wqHL/9K5eyy757M3TYMCTQ/+ADC2pTFUSnPd6A5/noutan6eEjla7n+cRiJp7vq+0Vfe8hokwgKiBWV5ya27/8VczaWk78+ZVd1uetWEnL/A9pOrw9FLuUEun5BIGvTCM9Yd37SpiTQEs6S13oIlhqoYl27d3FC+lLuK6H53ndupVGi1IulyeeiPc4gFolKLhOh55KxfeIPCGseCwUOLpuayZnI4ToMoZIKSiOhVtxLAcppUp2p3dN3ix1n8gMFbl+gwpg53t+6JlhoulawctISonnepgxE9/3yeftMFKq2YEcXc77yPN88vk8iUQc31fk7cgE1vmaKsdiJ4PvB+TyDrbj7nB7bClseO5Fmt//gPyWZpoffZJVDz9K7ZTJbHjgQVbccmvJa9qWL2fJv25hyT/+ReA6ND/w0Da1QSQS9D/kIOoTFm1vv4u/ZQvZhx/h2Z9exVPfu4KJxx7J5HM+jScljufh+h6eF+D7AV6Y5a9cP46cvgf9gBRwwPBRrLrqKpxcjmzeRutkN1//1lsd/h583DHYy1YV/k4lLLK2g90Ltfoe55/L2kVLYP36wrGm3adx5JU/IteW5s7LvsUzV/6Mta++wWm/u4Zlc97k6dtuI5vLhmRaZeqIwnVHwpRpGoVda1+OJSllIaRyezbL7bBgBhI3nSkbZRWgZdEiph96SLdCBYAxYjh6Yz/eu+GfbHr5VSA0Wegaft7uNgFcZwhNFISFZNwik7fLsC3ag5DtWMiKSI5CqFTriUQcO2/jeaW5AtuCaExK2Eq4EkIFPquU5qFrGq2ZLDnb2e5ZeH2752nTIzOH+r8MNXsgA4kVt7AsSwnhRd+rpmnooVBqGAapMFFbNpvD87ytzD/F64Pn+WSzOSwrVtBUCNG7OBr/zdhpNRbvL1gkhRDEDINUMk59TaqsarDgO97hqOjwqzM67/bLwcvlaZk3n/7Tp7H6rntoOvRgrKam9gKOQ+vrc5TmohxWraFt7Rrm33wrww47hCHHHdPlPctBSsmcP/6ZCSccR371OjYvXMDmlauY9uWLCMIokGb4Mfm+WmRtx8XQdayYGX68okAyjPrg/v93BfPeeI3W5mZeAD4BBMD/vvAcK557ETOdZsC0KZgjRvD0//2OB2+5hQu/8U0G7j6V+vEqwuPKW29n8GGHsPnFl/ENnQFHH8WW1gx1qQRWDwLqAPiZDA/+5Kcce8lXMAYPLlnmvm98i/5DhzHr65cw7/p/cNe1f+GSv/8NY+gwrPrakn2ndqNBqE3Y9okmipVRHK54W/z2u71XLg9SYvQi/HZXWHzr7chUinHHHxt6ePhIz1NE4wrvE+30o8WhJZ0lGQZw+jhM6LlcHl3XOmTK7A5eSKaMInP29XN4nlfQbHU47nq0pDM01Nd2KYD5ns/G5lYScQvH9ZBBQDxukUxY3ZqQe+MVEoTt7Unq9EgrEz1HEBI2lZkiFmoVtQ7mj2gs6aG5DwSO43RwHy/WXqhvG4JAaZpiMVPVLVSEXIFQGpES2Fk1FjstxwJC/2PXxWn1cF2Pfg21BfZ2hzKOQ0tblhrTIGbqSAmaruO7LoYVw7Odwm973VriQ4aiGQbS8xC6zvK77iU5chj999xTuXAaBr7jYFgWgefT+vwLeAsXImVArPOHGIt1LVQADBuCv2YtLUh222Vi7ztk9RqaV6yiZsQIksOGUjtjd4b7PlFKDNfx8Dy/YIKwHRfP8zENPQxtDSKT4+7vXUEcOPDsc4g11pGwc1z6t79i1NTw/N9uQNu4AbetjbU33EjtSSdTY+gsufMezFSCV265BYBX77+P2qeeYuDoUYycOYPhp53C81//JtOOPII3H3mEpx59jOOu/CltH37IFtdl8B7TK37MTUuWkMhkWPLM80woMokU45O/uoq3r7+RV/90LXPfeYfDTzuT753/Ob75458w5PBDtypfTCD0PA8pxTa5sEVCSue4FdtrEVWeGyZeGDmwLzH2jNN44he/ZNi0acRHDlcq6x6mx452mkEg0XWlNfKDAJOPNllbhJ4sohF0Xcc0zdCroGfXVowS48UwDQzDwHE9EtbWrrvhf5AoV9ZEPEZNKqF263mb1rYMDXWlg6FFUNqNnjXVz9sQagIqhRACISmYQGTYdiSKQK2Jknu/4m8sEii0ME6M7/u0tWVIJuNhTBKB67oFYaU4sioosuhOq/ovg51asIggpSSdyxG3VJyASHMhpSRvO2RyecyYiSMEZiyGGQ58zTBU4Bkh0DQdI66x7JU3GHf6KBVDQlNq6/zqlQzeZULBUwMhEFocTddIv/YaQ0/6JPEuclNsee0N8mvW0NSvCQY0EessPHge3qaNfOLXV21TP4hhQ5mwz15qN6LpCKHhhV+lcqXUyeVtsjkHI7RZJhNq1+m6PquffIoVH7zPCV/8InoyzsrnX2TVuvUcfuWPIdzJHXDpV5XtdslSbvvqpRyVrCG92xRGn3UmhqGz7uqrOWvGDDL9+rHbKafSNH0qS++6h1f//Ff2+9530Zua2GfvPRn96BNsevBBWv2ACSefiO16mHq7aaIrDBw/Hqe+HrOurstyu5/3WdbMfhYv8Fn8/geceeopBEJgb96M1a9f6T4M1atBoCYsoMcCRsSt2NEZTgPPx3cczFA13Jc4/NJLeOD7P+T4n1+Jput4EGbKrXwKUur9UCAJtWYfYWqQAqSU6LrR4/clhCAWM8nl/IJ3QV8LjqVq830fPwg6aCuCIEzAJVUIdun7+IaJYRgFjkbMVM/Y3JYhbzskuuRPtJObK4Uet3qUE6fgVtrZFBLeX4iikPpF/Arf87HzDrqhh+9ODz07FFdG13XicQ3P83FdL+RuKG2NYbRncXZdD00TGEbPNKY7A6qCRQgpYUtrGtv1aKhNETMN0tk86199nZH774MZi+F6KtNiKm5h6FohRXT0geoyYNAe09qz84ULyqTPn8+8f/yLYXGLDx9/grgU7HbxRQhNQwsC4t14dDTu1Z4Xw1mwmPyDD/PmSy8x4dBDWDvnbWLxOKPPOmPbnn/dOhbMfoYF773PyJM+pXaIKIFCpRMWoctcDMfxaGnLELdMYphkczZxK8aoo49g7LFHYepKdT9h1CiiJOarX3yFVa++wqhdJ/P2o4/Tms/xqe98myu+8Q2u/NOfyNkOOIITjz6Wtz+cx+f+8LtC20affCKji9oa79+foUd+gqX33s/Q3aejhdqTXCBJJmLEulus4nGO+/EPue2rl5LoP5BBe00vW3TIIQfx4j33MrZ/I/fdcSf9nn6GT331YsYeeiiiTLS+yI7evivyEUJDK5NmvfAOIja/HxRswJWgO1fHSq738nm1eNR2vRPtNWIxinUUmq53G7OgMyLXSt8PiBkGW9oyGLpO3PpoJ3a1uPUuUVzkhhrFQ+hL4aLcsp7N2Sq5Wzh/SSnJZHPkbIeaZByERt738Dybmk4huTUhSMUt2jJZ4t22tfvnKF70e6ex0BCiWHAAgdKW+H5QID8HQaDcwmU4jkKitW7oBY2slGCaBn4QEPiKMJ3N5gA172maVmiv63qYptGlCWtnpRnATs6xKHVc13WSCYtk3ML3fO786leZsv/+zLrwAmRIWszmHWqT8R65PL7yjW+DbpCor8dMJFizfCmHXfNr8DyW3XIrg/bbj/i4sRXXl1u0CFIpEnV1tK5bR92YMRVfWwr//uKXya3fyMlXfJ+GqVMKx2WoEkWqmBUR435LSxopIW4pW6QVU8KErmkq2VaJj+213/2R4YMG0G+3aaxZsoQ18+ait7QhbZtcPMGgcWPICMGi55/DbGjk5F/8tGx71z3xFD//3vf4xMyZHPbdy0kMGYLteNiu220Y4rsv+xZ2W5qa+nr6jRnFrC9d1GXf/O7k0xg1YRyHXXQhqdGjeeM3vyExaAi7fvqMihaB9oA9Ek0vnXwsEkCADqTQSuB6PnnbxjSVf39PXQNlEODlbYx4vBCTY3vgL6edxoW3KxdVlZhMYPTQfBCpr4VQz521Hfp1o5bf3vA8Fc8g2UtuSrRYKft9bJvCSxfDdb2SvDHXUxsDTdOIx0xiMZOWtgyWaWC7HromMA0TI8x70nk8SRnlIEkSK9NWz/MK0Si7QvH60xuORec61H8luZyteE6awNANNE2ERM8AEEX8E9Eh6VihLWHuDykhmYwjkYpLoWm4rqtyr3SzgfF9n3g8+VEr1D4SVAWLTjAMnYa6GhY/9xLLn3qCtubNfPZv1xXOSynJ5G308KOsdCK58dgT2WPfvWnab1+GHXEYb37tm+x20QWYkyYSNDfT/ObbmIZO7YEH9M0D9gatrcy7735EJk9y6CCatzQz9X/OBiIBI4pS5+O4Hptb0ip3gxXDMNSCqWsq0mRn5JctZ9lTs9nlvP8pHJNSguOw4N776T9uHLdd+TMa6urY+7PnMuqgWV0SIJ/63g+Z+anjWPrU07RpGgd84zLlSpfOYoX5JEpeGwQ89LNfcOz/fqfLrnj9+htZ+f4H5DMZss3NnP/vm9qr8H2WPvw4Y449ske5LzoTEKFdy6C0GqIgdPRkgXI9n3Ubt4CAAY31xEyj4utlEOCkM5ipJGI7umeuvv8h7FScMYcp99PA89ROsRfkSyklbrgwtLRlME0T09B79D32JWzbAWSB0NcbRGMjn7cLAsq2Povruh2Iv8X3klLi+T5t6SyB52NaJnEpCzFMoOscG22ZHLESeVsiKDOCW3FWVymVV5KK+tuzGCfRGiYLmgdZIFnmbJflqzcQt0yGDmwibpkEQSjEC7WRLEVEXbexWdWTt0EIhgxoJB6aS/J5uyK34sAPiCd2TsGiagrpBOWj7PDCL37OLjP3IJ61WXLX3Yw5+SQgDHJjmqRzeRVmWQMhJe6aNbS++RbpnEPtqJEY+TzU11O3+254S5fziZM+xfALzgNg8yOPkTY0Vj77PGMmTURraKDfoQez6u57kfPmUTdp0kfz8HV1TDr7LFi1BoYNwXjmWX643/6ccP7nmHHB+Sr4DqCFGTuT8RiJuAplq4dChRBaSdV84HkdhIrCecuiriZF44zpnH/LTTT/+TpqRwyjNZPDNHSS8dKhcgMrzk2//T1aW4Yv3nlrob7aVIKWdFYJOCUWrTXPPM+wmq65FQDrPlzAiVf9rGQ6cKFpDJg2hffvupcpp5y41bOWQnS+mH8hJeFOShZImr1ZTAxdY0C/eqSUZXeQpRB5aBiJ+HYVKhbdeQ9GLFYQKqJ7+7aDaZTnc3Te9BQLYxF5s64mie9LsraNoeu9TvO9LejsudMbROYzw9DJ5fKFnf72eCcFF2khaKhJ4rsegeOoNAAVxtVwXLdLbyxNE6EJQnZrAoyIvCrsu15y/ugOUdTMYhI1QCabI5vLo2mCJSvXousamWyeIQObWL+pmbqaJEJAc2uGRNyiLpXAdlwyOZtEPEZza0b1laGzqbmVmmSSoQMaum+QLFBJd0pUyawlYLsu1tCh3PXyy7yydDG//OWvWP/Mc4Xzhq5hxUzacnkW3nk3y+64i7bFS2k6/jhGnXYS/faeSd1B+4OusemVV1n+/PMFoQLAkZKVa9dSP20Ky++4u3A8UdfA0oce69iWongLOwzDFOdjyMEH8aU//I4PX3mFN373B9rC8Neu75OzXTw/KNg2AykLO4Fik0k0SSTGjilrc/QdV328pkndBecz/8Z/sP7WW3HaWsnZYfhhzyOzaHHhmlRDDRNGjeaLd9/eYfHXNY3aZIJM3qYtmyfvuMpVLrz38vfeZ9rnz+22Cw770oW8f8ONJc8JIUgNG8rk44/Bbm0jn86ULFfqumgBMU1Txb4IPT+2xd1QCKG0NKHNu9IdIqGL6fYUKgCE5zKwyLwGivisx0yVnKzTuJBFY8cPI512RhSgTNc0rJgiGHp+38eE6A7R+O8Loq0QAsuy0EOS9HZ/FinxsjmElBiJeJd5gYrhh4TJrp5ZErnT5rtpgsTNZnHzOdx8Hi/Ma9ITKE2f2ErDqTgWymy7bsMWAFrbcjTW17Jq7UYy2TwtbRkWLl2thIlsnuWrN7CpuQ0nDHgWPc2qtRtpS+fYtKWlWy1lZPrcEbl9Pq6omkLKQNc1Nv/tb7z86CMMjCWwJoznU3/9U2HgSinJhVntapPxiolbb/zghwybNo3mZcsZuP8s7E0bGThzBvqgQbz+l7+y54UXdCi/6ZkXaBo/ls2bNtK2cAmjTv5kL594G5HPM/+uu1m7ZDn7fOE8tIZG2rI5JGDFjKLgTe0ftqFp6JqKfxEEgVI9lvjYlt59L4Nm7kFy1CjFY8nbvPPNyxk+aRLW/5xNTSKOu3QJ5vqNzHv+Rba4Od589XWGDhjAIZ87n4Gz9utQX+R37rguWdvBMk0VObCtjfn3P8QuJTJwlsLVJ5/G1+8qk/sCZUZwszk1IfeQuFfgXbB1EKMdARkuKrqldonb+/5v/vyXDDjoIIbP2qdwLPB9lTk1ZnUwiRRIrOHcVK5/ooBkuq5yiNiO4teAMg9FSeC2J4IgIJvNkUwmekXeLAUpVXIroGJTQimUM4UU38d3HKTnh4kKu9d2SSlpzeQQQF1N19qmXM7GMFRMiHIIPA8nk0VPJojInkpI6N03IaXKNgpK8GluzbCpuQ3TUNqglrYMtuPR1FBLWyaHHygisON6DBvcn/Ubt5BMWASBxDQN8rYDgGkYbGpupbEuxZAB/cJxtbVPkmqyim8Ri5k7LceiagopA98PGHDBBUwOYNPSJdz5/ru8PesALvrudxl4/LEIIUjETGVvzNnUJrp3ldr86muM3msv3FyO1tWr0F57jXdefJm9NmzAqqtj1xOOay8c5uuo2WUc62Y/z+LXX2Pa8cdBPg89JLz1CeJxdvnMp9mluZl7rvwZI3efztQzTyOTy5O3XWSgIg8aoTpX0wR+IJHSR9K+SAQoASMiWemazqjDDmHja3NIjhqlPBPiFtOv/BGL/3UzL37+C5x43V9JjR7DO0/OZuXC+dzz3vscN3Y8Hy5ZwumdhApoT95lxcyCulYIAUHAogUfskuFj3zspz7V5fmCUL4NhL3OcSp2BKSUKoqopm13bUWEPb5+CXOu+3sHwULTdfSYhZvLEatJFfoxao9egXkp4v4YukbW98nbLrqu0ZbNo2sa9TV9G+yrM7bVI6cUIs1FLpfrEzNL1/fSQJMVCRWgBCnbdmhqqC2vUQnXW02Epr4gaHe76PSOhaZhJuJb3X9bnjcIgkKsifraFLU1iXCDIxkysB+BH6BpgrztFAQ3PwzJn0rE8D1PRezUtdCkAbomGDa4CQpeXqJgyhQdNksyJIl+9NGcP0pUNRYVQNMEcvlyYs1buPTKKzmpXz/Ovu+egj0wG4YXTlWwu/jHp8/itHPP4+2nnkZPphi71wyajj26Q5ncqlWsfX0OTVN3o26s8vbwNm4i++obrF6zmtrGBoYecxQikSC7chXJ4cN63gHbiHWPP8Xq5cvpP2E8Q/bfD8dVHhmO4+L7PpYVU9E4NRX1rly/GEJHF7D+oUcYFAlW2Sz/+s7/cvQxR7P0meepHziYARecR52QiFSK3596Og0DBjBhym7sedop6IMGVtzuu7/+TU66+pcVlV379Gw2L1zMrp8+HWq29jyQQYCbyRaIjz2BH5qRdL33O7MIPbneDwJa2zL4jkNDQx1GiSRj2wtLb7uT0aef0uGY4lrYKstvTapH9UWRSUGR8PxA5bbwfJ+aZJxc3qG+pu80CaXgui6+H2yXGBSu65LL2SrktIiCTimvGMPonk/SncaiN8jlbdKtaeoSlhIGQq2bpmsErocei+HZtsp/lMtjxuPI8G8vb6NbMQLXU0nukASeT+C4GMkEesxEBkEhAV7xN9UT12vbtjELgQ4jZlg7orpc1w3zfOihW6ry7jEMo6ymyPd9PM/rEGG1A5dMBhBqSwWCmpranVJjURUsegArZrL2oYe56W9/ZTAwfvAw2uIxzr/x77Q6HpZpdMtMn3f/Q0w64VjeveJHpFtaaRo9holfvrDbRGMdkM/z1jW/o//ECWxesYKhEybQ/6jDISQGAtt1Mi3GwrvvYd3CJez7+XPRGhrwfJ+87ZDO5vBCt8BYzCSViJdUS6s04wabHnmMpv33QwuDVq1/9lmshYt54Y03yLe2ctif/oSpK+a/pgk+uP5Gppx/Ls9c9SsO/tbWmUnLYdOLL9G6Zh1jQtJld2hbtJjHfvd7TvnVVVu9o4iAGAWV6knypGJf+J5O/K7nkc7mcT2PxrqaQi6RSq9ds34zyYRFYzchnfsa6x5+hAH77YvW0NDhuAwCPDsiD/ZQQAsCAr89mFgQLrymodOayZFKWL3KhFspcjkV/6PSZFs9QWQS8Twfn3DnLDR8GYRcoq2TxUUmJE0ol0pRIFX3zfrWks5iaFoh+m6keYy0R8W/83knjPUgtjofNpbAUy7WvudhWDH8vI0ei+E7Dppp4rtuQYApuKEKlXMGKRGaru5fNI7zeTvUmqrMwMXk7yKlCTJQycoMwyCQAY7tYMZMFePDLD2P+74KmlVKkIyEviD0mkvn8owYMmSnFCx2XnZJL2A7LkOPP47DDj2UD4FH165C5HMI06QmYWG7Lm43BLJJJxwLwNQrvs9+1/yKsaedxMqHH6no/pnFi1l53wMQj1O3y0Tef/JJpn3tK/Q/6ABW3PcAAJ4fkM072/yslWL8SSey/6VfYe5Dj7LpyacwdJ2aZIKmxnrqa1NICS2tGZpbM+RtF9t2VbAawNQNFfMCqBk7ls2vvFqoNzVkCG9s2MDB3/8eA8dN5OVvfhvpOLRkcrRkcgzed18W33Qzcdfl9ev+Tsu8+RW1t2nWfrRs3lRR2Ss/cST3X/N/CKd0fwoh0K0YRjxO4Lo9Vn1GHiE9hZSQjFvomtZObq0Qhq5TE48Rt2I7PFFX3bSpbHz9ja1PCKUulwWyXOUoTnEdxVGJPGM0oeH3MHR4TxD1+/bicUQCi2mqhbUuGac2FaculSCQki1tWTJ5O/QyCsjZDs1tWdoyOZrTWdqyedoyeVozuR4TIsshiuGg6boK8KcX/7/9N0LFkECIkuc1XVcEXiuGbsWIpZJohoFZk0KLmZipVOG4KmMpLpCugQwgCPAdF+l7OGmlgbNbWpWgb9sEroufV78D1yXwVK4TikxXQlOkW9/3SLdlMAyDmGluFVms2KyhhInS31uBGxQEZG2b1nSuT/r8PxFVjUUvYBo6zS++wPPX/IbXkBw3ajReYwOn/+7/SOfsioJnBa2trHjkMdatW89e556DqN06sRWOw7s//ilrvQB7/TqGTd8dy3N56733OPCkkxhU30DswPY0334mw9I776LVDRi9x+40zpje20esGMXjx1u6jPyWLSSn744X+MhA4suA5pY0ubxaAAVQX19DbTKBlsuy9KHHmPip4yGZZM2DDzHkuGO3qj8IAnLvfcDrf/4LjZMnsctFF5LJ2Vh2jqeu/Bmf/NY3WfD0bLKmzu5nnN5le1sXLeKBn/2cz1z3126f7Z+fOYdzrv0TG5evoP+uk7vsA6ct3WOtRTH5sCc7yna//TCFu6g86ZmTziB1HS2M/bCjse6BRxh09OFbaX8Cz8dJp7Hq63rcF0pQDfNCFBFAHdcj73jUpcqnge/JfSJEdQVBQCaTJZlM9ChaZE/vmbMdsrk8ybjVIYy2HwRkcnYY18PHNAxqkkrgbNeIha7xoTZ1W9uzsbmVulSy28R/yiShzAqVeMwUR+CMUEojEP3ucC7iUIbnozToQkbhviX4EqFrSN9HN01FGk7E8fMOvq7hOm4hy2kQcZ8iTYtqjaKJBBLHcbBKmEqisei6Hpl8ni2tGSaPG7NTaiyqgsU2wDQMWl95mQd+9UvGjBrF6uYWvnzv3biesvEW76aW3PcgS55/jpwEq76ekSNHMPHM00HTePKHP8GMxxkyYTzJuMWmzc1MO/ccXvjO94h5LjO+cSnv3ngTrStXMGz0aBIDBmFNn0rT1N06tGfdfQ/QsNuu5K0Em155lbEnd00+7A2iSJzFwyYIgoIg9cqfr+MP/7iBY6ZMZbdPHMKEE44jMExs2yWbzfH0r3/NYd/6Jo31tdz65a9w5Kc+Sdww2LRyNY3DhjDgWJWZdcUddxPELUaFGTFBua89ftHF7PWpE2g87hhWvvIGbjaDM+ctgsClado0hnbiqxTjpWt+S+u6tfQfOYqZX7qw22d95ZrfMPbggxkwY49u+8S3bYTQ0K3Kg/sojoBfNqtuJddDu8eN1k069cDzkb6PVkxo3dFwHNY99gSDju8oQAaeXyBx9iZgluf7W3kmBYGkJZNVQdxiZphbRIauqqKgEi+3gKn/t6vOM2Hsmsh85fs+6XSWmppknwsWkVq9NZND0wTJeIxcNkcikehgPpNSYodeEFan9xpxLDJ5ldtnWwUL3/fZ3JKmX31tt1oaKSWZdJaYZXaZ8bWS9af4Wf1QIyw0ga6V7vNIoIk0gjKMuBm5ehcjn83hS0k8FlOCgx/g+b6au6UiOAeuh2aaBJ7ikNi2TTyRQHrquJSygwnP9TwyuTybW9JM2kkFi6pXyDbA9TxSe+7FUZd+neZXX2XMuPHc+pmzOe5HP0IfO0a5OIY2xfkvv8KQkaOYv3Qph3/7m8z7WWiz1zQ+8eMrOtS76YYb8ZqbGT5zD/xsltu++nUOPOJwVi5cwOihw2iYtQ/J4cO3as/SufOYsstEsnYbAw5XwYg2vPYGAybtAn2YA0LKkKQERR+u2nFM/9xnGXLXncQaG2gcNYp3brwJ2/fJ23kMoE5K3Bde4uknHmdgbS1LP5jPjDNPxxAabz79NAfuszd6UxMjPnkcL/3iVyz84H32PvJIaqfvjmEYzDr9dO7+4U/YZ8MGrCAgv7kZ0zBZumUDrFnL4HQakdp6cXr+mt8wcdYBDNxnz7LP1fzBB8x96hn2u/iLAOxzztncd81v+WQ3ggWA0HUC10OEGW0rWRwj75VKggiVuz6aZLuLxSOlygeiV0gy7C05tFvEYmRLxDYQmug1Lygygfgh2789JDrUpRKks3ls11Mh1TWhsvCGvICYaRTcUgXKlGi7XuG9RMm6EmG/ZXJ5Gkz1LWma1mfht4uhBKWATC6PYegk46HZKpHAcRz0MCx8JETFywizhbyeoaZwW9uUyeYLHKfuoLxH7JBj1ZVgAZEnBYIwzbkohNDeCuFYjGJEyEIgqoJeIdTWuIXEYoVzRR4pkUYngI6uwiZI10XXjXZnr7h6Hs001B1C4SQIAvB9As8jCM15gMqJ0wuz3n8TqoLFNiKQkqZZs9j07HM89sLzzJq1P1d//nPUA5c+O5uYYZCZ8xZtjs1+536WoaG/fbq1pWRUR4Bpn/k0c/99C1ZDP+Y/+ygNAwaw+u23Eb7E27ieDc+/iAaseO11UkOGMO3SryJMk32+fBHv/vYPTPz6JWRclcGwed58MkuXIXyfVCqFUV9H/cw9EKmeMfAjCCHQhUCnPSGP7brkfF+lIA4CfnD/3YWJb0CYQC0IJM2taebedhtznnycuXPe4KAzzmTWJReTX7SYtx5+mEN+/EPWvPQKK5Yso7GxgfqExaRZ+9O8dBnxgQMQsRjLli5m8tFH8NS/bmVhro2z99qXYZdewsghg7BkwPxbbmPorP2omzihw4J4wJe/xH3f/R4HJS0apk4t+WwLHnyYPY86svD3u7fcwuRpu5Us27lPNMNA+gG+6yHzdshwV0GoNMPAy6TJt7VRO3x4h3ZFaZql7B3BTghRyp2+AyKNimaaFbsVRtdtda9theNQmywt5EZBu3rjvhuNt8jbBtrHam0yju36mLpWyBkRyHZeQrtqXam9k1aMQAaYMQND03A8j0zOVkHggLzjEjONMBS02slvq8YicpuNhIps3iZhxbCKtBOmaRQInYlEBeYdTYRZS+U2vbtAqiRlnu/TUFdTUV2aphFPWAW3z7IQyp+zwF0oEhwiF/UO6tGQmFrcBq3g/UHBhdvzPJU/pzDeFd/Dc70wmJ9ym43FTJU3RNcLn5Dv+x28aaLxITRNuZjqGkLX0ONxhADNNNuHbLjRCoSgfw9Dk/83oUre7AO4ns+4Cy8kJTTefvEFJgudJLD8qWdVrPrFS5h12mnUpRIkQ9vc7pd+Fc8rQ/SMxXjlhRcZvs+ezDj5JBobaknW1FI/dgz9ZswE3+PlO+9ibUsLq5ctQwjByrvuxgPiQwbz3A9+jIaguS1LLJVi9GknM+rM0+h/wrHUThjHppdfYeFNN6t8Db2ElBKnpYWXf/s7Prj7PkzDIG6puBF5WwUOCwJZeEYhIGaajJ61Ly+98QZf+vMfOeCSiwFIjB/HpFNO5qmrrqZp6hT2vujzuJk2Rh91NJtWLieRTDHv1rtofuNtdv/cefQfP44LHrqXiy7+Cs+89jrB4sUqQJLQGH/OWax8+RXsBQu54phj2fD8y4U+/eRVP+P9x58s+0xTTzqRx/91s/rD8xi7xx6sWbESggB77VrSS5eXvVYIgRG3MOJWQT0KyuNBSsUBeOgXvyJwva2u00J3t96aJaOda/FkK6UkcD1818XNZFn11tssu+nfiKJ7pJcs5d0b/sHqBx5iwU034y1d1qHOFU8/zcpHHqN13Xq8MEHatmLjk0/TdOiBpR6iR0JPKai+VJqLyC3Q81QkR1NXC5fqY1nI7llfk6S+JkkqbpG0TOpScayYQTJuYZkGemhCUKTJOPWpJK7n05ZR2UCDQPYZMTKdzdOSzpK3ncL9O3MOYqELdzZbKSFz2+JsBEFAWzqrgo/VVm6mUmYHo1stVKSVEKFLeqSxUOeUCSMKgV8qSV/ELWr/W93PCAU/13WVV43v4TpuGMVVeYNYVoxYTGUt9cMU6Z7nlST8tnNAItk35Fx00uyp2DACwzSgGnlz50NfcCw6IxG3ePenV7L07bd5xHH4+l57sy6RZNiYUex/4QUIIfB8lXpdEe8kCcvEMkt/gDee/Vl2iScYff5nGRwGgmqZOxfn/bm88sDDHPblC1nx5tvU9W9i5WtvIrKt7PH/vosTs4jV1NCSybHq7ruZ8j9ndeB7ANscaEtKye1f+zon/fTHaIlkof5ASnK2Td52OkwQlhUL06ubLLrjbqb/z1kl6118402M/fTprH/kMVrXbaBp6mQa9923Q5mnr/gJ8xct5IIb/oaTznDbVy5h9JixzPz2N3F9n0ToFrzk1Vd5+Y03+M5j7V43z171aw761mUl7/3Mr69my8pVNAKLWltx/YALr/0TxGKsvP1O8p7H+E/3Lj29lJK/XnAh5/32NxiJxNZCQBgmubdxLUBFsgTwcvkwXLaDnoiDBM3QsZcvZ/Pb72DU1LJ+3ToyK1eyz6WXKJNcPs/7t96O3dLCytWrOeyUU1j27jvUDh3G4MMORUKPkpuVQmbxEnIfzKV/J35F1AdOOoMRj6MZekFz0Ru+RVcoV1/0DoJAcYiMMrlbCnyf8DsO/IB4zAjV7qKwQPYEvh+o0POeiuLbnXtoceZNw1DRbfWCe2U7PN9HAJm8Q8KK9ZisGwQBLW0ZECoHT7GmoJJnzIf5W7rKAlpM2ixVZxCFdJcyzEbafZI+ZYLp6OKqhdoGgFwuRywWI1YmNEAul+8QxyIy90ammii9fWd0JA67pHM2g/v3r3Isqtg25PI2e//wh2z54peYvmwpb7z+Jl944G6k1b6AR/7nEjWhZHJ5craDZRoFbUaEz/79r7x6/Q28eMddDJ3zFvte/EU0TWNzLse4PWewYPZz7HbmqehNTQz55PG8fc3v0QcMIIEa3DVJi4EnnIDr+cQ6EwS3QahY9diTvPrIw4waOw4jqUwqUd0ayhUyZhqkM/nQjqkCFyUTFqZh4Da3lq179Ckn8tpPfsaoffZm/AXnsfLue2nsVGbP887B+/NfeetftzDjnM9wxu9/y2+OOo6c53LYFd8nazv0P+oo1q9ZzSzUZNq6ahWLbr0DZ9NmVj/6BEOPOGwrU9QLTz/DoSecwOCxYzn4E4d0OJ8aMIDGQQN63WdyyxYG1jcSeD5bFiyk38QJhXPRxOd7PdMKRBE0pe+reABSInRdxYMwlOdHVD9AfNQoho4axeZXXuWlBx7ggn/9s72yeJwpnz0HgCkLFrBq/iKmnH9eYcH1/YBMNk8iHuu12j81dgzZufPKnjeTCbxcHjfrIzRBrERQsu7QW8GnsNsViiBoOy6mYWwl6BXMEoZBTVIjm7PJ5m1yrheapSQx0yRumSWzZnaGlJJ0Lo8WzguRC/BWng9F0DSNZDKhdvGeTyaTBQF1dbVbb1DCOjzfx+iB0Bp51QhNUJdKhgvz9tmEdtUmpcVQmqhywkeEKMiVG2oFFQfG7PAOc7m8civtQSbcSDsBoamlk3BTyltFBhJR1VjsfNgeGgtQcQLy77zNHT/5MVuAPUaP5vi//IWEFdsqeFbU95mcje26NNSmyk5Gc//4Z0YcfSQ1Y8cWjm1+6BGkbmAmE2xcsZI6oZHJZek/aQKpWbOQUpKzXRzPVZNDH9jI7bnzWPzGHCafenKXwokfBDieG7qYCnK2Q952qa9NsvHp2TibW5hwVundf9v7c1nwwENMOusM1j7/ImPPLO1C2rZ0KcufeQ7TMDBMkz9ecw0/veYasp4Du8/ANDQW3XUPm9ev56DPncubf/kbU049Cek4bPzgAwbusgtW6Eb64p/+RF1NPbud85nSD5TPs272cww6+oiedViId/5+PSP32YfEiBGK9NvYUFJrUazOLUZxUCEpwcvn0QwD37YxEgmgY1jmribNpQ8/ytARw4jt1j1/BEKSWpj/IJO3SYUCYm+w/tHHGFjEYylGxLGQgQyDZtm98hLpLQpeNlLiOipeQ2ePnc5t8X21sKfC6KsykOQcB9fzEShyqKYJTF3vECgqCCSu7+P5Pp4XUFejNAJB2Aed79N5EStus5Rg520QdOBeRN4NfiDJ5G00IdqJoGWep7je1rYMlhUrSw4t138RokBVXWssip+xvIdOFJiq3HoVuW1H3iBRoCopCc0dgnyY2K07fkpnjUXn9riuF7qIE2oxhCJ3hv0aaVkyOYeBTf2qGosqth2e79O4914Yukmb7/LS0qWc1tKM3dBPDeoiVn70OxGPIYG2TB4rZpQ0jViDB9G2aAmpMWMKxxqPOapQR5QIvPWWW4mH5EQhBPGYoQJ3ud42q7IBrHFjycx+pluNhyYEMd0sTBYF1XI6zT+u+Q27TdmtrGBRO2UyAxYsxN64mYbxY1l6592MPuWkrcuNHs2U0aMB9TF/JZtnw/oNDD3hWPwgoCWdY9czT0Nksjzz/SvY7fRTiY9R5UfsMpGVt9zO8F0nI1vbYEsLu33xi+UfKB6ndf16+m/Zgt7YWYfSPea8/CpTTzoRmUqi5W2Vq6No5x/txiLhosNCIiW+56nfUYRKQ0c3VYbQ6PpK0bppI6P33zrHSjlEdUceCp4fYOiVEwKjaJBSSmoaGsBxoASxTajBgtBABhp6FNBoBwgWxQuWFnIZ2k1UHVX1QmiFJglNQw+FD00IpKZC+4PiXnl+gO24ZAMbXdOxYgae5+N4Pqaho2uC2lS8nXsrJdmcjWWZZHM2ybiF7bikkvGitoa/keTzDq6vtFWmrhVyi4QFiHJ2yCDAiMVIZ/NoQrldqrmofJ9EobUr7b+IBxEJO9lsTo2ZZDLst7BwYTGO+jdACA1d15GF2BMd65ay67Dp+bzdIfqpEuBU5E3HcQp8lCgdfaXPVNJUYjtsaUljxUwG9KtHUylFWLN+M02NdUooltsvcNp/AnbeJ9+OCCQcf9GFDAFOO+EE9Po6apNxHNfvwFqPoGsaNQmLhGWSsx2cEirxNx57grqJ48nmbfKOS952WfTUM9iuy5q33sNxFelozBmnI2pqCnkFlHBhkrV7Ho3zpauv5q1/3wrAEz/4If6aNSx48BFu+8c/ur1Wkbc62kTjdo5nfnEVX/rlVZx0za+6vH7EiSdgr1yFdHySAwaw4bHH+PCW8plG//3Nb/Pkw/fzwaOPqnsHAcamzeTaMtiuw55nnA5tmQ59b7sOmTVreO+GfzKrgrDg9f37odfX0/LW2yy75z7Sc95Wi+SqNeB5rH7gYTY+NbvktToS0dioyF26FpI6S3tdBH5A4Pu42Ry+4+BkMmEAKI1YbY2K9mlZhQRiPRUWB4wcw+rnX6i4fDE5zjQMZBB0SEVfCWzHZUtrmsyK1Xibuo98KjShMm/2ETGyKxQLENETaZpW2AErdXqkuRBhECRX5QnxfDx36920EEpbkYzHqEslaKxNEY8Z4W5Xo6EmEX7zsYImMeIbrFizgTXrN/PW3MWs3djM4hVrWbxiLWs2bGFTcxtLVq6luTXNqrUb+XDJKpatXs/y1Rtoy9qsWLuRTc2tLFmxllXrNrG5Jc2i5WtZsGw1pqFRV5MkEbcUR8S2VXrwMtGCdU3gON1HlI04BZF3jBDqu4/FzFDIUYRZKVW/RvFWNE1TJMvQ3VcrGmfRhiSaRyzL6kDaLEVYjvpdSuWFpt6jIng6oQbKDefJKDhdqZ8ohkhULnov0f9XrdvE2o1bsF2PtRu3MH/JKjZtaWXluk1s2NzC4pXryGRzrNuwubdD8j8eVY3FdkA2l6f/IQez+5w3mbz/fsTq6pBSEo+ZpPM2qbi1lb0zmohs11OeFEXahZZ332PPQw/BGjacTa1tyhVr82ZWvPwyLWvW0Dp3PvK5weSWLmbKAQfQlm4j09LGiGm7MfTA/fH8AC9kOi9/7HHeeuoZNmzcwOeu+0vh/rKtjdWzn2XQHrtjDB/Os7/5Hc/efie7DOzPvX/9K1+96pfc9fNfkGlp4wtfuJDWRYuZ/cc/8ckrfwzxOGuee5FXHn+M9UuXsd+s/Rg4ZTcGFUUF1TWN679xOef/+Ar0ESPK9t3z//c7zEyejc2bWLZwMWde8DkGHnMUt1xwIWf+6Q88e83vOOjSr2x13aev/DHPfemr1A5VCdla3nwT0ZpG6ONx+jWR2msmzc88w1u/vobdv/ZVAAZNmsyG+x9k8jmfxtu0GSNKZhYEJV2BV34wnw2r1jJg5DCGz9wD6QWseeRRUokkubk6gw6chV5fv9V1+bVrEaGwKIRAtywVqTOZQBhGQSsReB5BW5q3HnyIGWecDgJ000SP9W2Cq0RtEs/pXbhhIQRWzMR2XByUZ0Ul8SfWz34WJ50hMXIE2qBB3ZYvzr66IxBpS8qZCztrkbQw7oXSMFHwXCiUD5l+EUcAocivsU5xL9RGIyiUkUBNKsHy1RuoTSVZsWaD0jTmbDZuaSUIAhrrapi3eCWG3h5Hww8CNja3smFTM7WpBHErpoJrCUG/+lolrAYSTQRoArXZyDu4ruJeJOMdNUhBZI4KeQtaJyE2Wmwj106BwAy1ZxEfw/fV2NANfauYFEpWUVFjRejaKYRAo53L0Xu+THusCt/3cRyPmpqUimESSDzPpSv/bGV2UYIIUisUDcIAa1Kq1Ox522FzcyuD+zeybNV6/CAgncmzeUtraOLqG0+q/0RUORbbEaahs/bavzH6yMMYcoDiPNiOS95V7O9IQs8vXkw85E74QUA6Z6NrgkQshq5rrL3/QQYdr9T7m1rS3HzhRewxbXf2uewrYBiseP4Vmt9/jzEHH8LKBx9gwsVfRIvFWPngIwyfOR2v/wBwXT649jpSAwcw9dz/YelDj/DS/feTTKXYkssxYfQYJh5xGG/ecgd1gwaQXbsGkUpx6Pe/t9VzbXj0cVa++hp6fT16MkWba6Mh2PuLXyiUWXDHXTRv2Ehzuo0jvvJlnOZmfnbSKVx64/XUTZzYZb89cPl3Of4nP2LeQ48w74knOPqLF7Li9TnEdR3R1J/hhx5UUpW+5oEHeeXueznxb9fivjsXc8QQZH092byD46kkcbl330PLpKnfdx/eveJKxv/PZ4gPGsimOW8x8IhPsPGJp4iNHkXd+HHb+Pahef587r36N4wYNoyDL70EvShsu5fLq0VTqAkLGaaWFhp/PPMzfPXuO7Ybt2DTW2+z4o05TP/ceb2uIwhUDAjfD6gJPQbKQUrJ63+5jrFnnkFrOsOAfg2kurFzSynxsjkV0GsHpJbflsUsl8thmrGC6lsWgj6VSJ0tRCFcg5TKHVvTBLphFPowm7f5cMkqRgwZwPI1Gxg+qD9rN2zGNA1MwyCby1OTSpANE5TV1aRU3AbHwXE8amsSNNbV0NyWUfOL7aAhGDtikFpwi6OpyeIwKO0RdSOzhqbpBa6GrmsFzY1y5fWJxy21m/d9gkBihBuiaNdvxUyV2KsTRyQIZAetRG9RiKVTlAI9Ou77Ablcjng8XogB4od5irQueCbFHIvOXitSShYtX0MybtHUWMf8JStxXI9UIo7tKJ7c6vWbqKtJkcvbzJo5dafkWFQFi+2MupokqQ/nk5i0C0a/fu2EStcrELaa57xFQ1FeDz9QAXI8P6A+leCZH/yIDc1bmHrwwconu6WVRL8GRp14AqDIZgL1gWSWLiM1ehQCwfLZz9NUX09i99144IofM33qbkz4TO/cJXuLLW+9xSt330dcwtJ16zj3L3/o0fVLn34WZ+UKJp5yEktuupnFq1Yzc7/9aTj6E1uVdRyH+754Madc9xfEhwth6BCorQkFOg/H86hJxrEXLmbV3fcz5JPHseqW2/BqkqzfsI5Jsw6gduxoUlMrIzV2h8e/dwX7f+5ckiEPpBi5TVtUWOJYrBBo56Gf/4L37n+AhcC1Lz6/3RbTd6+/gUmHfwKzC81RJQikpKU1TSJuYXXBspdSMvv//sD4M88gl7dJJuIMamrolgAqgwC7LY1VW7PDNBe9QS6XJxYzy3rLtHsNqMBcaocfaTXaPQ50XS/a7SsyoB8EGLqmyKDhQhxFGI3MnYauE4S7aFCBtARKYDDCAGyRuaFStK8LAttWni+pZALT0AsCkWqzqjMy8Rq6jkSF33dcj7gVK7hmRgtz1BcFnso2CxbKxbRYsIhccos9QNrbLTuYaDuTqPN5u8DniHggytVVFDaHZqhpLGTTNQ3S2TymroEQxEwdzw9oqKvfKQWLqilkOyOdzRObshu5555l4PHHIYQgYZk4nkdzW4bG2lQHoQJCzoUMuPU73yWeTNKYSDC8aQC5ZcvY9StfRm5Yz5b5CwrlNSEI8nnWPDmbuS++yEFX/ADH9diyYQOrX3+DDX/6E/rAAYz/dNcJurYHGqdP5+jp03t9/ehDD2Lt/Q9AMolobGSv/WeRHDy4ZNnWd98nu2Ydy/96IwNGjcBZtYqX77mX/Q/7BEyaQDBsBEhYN+dNRp1wLBvnvsfoL5zHhnseZMApBzFg75m9bmcpHPG97/L+v25hynmjtzoXq6tVCZGs9rDvt9//AP1QQsX2RL/a+m0WKkCNu0TcIp1VIbq7Ei6mTt2NVlctfPm8Td52C4TeshCCWE0KN5vDSMR7lODt44T2BTUKzGUo1kGBP9IxgZoQopC4SwvzYZiG3r6B0LWC26OUatGTvo/rqDTlKm+PLJh2dL3nOUKK30s8bqHpOulMjtqahPLC6iQUFgfYlFJimga67hbylShOhTofaSsCyVaarp5qjlQ5GQoNHoQhvW3bVs+viQ4mieJAW8V1FGskPM8raJMj8SrKyBwlGdNQ5NZozHu+jxcEWIZGIqG0OL0NUf/fgKpgsZ0RBAHpbA5StWx5fQ6Ne85ACEFdMk5rNk86p9z3Io0Dzc089dOf8eZb7/LlG65j3co1DJ2xO7l165j7hz/z7He/x7RDD6Ztw0ZqVq/Bilvk2zLYq9ew6pVXOPKnPyHvuAghmHLc0Sx94kneff5ZnLYWoJ3pHKn4/DB/glY0qW0PtL0/l+y8+TQeehCxfv26LZ9ftw4rZrH46dmMmDmDVQ8/zOjTTuH1P/6FKUd+Ar2hnoV33UNdIoHV2MDi1+YwdNxYxk6fxgPX/5VNwIknn0z/3adR+8ljufasczjurLOY/dRTHHf55bQuWMAL9z/Mp3afTt0u41j53gfE+zWQGj1qmyNAFhCLsXrlKmL3PcCETx7PlmXLaRw1ElC7Nc91OyQtu+aG67nk3PP65B1sNUF7Hkvuug8EJEeNLntNV8GKSsGKqTgBedvB932SZUwcGzdtxgja3Tmz+XxoDilftxACNA3NVG61rh+gm6aK0dFX72gHItrhRgn7/KL+rjSFvZTRu1ULqtLkhERFXSu4VnbFIegpIv5XbU2StkyW+ppU2UBuxRpww9DDyJcesaIEaIqTooSL4gFQTJLUdL1H7vHKpKQVuZVCPB7rYJaKPK4ij5/i54tMPNH7iMVKe8wEgcrNY1lW4VpQGhu9UxTQ4ii3Oxv+877O/0B4nsfAffbitat+yYzmFjLZNLofUHvgAWz0AlY98ST//OUvGTB4MGPGjGLGYUeQaGwiPnQoI4cMAaB26FD2vvJHAGSXLGXl+3fRMG8Ba1u3kIhZvHDf/Rx60YVAeyz9RG0tu558IlNOOYlHfnwlT//sKg65/FuAyu+RyTuFbMOWaZBKWGWfYVux4f336T9kCLGGhorKr3z+RXLLlrLLaaey+K57WbliORsXLWXLytV8ePtd1DT1Z+gB+5Gqb4BhQxiXqOG1e+7koCu+x5IFC9i4cgXTLru0QML8wr//hZSSI/eYzqInn6a2oYEhM2eArlFz2KGMXruWjbffRc2Fn0f6PsLq2BcdTIaOowie8e7zNSz+cB7DJ+0CUBAqQLkpGp14IrdffQ3Txo8r6+bWUxQncpr7r38z6dijEQNKB/mSUpK3HbJ5m8Yy+SA6T8bRb0PXScQtWtuyxGJ+YeEsFmoWLlrILnvvXbg+bzvhRN910CYhBIZlEfg+OhB4XsGjZnvzLnqG7tuiaVrBDa+YfxEl9erueTQRETz18LtVbInIi0IP425sK/mxFJRHkHJRzeRt6lKJwnN0RgehQUI+n+8gWKiu6pghueNJoeKZFN27O5imjmXFcBxXudIWCbihbEEQ+ETaIcUtkWW9jiKz09bH2xkpxecd1wtjlWh4odmqS6n5vxxVwWIHwPMDNre0MenY44jX1VI/aSJ4HrOv+jWbm7ewafMWLr3/foLAp6m+Dl3XSEjJ4gcfYexxW6cBT40dw5jp02g68nAGoT7uo8aOpX7KrkQuca3pHDKQ1Ncm0YVg3zPOYPYN/6A5nS3YCuuSCYxQrRpsB+l65V33kho4gMYDZjH29FNZetc98Noc6nbfjfTc+dTssXvZa8cXxa2YdMnFTPI8HvjKJUw99FC0mEXbggUkzBgMU4LXloULmf/ks8w89limz9iDyVOmbOXZIYQgMXQIE04/hdZly/Hfe59sbT0xx8UaNIgBZ57OI9/6DjNOOpFBhxxE88JFvHHn3Xzi28oVdfEDD7Nk7gd4dp7+DU30HzaEUcccVV7AcBwCKZl82slbnZJ+gOc4HSbc3fbei99e9zcumXUAv32pcnfQcihm4k86/VRW3fcAA/afhTV8WMnyrueHuTUkQoTarOIJ1nF47fobmX7aqZj9Gjs9kJrAW9M5EpZyM4xCSM+96WZmnHYa6aLijuvRks7QWFcLlB970b0jM4im6zhtaUAUYnj8J6Dz+GjXDFWmqejgQVZ8PPzteX5h1x3FDNFK3HdbIELTV765Fcc1iZmG4oOFprBkp8ihEohZMaStAoLpetgWGebUKPmMsjA/tT/h1gJthILm1VecCsdxVLCyItOGDNrrkoroAmH49ehMxENRXjzdYesgZa7vowFSCkAvmKp2VlQFix0E23FJTZxA8wvPM3CXCQjD4JDvfhtp27ieR6vjk4zHC7uX/sccwYdX/ZqxnzikZDCqTDZDU/h/IQSNRYRDKdWHks371NWoncWS199g2LAhpBIWedumNpXoEJq2rz+B/IoVmJ5H4wHtLqfCcfjg0UfI/vsWIOCwPa7utp7WZct4/cabGTN5F0bvP4tRp5/Kh/+6hcmfP4/NL7xE06gR5FevJjlqJE0TxvLqv/6Noes0DB3M1Z86hcNP/CR1qRQjjjkKvbY2VHsKGvs1sH7pYu77ylc54c9/RiCwBvTnyKt/xXu//xNafS2/+dplfO8vf2H57Oepralh0dtvc8T/Xh72sUT6PmsffZza2lqssaMxOmUuXTL7eXbrRASd/69/M/HTZ+C7DmYy0d43QrDf+efx4HV/46lt7Puovg5/JxIMP+oIWt6fW1KwEELlg6hJtgtJK9dtpKEmRX7+fFbMm8fSDz5gwn7789h1NzJx7xn0m74HsZhJbTLO2k3NLFuzAaHBiIH9kVLSr76W9c8+S+2YCeRicYSUGGGSMNePEnm51NckydkOyXiMfBg3oSaZIF5CcJBSIoyQQ/CxQs/aE6nfi/+u6C5F2ohik6bruoXgT1IqTVX73rrvIISgpiZFOpPDMXVc1yNuKU5Ba1uGhrraAumxXUhQnjM1NakCabM97bks8BYiXkk7wVN2iA9immaHSKjKlVTxOJSmQsMwzEJkzPY+CwqcFtVnFMwmxYTSaFMmuxF0I5knirCZsx1s2yEVt8JYGS4Sieb5WFaibF3/zagKFjsIUkpa01nMfk2sevgRhh97DADCstB0A99ObzW57HrsUbz2+z8wcOw4Rp18YvuJIMD12lV4Cx94iFEz98AMzSamoTOwqYG2bK7w4Y4+9BAevuoq9jR0YkZyu6uRmxctpn7y5A7HRp15OsM2bmTFvQ/Sks1WVE/dkCEcdvllBffSzJo1vPH8c7z6+GN8+pe/YPG/b1OBjJAMTKZ45fXXWI6a5sc1NDDtvM+C4zD/jrvY5TNnFup979HHOeb002DkcFbefz9DT/wUlgcrbr+T5k0bePhLFxNH46UH7mfTylWMm7wre516UqHfMq++gdvazOBjjsLPZEi/+x76oqVoAoJhQ6kZN5YxRx6GvXxJh+d594knGTh+HDXTphYCXIEaH/defAlPAYf0qscp1FNWFV5fT279BurKmBGKuRW+75PN2Wx8+ik2Z21GH3k4Q6bugWMY1Awbyau33cJIM0lN/yZ2GzeSTS2txEyDrG2zfN1GgiBgY0srq+ctYshRRyKyOZVRMhZjU3MrMcOgJhUnnc0zpH8/Nmxuoa4mCQLasjnGDRtcUrBQD9n+rB8fc0jP2tHbdncWFpTrpyIkFrQ7nYiHfQ3T0KlJxnF9n9qaZMH0ZbsufqBMYZG3SBAEKj6P43R4X1GMCRWwSsWNsCzl1RFF71RmnXbyq23buK4WCg3Ke0PXdSzLUvyeZJJYzOyQ9TX6HjRNww0kmtbualpsxom8S3xfudEaRoATZn+2TLMghERls3mbtkwO3w8QMlDk2sDH9SiYWXy5/YO7fVxRFSx2IFzPwxo3noaFCzt8ZLquUZdK0NKWwTQ0zJBF3bDbbuy12268d/0/aHv3fWqnTlEVaRrjTm1Xr48/5CDev+0OkskUY848rWAPTcYt2kI1pV5by7SZe7L4znsYd+pJW7WtKyjVanuo3e6yLwIMPuRglt58C8OGDsJsaiocN/r3Z+CxRzKmgiBJAMRivPivfzPrrE8DkBoyhE//6Q+se/kVfvvpsznh3M/y8pNPcOznP4f70kvMBVxgGHDZg/fjuB6GYZJ5732W3f8QubY2Rh91OLudcZp6Ns9j4x//jBw2jGEjhrHkzbc55KqfMnr6dEYedQQUwhEL3C1bAFj37HPEPJ/Erruy7omn2TBnDmMPPBDXzpPYdVfszZtYesM/yEvJ4AP27/A4x17yVdLNzWjG1nlj1qRbeXEbPUKklCqrpWjfsUY2eBAkRgzDXb6c2KhRXdbj+QGZdevZvGEzg487Fsf1qYnHybsutck4u591FnPvf4Ch40ejTxhNLu8St2IkpAy11xqJuIXMq1gKTXU1rFy/Cc/zSFgWpq6RsCyVJyeMiuj7gfKOQJCIl89PoZkGXjZHzPzPMYX0GYr9NGnf8Ufpv4uFw+0lckUEyBgd+18PhZxI0CjMF4aO7qtQ5qZpEAQB2UxOJZqLmZimGUbpVCkAOgvGHTUzHjJcsKMEY7Zth1FS27UUxcJF5MJb4PQgOsxn7b/DYGdS0prJoYdm4rzjYZl6SEZVWhIn1LBYhoZlxdA1HURxtOFyHJKdAzuvEegjQjZvk61JkX7vg8IxIQSWaSAEbGpJF8LRRnDS6XahohRqaphy/rmMPOIwFochuIVQobzrU0nMtWvZcMttTD7jVNZv3MjzP/5Zj9ocBEp17QW+SmFcIUafeTqL7rhLER2LkBoypGRky3Ko9TyyGzcW/l770su8cdNNTOg/ECtmstcxx+CuXoOfzlAPDAAcYNN7H7C5NU1LOsvYs/+Hx269DV/T8ZM1hefQDINZP/0JzW/MIWhohMZG9T40jSd//X8dJuoP//EvNj35FKlhw9B1ndyy5Qw+6nBGHXsMqQP2o+GoIwjWrYF8nn67TFKxKhyv0G5n9Wo2znmTeMgLKd4xBYFk7ocLeuSR0RV8GRDIAF8GhffmBz7W7lNJf/BhSdJdMUxDZ4R0mHHEoUwYMYThg5qYOHoo0yaMYsrYkYybOJajLvkSw+rrWXXf/UwaM4xRQ/ozbeJopowdyZCmRmriFnLLZhpTSfwgQBOCxtokg/rV0VhXg2UaDGqsZ0BjLZPHDA/rGMCUsSO2yvRb6CfHxcvbmDWpbe6jvkD7Irhj7leqTzzfC70YPlrtjWEYHbhaknYPI8PQsW0Hz/MUJ0MQBq5SwoQeevkUEzY7CElChQC3rJjyyBCKJOm4HqZpomlaIQtvu9aukzlQCAzDUIKOrhfCj2dth4ztoOs6vgTXl8RNnaQVI5WwSMVjyuSRV2kREnGLmC6wDJ2aVJJEPK4ELdNA11Rock1oOzXHYud98o8IQRCQHzgIb81aZOjXD0qq7ldfh6FrZG27w8S/ZMECnvj5r3j7hpu6rFtvaiIHNL/zLgDCdcksXsySRx5h/OfPRTdN9rvoAsbtvSfv/OlavE1bWPfq6922uXi+krQnlOoWmsbwww5hztW/6b5sF5j62XNI9u9f+NvJ5HEDGLb33mxeuZJRe86kMVVDv0GDaQXWAK3A1RdeyJXHH8c/z/w0D3z/+2xYtIDRY8fQNm8+rZl8IUeCME32uvDzZB5/mn3P/ywA6z54n31OOrFDO6ZccjHWoKG0zptP3cEH0jhrXwDqdp9aKBPbc0+0VIqVr73G9K9fQvO8eYX3vP7tdxh+4gkkR4zEdzvmbtGEoKm2FtnSsk19FXlpdKagBUUEXWPIIBbdc3+X71AIQcKx6T9pIgkrRn1NkoQVI2HFsGIGCcukLpVg9FGHUzN6NEtv/AcNlokV5scYMqAf9TVJFq9agReofh7YWNch8ZSKO6ACDiUTFjHToC7keZQNra1r6KaJEBqB6+2QXCJdIYo6uaPQWfCUUrFmPw4JrzS9dGp1EfIZPM8Lg4kZpFLJgsuqFmbxEgIVwbPMuJRS5SRJZ7J4rks8bhG3Yp0y0HYmeoqCOaUDAVaoQGMtmWxBW2Z7HjnbKZjkNE19RbomSFgxklYMXSg38WQySSqVLMTo6CwI7eyoRt78iJAUwOuvMezkEzvY7gIpSWfzGLrKJFk8UNvmzuXDJ58h2dRAYvBQRu+zZ0FVD+C3tXHb5f/LssWL+cRxx9K8cBFCSg7+1mWYwzoS9lqfe4E3b76ZtBVj5sGHYAwegrd2DbWjR5Mq8tZwt2whvXkziZHtAZU0ITD18plSO6sy1z7wMOktmxl/zlm97i8pJZvefJP8uvW0tmVY9d57tLS0MH7GHrgfLmD6N76OTCX57sGHkgEmAIuAVUAjMALIAVuAy776VcaecjI526E2mSgQZpfc9wBLX3iB/b7+NV7+5TUc+utf9KqtLW+9TfPzLzPsjFOwt7TgrF5Fw8EHFvrDsx18x+mQElxKyavX/Z3nn3ySy265udf9FNXlB0pTUQ7rn5xNSkDTUUeW5mR4HvlXXie+/74V3XPNsy+w+pWX6Td1d0YdsC+P//YPjBs9ho2ZDE1HHtGlWlgIQVNDHQ21NYV3UQ6B6+HmcuixGF4uh9B1YrWl3WN3BKK06SoXxY5f3F3XJZfLU/sR9kGEvO3geh41yY6ERd8PyOfzeK6HFbcKWUgLfJ4gIPCDQnbT4qiYxQiCgEwm1x7lVChCpq7r5PN2GJ+CDuaUCEIIleE5vFZKSUs6V8gm3ZzOEQQBdSGp3XUdYrFYIZeL5/v4oeeNSohWmRBhmtZOKWlUBYuPENba1TRlMqT23hMR5pEI8nm2zF+IGDOaVNwqmer8w7vvxVu9is2taQ74zrdY9ejjbFy9hlxbmn3PPRvq6gplP/jXLQxsrKd/SBYtxqqHHqFhymRSRfb29NvvMv++B5j5v98umCuan55NPPTu0IRyE1PZCLeeSKNFTQXdaj+f/nABb911Dwdc/s0e9ZGUkrZMDpnLMue660nqBntedglCgG/bPPPr35Bdv56Zp56K5Xk8c/VveW3TWiQw3UrR77DDWP7w/byBEi4WAoeNn8CYPfZgjwu/QACkEorNvWHxEvx0hsHTdmPVXXdTO2MP9NZWUtOmVdze7Lz5NL//PkNPOZnFt99JYyzGmnfeZfL/+46yFQcSz86r1OedIkl6ns+1F17El/721x71UWf4gYoC2N23vfm5F2hduIhNGzcxcMxoxkyehDFoEDT1w57zFtaM6RCLKVOY55ccixGklMhcDvetd3jh1dfZ+5QT8cwYt//v/3LYD37YrQktZpoMHdiEaXQdjVNKiZvNqdwaMZPAdZESDKs8J2N74qMWLBzHIZfLUxd6Y3yUyNsO+bxNfRgHJQqr7fs+sZCHEHmHFLdVZRWVnTQPHSGlDD1APKx4rJDvIzJ7OI6LZcU6eJQQuY6GpgkVBVSZQPwgoLktQyoRxzINFR4d5SLqeT5BEKDrGo6jsrZGocG1CvhlxagKFjsZPg6ChRCClGXiPPsso047pTBgNz7xFDKRQJ86jXjMKNjuoMgGCSz+960EnsuI/WYRn1A+adYb111PfX094085sSJuw5Y33mbNiy8y/oxTWPP8i9ROmkBywoSCpqK4/Z3RLlhoW6mzfddF7yHhTkrJ/CUr0TWdTC7P8jtvZ3Mmx4FfvJBE3GLhk0+z8sXnmbLXviQOPIBffeZ03gNmocwhq4AYcOyEiby34ENiwH6HHcmEU06h+e23adz/APo31jF4QCPpnNIUxTXBk1f8hN322ZNXH3+S2qb+LF65nDN++ANSQ4eWbevGZ5/D1A3q99+vcKz1hZeY++RTjD7ySAbusyeB5+HbytW0c/4L3/c5/4CDuGEb84RE6Z3dLjQWEe787Hns/ZnPMOroI2m75376zZzJ5vfeI57JEgweTO2+++CZOpub22isrymb30NKqeJghCGTk4k4Atg0501m//Mm9v3Od8nl7bLtEAJSiQQD+zV0IOF1+6yuh2fbH1nIb98PyGazpFLJj05jkbepq63Z4ffuDM/3aU1naaxTbYm0KfF4vODhkc3miMdjGIZZRGBv99woN6e4rkc+r5KDRf2seBVS5V9xXUwzRme338jUEnmbKDdTdV1rNkcsJLkX3ysShiKX4N4IFBF2VsGi6hXyUUJKzFiM+IgRbHrpVfrP2geA2KiRrHj8SUaOGY1X34Dj2YXsg4EEmctR21DPorlzOfI734ZkkvSyZWTefY9BRx8FnSb/mZ8/D3/tOl7545/Z5+Ivddusxpm707jHVN773R/xPZfBJxzb4XPtalcRdBEYRjdNVj/3EsvfmsOEWfvTNHN6+0nP26rdhXoDSWs2g+24DDz+UzQ4Lptb2jDSWfwxE9hl6u7Yr71G21tv8al+g3h38zqagYHAbnqCZj9HixRcdNO/aW3LEbdUxsXkXvvgeR6bN26mf7+6glC04q57mb7nDNZnc/TfbQr7feHzFbmArlmyjMHjxnY4Vrf/fuy57z48dfl3mdTaysB99y4pVEgpybz7Lh9WcJ/uENl6ddm1y5uzcSNDx45jxFFHAGCMG8/6NatpaGrCOuYo0DS8V+egD2iicdQI9G60DhFxTZhmYQwM2HMmR8sAmcti68ZWxOQIUipis+t5ZcNFl3xWQ0cnhpvNdTAt7Uz4uDyxHnIl8o6DZZo4jqtIpaEWQNc1zJhBPu8Qj1OIJwHF4byLo5GKglkjit4ZxaeQhWvClPO0x6SIuBWE5NEolHcQuptKqSIPSymxOrk0u66HbaucK4lEvNcCxc6Oj57xsxNDouyLyZl7kGtuZvX9DyBtm+y8eRgtLdivvAbvvktdMoEVM4nHYqx6+GHu/fpl/PTgQ9i4em2BY5Gsr2fzG2+VXZz1wYNI53I884tf8dD3r+BP/3MeLFtWvnGaxpSLLsBuzaBr7XH7i+MkbP08kmjHEH34Ed65424Ahh64H/t+5cukly5hw3PKtTK3YgWv/uJq3rvxJj646d9b1dvYUMuE0cMYN3Ioo4YNZEC/egb3b6Q2lWBAUz1NjXUMO/wQ1s9+irqZe/CtKdNYDIxEQ1gmhxxyBCdffDGB41KTStDUWMfA/o0knDytrRk+/Pt1ZPMOIIibJnnX4eUnnmTF888zYvx4Ft51T/l+KsLUz57N2vnzSnSl4LCfX8mH77zL8z/9KRsefpSX/3gt9qpVhTKu5yPGjOPre+3N7Zd9k/TChRXdsxyintdQeWA6kDnzeT689Tb+dvEl7PfNr6tyQqNu+lSMdBsr5s9X40jTMPbdk0CD9COPM/dft27l4RNBhK52StXccVqp2XNP3r31duL5fJeLYBAEbGlN4xQFReoOQgg0w0A3zaIIizsPpGx3l/yoIYRQ6dyzNvkwO3M2b5PJ5kins7Rl89i2SxD45ByXTOiN4XheIciXH/6/oInwPNraMoBAD7WlUdTOYm2E0nqosVnsFRIEksBXAbgCKcnkbVoyORzXo7YTSVhKlYDMsmIYhlEVKrYBVVPIxwCJuEVDbQotn+O5K36C6broo4Yz47jjWPvsc0ws0jK8+edrGbHvvlgTJ7L2yaeYcMKxbHzjTfrvMoG5f/4bvptnt8suLQSUKgd/yxae/PkvGbHnDCafdqo66Dhkly4jOXEC5PMQj7PhlVdZ+dxLjDniMGp22xWQaEIrqfYtHkuRe2FX6uF5//o3G9esId/WxsFf/hLmwAEsu/c+nJzNhDNPK9QZ7UIiD7JV77zDvy/7Bmd96zssfP0NDrz4QpY+NZsYMOSE41n8h2sZuOsu3PC9/8eu+x/AfscdS2DqBAMHUTt+nNrLtLby/h+uZUNrGxP23ZsRJx4PqMlq1X33M+yTJ3DXN77FiT//KcvuuY/H77uf0/7fd2icOLHLft38yqvErQTJ6VM7HJdS4uXzCMNg8YOPEMRiOJs2ghBM/fQZ+MCaBx6mcfo0EoMHsfr+hxh+yom9mtgizYtAuZ1GgqEbesFIx2b+n65ll0+fDgMHFq4zdQNNCG74/IWc97drO9Tpb9hI/s23SB1yULdjq2SbfJ8NDz1Kfuae5B2ny7INtTX071dfcRIqKSVeLodmmDs8zHdEKEylEh8Rx8LFtm1qPwamEIhMCTbZXA4pBDXJRFFcC0kmZ5O3beVdFFfJFx3PJ/B9REjcjDw2oiBaViyGHuZAUQt+u3Yi0nA4YWbX9jweIEQ7B8MwdFqzeTRNbR5UrKCO2lff98nl8iSTCfJ5u0O+kd6iagqp4iNDLm+Ttx0MXWfyJw7j8RtvIJ5Js8u03XnyueeZ+JkzIcwIKqw42tix1CQsRs7cAzyP5fc/RO7dUcQHNNC2ZDlrXn4dr62FEcdtTdiMoDc2cuQvfsqH9z3AW3/9G6tXrAA0tObNjNtvFquWLaN/v0ZGHnowe3z9K6y48y7qd9sVtPJ27GIPh0p8uCed9WkWP/oEY486vHBs1Kc+yWM//SXjNm5E69+/ky+7KrPwgYc5+aILWfHKy2xa+CEL7n+IoRMnsvSZZxiwfh2pMcOxpk1h8PgJvPbOu5hWjIYRI3DXzGbGV79I87wPee+uOxk5aQpTL7+MlY8+3mEC6T9tKq1PPMXJv7oKgDGnnswXigKSdYV+++zNa9f8nr06CRaq/RqB7TDhU8cXjmWXL+f9P1/H5HPOJADMIUPQTIPU+Amk33qHmunTeje5SYkMNRVaOAlrCIQuyKxaxfJFixmWyVK8HHmBj6kbHHrC8WTffY9kUThyfUB/UocdwvqHH2fgCeXHVTkIXUevq2H5PXcz/LjjcdmauR8hk8uTysfLxrLYqm4h0GMxfNtB64JgSqd7dld3Kc+C0g3otol90p5S10lkgVPT17vr0u9HaQe6gmFooRtolF5dBYvSQ0+3fD5PzDSIRQnTpCTrOFiWRTJMhKi0ByoiZxRpUwgtTHuuyONSdUDBbCKlQAgZ5roRgOL7xGJmWFYSj8UwDaOEpsLHztuYsch9tA86cCdGVWPxMUPCipF/ZjZafQMbPvyQwNCpi8eZ/+67NAwdhp7PMe1rXyNhxWh76inkxk2k9tsHZ96HZJYsY9AJxxIbPYqlt93JgGm7kQoza7a9+wFv3/gPJp16Cv33nllxgKoFd9zNh6+/zmFfvogFT89m2v+cs12eO2huxl2yFGuP6RAELPz3raSGDWPIIQd1KLfiwYdIZ3JMPv0U7v72d5nxiUMZdaTiCDz9y6uZPHkXBh/+Cba88BL2+k3UHXogt37pK4wfM5qm0aMRmQz6+PFMPPlT7X2Qz/POXfcx7dQTWf/qqww84ADuv+ybvP3i/2fvrcPkKLP3709J+7j7TCaZuHtIQlwhgrs7u7jrLrDA4u7uEiAQBWLE3V0nGXdt766q94/q7umxJLDy7u9L7utKZqbk6arq7npOnXOf+17D3d98hSqKWDMyTvpciubMI2noYIxh2QAIcFB8PjRoRmJ1VVez4dnnGfDQQ8gmo65OqCgsu/chht18PZF5nf7QpNPWckEQqJr/C0WHD9P1yksQwtqVAWRRovDnRZhjYkg9yVbT33Ncms/HsTnzOaZqpIW5nbaExWQiNSnupFReQW87VLxepEBNv63XDv95MpoDTfvQ6uk2iH81YxGekfu977HOPfDg8XiJiYn6jwQWNXWN7M8vQvGr5GalkpYcR4Pdyb7DRXTPyyLCasbhdHPoWAkNdidJCTHEx0RxIL8YTdOwWc10zEzBZjXjcHrYc6iADhnJxETZKKmoweFy0zErFUkUOXC0BLPJgM1i5tCxEgRBwGQ0kJuVytGiMvJy0jGbjBw6WozZbKK0ogaf348sSWSnJ+HzKZSUV2EwyORmpRJlM6NpYAgEmw0OF2aTMSBG2PQQpIt2uTCZTJhMeou/y+XCfBLuxSfCqYzFKfxPwO31IXfKY8nbb3HNO28hBNKIwWfHipWrqVi4kMzp00maMplDT/4TOS2N+DOnEldcSnlhIQmpKeScfw4vDBvOjOuuo9PVV7Jr7lxG/PMf1K9aQ9niZaRMHHdSx5N37lnE5HXkl7fe4eja9f+5wEIQkbMyqf11EX6vj45TJ7Nn3kJ+uuhSeg8eTEpGOqWlpdiiouh75eUAnPXMU83GGHne2bgqazj8yRckdutKvd1OcnISY88+F++Orey123HW1sD6KjL79kYzyFizs8FsZsWcn5AbasnopWt4pHToQGJmFvu+/JouV/y+c04fNoT9c+biUhTMZhvWCBuSzULGpIlU79tP2e59lJdXkNGxI7VHDhKbkkLi6DEc+Opb0s48g5j4WOp37EQxylTt2kPt/oNkTJ6IKEuBEof+RBUkyra8+bV3Mwymj/fs2UNGZgYGWwRKwKCpaRsQ3G6Sstp2QP1XIAgCgtFIzjkzcc364bjbur3eZh0GJxw7MKn73Z5m5m5BqKqKP1CeO1lFxJaZsrYQJBD+EQTJzoRKfe14vLS3P4SkrP8TXABV1difX4zfr5CZmhgyFDt8rJTi8iqsFiNdcjPZuucwVrORzh0yqK5rwO320mB30LtrB4rLqtmfX0S/Hp3ILy6jpKIagywRFWGhqraeA/nFxMdEYpAN7DqQT3Z6Mv4o3UOka8fMgHiWxv7DhdgdLvr16ERxRTU983LITElgy55D9O3WEbvDRUFJBd07ZWN3utiy6yBD+nbFFihnCIKAQZZ12Xhjk0S41+vF79d9RsJN0P6kz9v/Npwib/6PQdM0zNnZpMfGMvuii1utTxo5HIOq4j2qm1t1vPM2PPX1FM+ZC+mpWMwWtv3jnwDMfOwxknI7sOmfz2FQFCoWLSF69Om4a6oBqFq7HsfO3a1eo2jBzzrHIoDEPr2Z+dQ/SM7JpvHw4f/EaSNHRyHFxxM7cQKJUyfTsGcvOVmZdE5PJ2/kCHLPO4fht/41FFQsvOMujs2ZA4DmcPDVdTey+OXXWfzWW9isVtTKSuKMBvyKSuLIYRysrmH7nJ8oW7+OsZdeiqu0HGNYe+KoMaPYv30nUcOHYi8uJj4hEaMg0ff+e7EEzN3aw6aPPsURRoQVEhMpPHgIW0Qk7ooKDFGROBscbH3vQ9yHjkBSCom9e4MA8b37s33nHjbMmUdBSSnLnn2eTd/8QPGBI1S6vSgDBuHt0Il9s35k23c/cSC/hL2HCymrqmPngWPUN56cmRvon62Fj/4dS2U5NY2NCPX1rbRI/IpKRq9eVOzae9Lj/hEodgcGnz80aUuiSHNHSg2H0/27JORFgwFRlttWfxQE5DAS8r8V/8qYwXQIJyowtHxJIRRU/qcIhqIokJYUh9PtobC0EkEQcLrdVFTX0qtLDqUVNdQ12LE7XHTOzSQxLoqctEQMBlnXa/EroWyM0+mhrKKGXl06UFlTj09RkUSR+Jgo8osqOHC0mKT4mFBVqbbBzuGCEiqq6wCBqEgbiqqx/0gRqqp3c8RGR4R+1jU6yExLIik+iqzUBGRZpsHuRNVUHG4vTrdOEjUEyi+KomC3O1AUFbPZFAoqVFUnjOpKof89RdX/aziVsfgfhNEgI9jtRKaktFk77XjRBSx65nkmdOuKYLGQdvZMGg4cpOS7H0gbfToJ2Tn6dhN17kLsgcPknHcWfqdLH0AUUBsaSBg2BH95ObXzFmDs1SMklJU+ZhTly5aTPGVSs9cdcsH5/PraG5zz/LPtdp/8WyCKRPfry87Pv8AnCtBob7XJuAfuC5UaajZv4bzH/85HDz1CtMFAymUX4T58GPvho3jyj2Hr1IGuo0fQu18/yMkiqU8v8PvZ+97HdLvpWvB6sVkjOOu1lwGISE2luKGR/reduDUXYOAlF/KP6TOZfOllDLxUN0uzxsbSUFvLwLtvb7atv7aW2rJakuKjqfjtN9x1jdiyOmKIiSMmI50OvfvgKyvDt38/kijiKSrGEx2DaeAgtrz6MnFHjnBo/wHSIyMRk5LR0lLA76X/dVef1LF26NGDqLR08ufOo+bgYWIHDWg2o2lokJqEMf/oSY33R9Fh9OlUbtqEEJuA0KUzcTFRGGSJ2vpGPF4fqqbh8Xl1O2zzSbLzNQ3F40E0tP5sBsWUmsh9/57J+F+d2JuOSy/naIFlJ1X+aUZs/n3ZjpOBqmmYzUb6de/IkcIy9h4qIDEumkaHi8LSSuoa7FTW1CNJIhXVdcRHR+BwefRSgsfLsZIKamobGdSnCyUV1dTbnRSWVtJgd1BaUQMIpKckUFZZg19R6JSdRnVtAwBx0RHk5aTrfAhRzzb0yMtm884DNDpdAVGtplbVCIuZ6tp6UhNj8QSEtAyyjNPjC5U+LCYjkiiEPEtEUcRsMunGd2HXEAQMgXZZURRPKJf+R3ky/5dxKrD4H4TT42Xsqy/zzdXX8sq0mVzz2stEdujQbJtuw4ex5d33qSksYtyD9xHVOY/I1BTWPPEkQmQkWaWlLProEzr07IkpIQ5kGVO6Lu6kVdZStGgJtkgbsWPHEjt1Mgc//5K8y/XAQrBYWgUVALmTJyKpKj/d9wAzXnjuP3b+q157E0dZGX0H9icvKYWa2jocR45gy23SiAjnL0R274bP52PqVZcjev0c/uFHkvLyiOrWleqt27F2zKFixy4UawTew4dIP2MKgiyjuvSApX7jRjLGnB4KlrTaWuzlpSd/wEYjD/+8gKV33sOyI/l0P2MylcUldB4xomkbp5PXrrme3Lwu2GKi8QwYhDu/gIyLLyIm0AYrBnrt1ZgofJ1yyZw5jcrlK/AVF2IbOJieAwYgDhhM0ng/qUlxeLw+EuOiqZr1DUp1NVKYi2xbEASBhOhoYocPYe2331IzaxbjO+QgxcWiampIpVCwWdFQUPKPIXU4vgvqH4EgCETk5mDrkM2BL77G3L1bwBVTxGQ04ldUVL9fFzFyODEHugdOOK4kIRoNaKoaKiG2fN3/JTSfzIJto78/B9+ytbvluuBZ/97z1zSNiqo6KmvqUBSV1KR46hodDOrdBavZSG2Dgwa7ky65GRw8WkJ+IURYLWSlJZGaFEffbh05kF9Eo91JbYOdAT06YbOYaEyJp6bejtlkJMJqoVeXDqEgyeHUiZ0Ol4f9R4owGgzkZCRjs5gwm410y8tm76FjupmYJGKz6C2jGakJNDpdbNmtZ1Sz0pKIjLBiNMgYZAlFUVEUPy6XF1mWsViapPyDCLavBitlRoMBn8+HKLZv8NbUmaL9/9IV9L+KU+TN/1FEet3kb9jIoHPPYt97H9Dz2qsRLK1rxzid7Pj2O3oHSgQA2z/4GGt0NHkzp7H2rXfoOm4stYcOkTVxAnW793Lgy6847YVnQ9v7iopwHCsiph2yXtn27cRnZWGIjQXg+7vv1bMWfxB7PvqUzjPORA50urQHxeFCcrsg/kTbOXju8qvo0ac30x59mHV33YslIoJef3uYkp8XYevambLvfiKqfy/eeeRRbv3rLSRcciF7nnmOtCGDef2BB5ly0cUMuPUv+oB+P4e//IaOl/9+b5Pvb7wZRRA4/603mi0/+ONcYtKSSRw8mL2ff8Hm35bTvVdv+v71pkAqvOVNTv+paRrFvy7CUVqGs66B2BkziYqLDnEPBEGgcdkK3E4HSWdOPe6xbfnkc5I7ZJM6YjilCxaSNHkSsiThUxS8fp/eQSLqKXZZlPDv3Ye9pIy4CWN/93U4WdTv2kVDYQlCv36IooDd6W623mQ0kJ6cEGpZPBF8LheiJCH9gZbYPwJVVXE4Xdis/xp5U1U1REn83UGAbuHtw2Ixo6mazpERm8ZRVDWk7yEIAV7GCUoowVKBoqh4vF7cHi+CIGA2m9BAN7kTmnQiLCYjHp8fn8+P2WTUvTb8fkxGA16vH5/fh8+ve24Q8PZQAj8Nsowl0AnicLpCx+X3KyHejNlo0L1vAuWToNy2JIrYXbqaq6aqCIF1JqMhcBz6+fl8fhwOJ0ajIaTcebIZoaC8t9FoaFcVNCjA1dY1/bOSN0+FWP+jaDSaSR09Go+qkX3GGXx/512tnkoce/djP3qMxmCJI4A+11xJ3rlngSzjcXso2rqN3KlTOPDiKyQM6NcsqChetIT8Bb8gxESz/fEn2zyWlD59QkEFQK8RI/n5wUf+8Ln9+N0sfGHOru1BsllOGFTo29m4//tvmfbowwDUeH2k9+6FX1Ex9+1DTHIK8QlxJGVnkW208Pjrr/Hz5VfyyY8/8vPfnuAYULJzR+j61u3YScbAAa1ep3zjJpa98DJzn2j7OuF0UlVdQ3bHTqx94+1mq/JmTiMx0AXR7dJLOPuWW6kvLUXxBDQdFAVB0OvawT794L+MSRPpfPll9LjkAmKKjqGt30DtmrV6v39lJYbICOyqxvq39dfUNC1kCBWEpmk0Hj1K6sABCB4PjdW1Ib5BUDFRDZgt+fwKPsWP1jkPt9VCwXc/4DtacML34Y8gumdPvPZGvD4/jhZBRfNzOcl69/8PxLt/ZeZomoi0ZuMEA46W3/nw5fo6DcXvxxtI7/sVBb9fV490udx4vV4UVQlxB4JiUeHjqaq+zOv14XA4A/9ceH1eREnEFmEhItKKbJAwGCRESdCDF1HAaNSFpCwmI1GBDIEk6e2mgC6YJopYTAb8iq6+aYuwEmGzIgrg9+uv6XZ7dHEsVcXn9SJLIuaAi26wO8RgkPH4/AiigMfrpdHpRhDAZJAxyiJmg0Sk1YxBEvG43TgcTpxOFx6PF4vV/IeUNIPcC39AtK319W9t8X4KpwKL/2n4/Arl1bXYIyMx2yKZe9e9rH7vg9B6W7cuKJJEkiiyup3JbvQdt9Jh2BCQZZK6d8OxfWdoXd2GjRxavhzJ7aZk0SJSwnQLjofOM6cx4uorWPPci/jLyn73eeV27ITFZDrxhn8AZZu34m2oo9FkxOX2YLOYaVi3gaTLL2br6+/g83qRgK8PHqQaKPO6aAR+2rWLaaeNoGbbNmoLCqkLty9vaEBTFD5+5lm++m4WuxYsoGrTFgC+u+Z6vr/uRqq372DB/Q+S16ED5fn5LPj8M2howFNY2PwAVZWSb7/H63JQVVBA4eyfqFq1Fp/bheLxogSkhlvetERJxJiYSMzI4cRPHIctNY2Sn+ZRs2ET5r69yZ1+BpFeFdc+XRTc7fXhcHnQNI0vr7+RNc++wMG9e9j25Tfs+342aeNH61bqASEtkywTfM5VNRV/wJQpbvAAUmZOY9/y5ZTMWwAnELf6I0gZOoTaVSvbLAJ4fX6cbg+SKLQ50baEaDAgiMIJt/tX0Gpi+RfHC3pS6GM3FUPUNoirQfGzYJYj6LERHoxqAR0Hg0HGIMvIkhzQlNAlsZVQ8OHBYQ9OvvpnxWAwYLaYiYy06R4fBhlJkv7w5Bn03DCZjFjNZv2YAyaFVqsFi8WCLMu66mbA4dRiMYdaaV0uN36/H5/fj0ESMQcCFFVRkUQBKRBYKYqiO6j6/YFz17MTFosZq9WM0WA4aZJt8L31KwoNDoeeQQl44AShB2pKmFy4ihIQoDuFUxyL/3koiord4aLrLbeSEBvNsbfebkbojM7rxJr332fQpZew6Z33Se2QQ/rEJsEpZJmIADchYeZ0Gg8cpGruAiyx0WgGAxmp6aQM7E/lsWMUFRSQfJLHZc3NxWm1UrF9J2kpKb/rnM687jreu+oaLnvtFcxh+hCfXnMd9cXFREZGcuVnn4DZ/LvGBUgZ0I/eZ51F9tQp1DtcUFKCr6oKZBkxIZ5qFLKAo+hup3uATuiup3/pkENkTg5xffuy6c23iUxLZfeCn0mIjeVgUSF33/pXXr/vAc574UW2fv8DJW+/jUUQGXHmGXg3beb0K67A1r8vtTt3U/XYY3xy0WWMmjmTGp8bCxKVtTWk5nYgZ8xoDCnJdF63nsxzz6Jw/kIKf/yJvhdegOrzo7h1Uy2k5m2E4b+bcnOIj44k/4fZVH75DZE+H5njRuGtrqJmUSFpE8bqwkmNjeRmZzL4lpuxvfcxe9au4ey39TKNhoaiaUiCFCKpqcGbp6YC+mQnCiI9L78UrbGRLW+9Q69LL8ZwAj7H74ElPR2t0Y4kim12gXi8Pipq6jDIMhFWC8YAObOtSU4QBN035H9EifJkEH4emqZPvAhCqBTQkoehqSqaKIIg4PL4UFQNA8EuEUASggOjqCoetweb1RwIKBR8Xh9+v4LBIGMyGwMiVs2PRdM0ZElC9WsBqf6TQ7BVUxAIlFMU3XUUMBplvF4vatCkUJQQ0NeLoojf7w9ZqhsMBhRFwePx4g0LZkVRxO/1ARqyQQ5Jbwf1KAyBZeHn0fJz0hbRtVVmCD2TZzIYw86rpWBaE/k2GGCcgo5THIv/hxBls1L16y8c3rML+76DxEdHk5nbAUNKCp2v1bsCCufMZf+qNTjtDjoO7I8xJpa8s2eExqhcvwmTpqJE2Nj18SckpKdjzc7GIskkTZl40nLNmqZRV1PHmtdfZ+qjD//uL9XRN99i1s+/cs8c3UOEkhK+vv9Bxt59JxXbdnB0xw48mkB2ly70HNAH84DWpYm2sOajT6hdt54pb71OvcNFdISVmkWLefpvfycPWA/kAXPD9hkHRAFTh52Gf/hp9D3nLFY88jeGTpnC8kWLiMnJxlvXwJKvv8IO9O7Zk+GXXcrb993PoH4DkAQR2Woha8hgOp4xBavZxOIXX8a+ajWby8p4cu0qtn/4MXi8lOfno5rNDLrofMpXr6f7pRc2C6C0QGdDwZoNpHbuiCXj+HoSwZtawazvSBt1OmJiIo3rN1BaWEj3C87n4DffovkVOl50gc6kP84kEU5E09sZ9TR2M60MVaVq/kISJoz7Q4FfWzj49bck9ehJXXw8Hm/bJTKDHDwWicgIK5E2S5vdEEERMtHQdk3834HmE72Gy+nC8gc5Fm2NrWpayAsjCN1ASwitFwUBv6KybtteIm1WVFWjY1YqLrcnIAgFVrOJugYHbq+PSKsZr89PbHQEkhgmtR/WttrWsfgV5bhGdkEZ+PDjVFUFTQO/X8FkMoQZjUFtXQNWi+5uqr9/arOMhbmZ0yhomp4J8Hl9gIDBaEBVdf6HFCjHiIIIAQEz3eujaYy2goqWgmTB91NR9PMUAwFacL2qqng8nlDAEiR5thw3+Hrhr/ln5Vicylj8P4QGh5PoceNpXLWanSXFpJcUs3rvHq667x6qVqwiYehgMqdPI2XkCEo3bCZr+FC8NXWU/bqIlIA6pdvrQYiLJaFbV6yJyaRPOxOhrJJd8+dTWV1Fj6uvPOFxrHvtLXL69SZ60CBUr/+E27cFuWcvppqayKhPnHMhDy5eiGSzEZOURLcZ05Cio8HvZ9eX3yDt2kN1RTV5w08j+bT2FRtPu+oK9gQnPE2/0XkNJs4aNoxP1q7lrN69SRYlOu8/gBofz6qiAhqAVcAkSUStqePAy6/y2+LFRGdlMf7eu/n0siuxxMaS17sPp11wAWu//w6vV+XG++4nc9rUwA1Qw1tfj6poNNhdjLntVuQ7b+fswE0md+xofn7+RXqMOJ3uF+reLPHdurU6fkEQkEwmsoYPBbQ2n7habi+KIplTp5I/fwEdLziPqKFDcNXqpRy3x8vRPXtIHtAfW14nBK3t589gR4gs6QGFfmMVW01wiCIJUyZRMPtHVFEi55yz2j22k4XP6SSqZzeUBjseb32r9aIgEBcdidVixu3x4nC6sQa0BzT0J/hgKUEQBPxuD7IgIrXRdvrvwPGedE+EE7WFCoIQqk+Hv/eiKOjvmyAghSZEkESJrrmZHDhaTHFFNQ6HC7fHi8VsIsJmwevTywiVNXUYDQZioyNDpQ04cQ/K8dYH5eIhWLbRAwUNUFUFWZaauZfqn1WdQSpJYqB0QGB/LVRq0CXK9VcPlnpMYaRLQTCEAupguSioxxIc73jfm7ZKOuFCZ6qqNdNUCd8v6KLa9Detfj+FU4HF/3NwuT2c9uBDjKqt4fMbridOlIm1RhLZpTO1e/YT27cXhthYsgL+G8aICIQdO0L7Z44cDsDeDz4Gp5OorExK1m8gb+Rw8pevbPd1y9dvpHjTZiprazht5HBqyqtY/sLL2ANiW78XtYcOIZp0WevqTVu58pEHkWw2APxuN5s/+YLUTh2wGExEWy2kdepEvdNBbdExCl7dSIPdTmxMFBU1tSSnpeOsKCciM5M+l1xERno6itp0I3OVlzPixefptnYji959lw/27cAJPDj8TH7+pgAr+hfhxVWrOK+qigFTpzJx3Hjm/zCbPtddgy05kQ5dumOxmDm6cwfDp05Bk0Rkm5UD33xPUlI8CePHYUyIR1U1HG43DreHKJslVH+PzMmhe//+oaDieBAEAdlkxNNoRxDFZvLf7W0vRthCT1SSIFBdW0OqptFxxGlYGh0cWr+BAV27oGlBjwU9wFA1NaDgGVZH5wQ3Slkm67xzcRw+zI53PqD3Ddec8JyOB6/LjVJRQURcHE6XG6fb0/zcAuJZoqBPLF6fHzVYqtH04MliaXKqlC1mTiYo+3fhZEMLVdVwuNwh3kHQdiP4ngm11ZjT0kLp9VYTWFhQEgxQ/IpCYWklbo8Xq2DUSa6ahtXjptThpHOHDCqq67FaTVTXNuiTt7GplPSvXB3dgyYYCIRlNTTd1yOoCBrMEni8ftD0Ekb4OejBQZOhmD6EGj4cgkCohBI8dkmSkCSpqbMmzLisvexRW0FhU/Cme5K0jbYzFafQNk4FFv8Pwq8oKFHRXDlnDivvf4Dt8+cxasJYYpOTWm2raRoF+w/SaP+OTmGTWtcrLwO3m/wvv4HERNImjqekpAS1rBwxRWdafHfXPeR26ICEQE19PQMuOJf+nToBEAkY1m/khttvxzHjLK6d82Oz190/fyFdxo1pN13ur6mhtqGRymefJyoqhv43XhtaZ83JYdh9d4Vt7Kf8p3lE9exBRLeudAzrUAnHti+/5tBX37B3+w6yi4vJmT4dURDw+PX0evywQVwwdCD9/vEUdVu38e4339AZMAL1gAKU7duHevEl5F18IR369ubAR5/QOSub3rfezIc33Ezpju0MWLqE0nkL+OK1l7ngr7fiUVU0lwsh0Bt/4IfZ9DnnrFY37di438dLMFgt+J0uRPn4xlqg3xzLy8rJKSlBSE8n2hYBAjiKS9i7ZxfT3nit1ZOapmlINE1iv3cS9jTa2bphA40eF8Nv/evv2jccff9yIw2r1uD27iV26FA8Xl+Ia2E1mxBEEYMs4fH6qG2wB4h0Kn5Bwef34/X5MRiUUAuiFuSJ/AdE3Fp3aRAg7qk4XB7QNF3JUWoqLyiKgsfnx+32YDAYsFpMgZq8GKrN+/x+dn37A12uvhKrxYypjfbGln/LInTKSsXT0Ei3jpmIgkBtdS2bv/ySfpdeQqLFQqTZiM1sQtU04iIsmI2GUAD2rwZdelYrkE3R9AlXDbBPJalJdMrvV3B6vDrXI9Ba6g/wPSRJbEZSbcpWhAdQTZ0+wSAivLsjnFgasBvTx9QIiF+JrTQr9G20ZsuDZmZtn6sQCPggWCo8hfZxKrD4fxQa4HC6Gfz44ygHD7LlyWdIGT+W9KEtygR+P36DRFLXPL6/6S/k9e7NsWMF9Bg4CIejEUd5Od0GDQRVpbyinN0PPUKvoUP48euvGDxuAq4GO8MfvJeKXxaz+JXXOTugTgmw+ptvsQEdU9NCyxwlJdjS0oiPiWXP17PofmXbPhv97r6TD6fNZMKtt5I5YSxlv60kpX8fiIpqvbEsk3zOzHavxcEf57F70c+kDRhEp6uvoOOF51Mwd75+kwMiA5kQgEPzFyJ164ZNlnnxskt557zzqQTGCkaqNS81wLWPPsJL11xNaXEpfQcPIvaqKwBIzsrCZDbh9fmpLjjGHS++xNY1axl2/rn6eVssbP3gI3LyOrHr48/oe9P1uKuraTiUj7+hHlNC2wFRexBEEURRJ/OFPam1ua0gMODyS1j/zgcMues2Kg8exLR6LYs/+YwxF57f7j7HG/NE2PrZ51zx90dxqAqLH3+SAdPOJLZfnz80VtSI01h46x2M1jQsvXphD1hcx0ZFoISeVDUEdEJibYM95Fzp9+vrIwIeIaLBgLfRjvRv7jwKPWFrzf09/H4Fe20d27/4moED+jN/8WJEn4+RD9wXCDwUvAcOEuXx4Ha7qSsvJ65TByRZxiBKOmlRNtC9W1csNqveJulyIyJgspgwSCJqoB1YEkVkSdLbMh1O4iKtrHnrTRYePcrhA/sZNWUK46+9GltqSsi5Nhja+90GNL8PJLFNo7Z2zvokttG9azTQHXTlJndQRVFpbHRgtpgQjHKTdLbSJPcNhN5fn8+PJEuhcUVRCNOJaApC2jp8PQMjhIKOps4ZBZ0PK+DzK7qGRoCsLNJUQjuZK6Gqyh8Kwv9sOEXe/D8Ai8nIc2efxcuzvkUIqGse+O4HFs2ejcPl5q/PP4MltwM1S5fzy8cfM2TqZFwNDaQPO4243r3Y8cVXyD4fETkdyBo9kg3vvkfuaafhKS1l78o15OZ1xGs20/WsGc2eAn1+hWkjT+cfM89mYCDDcODzL+h8/nlgNPLL4/+g14jhpI0d0+Zxr7jnQSKSElgwZx4Nfg91wM233UbfwESo+Xxo1TU4RIHIpNbZmCBUu53nZ5yF4vEy5IxpVOcfpt7j5fL330HcvYfGQ4exJyRiqanCm5pC2rChNCxeQklVDYZjBSz59VcUo4lP66p5cNx4ypcsZsTlV9BQWU720GEkh3XZKKpKg91F6c8/s+SlFxl25hn8Om8+yZFRXPPrQr67/W46ZmSSMbgfiafrzqwb33yHmLhY8lpO8MWlkN6+D4mmaRRv2kr93n1UlpXia2wkOi2FnqNGY+3etc3ta7dtY+MnnzPo0kto3LWLqIgoYs7RybtfXH4ll372Sbuv93vw81PP0m/s6SQPbRJV2/fRZ3Q+axpiTMwfGlNVFA58+DGxZ59DQ0DGPT05AVmW8Pr8WC1mPB4v1XUNuDxeIqwWEmKjqKypx2ox6VbdkoQkCPg9HiSDEVE+OWGtEyFImgyfDP1+Pw1HjrH5tTcwRkfSa/AgEmZM07cvr8BVUYmkabgqq7BkZmLuomf7qn5dQkJLE0C/H8+W7RgH9devhari8ys6R8LrQ5IlaletInr4cL2coGlYI2x4fT7uHDceEXjggQfImHYG0DZpEcDncHLkl1/pcvbMNrdruc/xyJtygEwbzDI0ZQ6aj1FvdyJoGpIohNxDlUB7pjFU5hNCHSNWm1UXvAqkRNRA6SiYMdA0DUlqm3Dq8XhD3I6WpQ5VVfH6/AjojqfiCYL1IFRVxev16fbrLbJ74VmPtgicp8ibp/D/LFweL1f+7TGObdiE6vXgdDgpzj/KTZ99gj8Q4SuqSvzY0QyurUWoa6DXDTeE9u99yUWh3yt+W0F6YjIJPXtAzx6kTxgf6J1X0ESpWaJQEkVeefAhjsybh6Zp7HjvI8w+L7s+/5KeV1/JpEcfZvHDj5HQOQ9joK10x1ffYDNbyJ1+BsMfvo+NL7/KQyuWcPVpI9gHRNsdofEFg4GK9etJGjnyuOcvRkQw86qrKDx6lO69e1Lo83CsuhoNqD90GDE6Em9NNZljR0NMDNTUULhlO6mDBnBo5y6GXHQRtTXVzMpIJzI1lTuWLOZ0WWbwo4+w/eXXSD59RKikIwRqrZsX/UL/SZP4Zd58ktLSmXzdtRycM48z7riVVV9+RXRRKYmB46uvqSQ1NiZ0vDU7dzHvjbc4fewYCkpKMJvN+P1+8Hiorq7F53Zx9vPPsP+b72l0NLLypzn4XG5mXHc1uSNHcnTZUna8+y59Bg1Elg3knD0TIXCDju3blw5HC6k7nI+/vp6GmBjW3H0vQ2ZOp7C6qtl1O7LgZ/auX8+gMWNIamFPfyLYLOZmQQVA14vOo37FKqLD251/BwRRJGPCOOw7diJ27IgGKJqGWZIQ3G4ECNXUrWYTCbFRSJKE0WCg0e6kpq6RCKuZuOgonbjr9yMcx+chWLM/6adPLejpoeH1+Vj06GOYFR/Lt2zk7vvuwxfmMiqkJFOyfDnZo04ntk+vZsOYI6ythnYdOIgYHRnaX5L0ydFkNIBNz8QY4uOwRkXg9flxe300ON0c+uknzhwzjslP/I3Shb+ESkih42i6ugCIZhOSKGMPEGD1rtX2OyfCl7W+HvqPtngHQXVyDV05s6HRQaStiaytqioG2YAoSjrhU9MwGo04nS78Pn9osg4eQXgJRFGbWlpbQmpRIgmdfSAwMZuMTToVfj8E23TbkPcO/z0YyIQvd7jcaJoWypQpioog0Cbx88+GU4HF/xFEdO2KJcJKfHQUcx/5O0uWL6PvpInEDh2k6xWoehq549kzadi8Gfv2XUT0aS2ItezDj+g+fCjhTY77vplF7jkz0TT9JiIKQSKTQO6USdSXVfDt9Tcy+YYbWPvcSxh6dAvZvPe7/CLWfPkto++9E4DeF13Awfc/YvEDD1Odn09MUiKapnHN6LE0OOwc2L8f25JlJI0bQ/E3szCLEoc//pTi0lLsLhd9zppJ+tjRrW6GJlsE/W69FUEQ6DxqFOnl5QhOF1KEjZgJ46n8/EuIiaFs5WoajuST1LMbcWNG0bNHN1Z/8DG5iYl8/MFHzJg5nb+ceSZfffgBl2oKRctX8Ms3XzN66hRyR44mbsRQKjZtokOHTuxeMJ99wHV/f4SkXr14Z/KZJHXI4VhhIYc3buJ0t4sul1zE+IcfZvdHnxBU7Njx41wuD2hJ5ARPwOtFtdsR4+JQSktZ8fzL9J02FWtyEt1OH0lE5zydANfQSO7Z59D5El1ufNtHn7HiqafJ6dgJD5Dary95M6dRvmgpR/fupvd559DF5UaKjmZkt+4c/uBDOl5yMcgyxZu3cMZjf6Nm1y6WP/sCo/56E1hbT3pt4djhQ7QK98xm6t1uHN/PJu0PdIsIgoAlMwv3kQIQwGwwMv+Bh3EUHuPMm/9C0rjRocxBlNUSkvnWW0/1DFqj04UGRFotaB4voqKgCEKgnt/kbqoEnkJNJqPuN9FGDb7lsQWDGo/Px9FlvxERG8vp115N9twFqLKMLTGZ6iVLiR+nS6DnXdB2CaqmrJzyz74kpVNHNLcLc1QMxb8tJ2VgP2SHA0kQ8Su6pLXPIGMOCNeZ5CYVSqNBpqGoGLmqihH33UOj040bdInr8CBA03RNzyBXVNOwBbIGDQ4XZpMBQ4usjsfrx+PzI4kCRoOEJoDiV3F7fc2IvWajEVsbbrI+nx+3x4s/IL6mAUa5qeSghXgYwZJFcOKXAqUtPwaDIcDhEMJIlUJYxqC9N6rp/WrrPQz/Ga5Bgb9p3+D73FbXR3iLqsloaFZ2CXJBTvEwTgUW/6fQ6HAhyzIj772byX97mL1z5/Px9LO4Z/5POllKVRAQiBo4gJXPvMSoNgKLM++9h31ffkHBgoVILjcpUyejiGLg6VFFVTSMYeWQwkWL6dyvN8Ub1/PKLbcwY9Jk+jz6YGh9fOfOHNm7h8zZP9HxrBmsePcDBp85haxzZrLornvISk6ibPYclv22lMnnXkCna67Cv24NAClnTsVbVEzsuDEYf1vOBc89x3WbN5HatRvRvXrQa/o0IgNkUr/iwyCKWC1mHC4P5oR4PNu2EzNxPEcWLcGiCWz77geUmiqSRAPGJF3Ua8fS5Wye8xO+AYPIy0hn5S+/cKi6GhF4+aOP0YB8oHHBQvoUl1H1wXv0jotn1aZNVKkKl3XvweLH/0Hfbt1JTk3GWVXFFXfdQWy/vmg2WyiTEB/mi+JS22jRNRoR4+L0G1pKMiPuvj30hBQR2FdTVdA0RIMcuvH1vao5h6X4p7nUHDtG1pTJGBKT2PPhJ/S8/BJMmZkMuPF6Pr73IXofOUYjMPB8ncwb17MnI7OyWP7iK4x6+IETfs52ffI5A4YPb3Nd1vQz2fLBxwjz5pN65hnNV1ZVQUJCq31Uu51dn36JNS6WrMED8btdGASRbS+8wPCB/fGOH0fSuNH6toEn8nCRrOBEq2ka1XUC9XYnJevWU7l1Gx6fl8aCAs56641Qx4AgCJgMMlazCYfLjd3pIsJqPinGv6aB3emm6uBheg7sh9/tQo2OJCI3h5qlyzF1yj3hGFmBMgSAd/1G5AF9ydFU5IH9Q8uD3zBt89bQMr+iIBPQzqiqonb5avre9tcQX0KOjCQykA1pprURPPAAFDRsZhP+QGnA4fKEzMqCn6voCL1V1e5yI4l6J44oirouRTDNLzeVG1Q1yDlRaXS6sJpMWI1yKIPgDNgONGVD9Ild7wTRw48gETRoFCYIUijoQBBOaHn/e8v64d0gghDQkFFUFL+iC5QJx+c0GVqQg8MDjPZIoH8WnAos/g9B0zRq6xvQND3I6DBpIpdnprPw0ceZcNdtEBERyF6o9J55Bmufe4Fh99zVbAxbz+5kjR2DOT2T+S+8wPiMLBqrqtj2/odUlZQw5bG/h14LIDkhjnmff4FDBBuQ3Ldvq+O6+qP3eWzYcGYeOsLRA/s4bWA/Zn3wEeb4eD5c+DPehT9z9qgx9Ln1JhqdHmoa7dR98RXmiEi2/7acTgP6cXDXblKA9wD27eUhr4/fqmtZsXQJ1z30EI4GB/Y33qb3vXdgctmRi0oxWa1QWk71wUMMuvkGMgGKS3EXFWEe2A+AoReeR6SqsHv+QnZXVXLuFZdz4cSJLH70UXwNjfx2+BAZQCXgbawnMT2Tn1cuZ9josfz421IsUZGkiyJbtu8ke/RIesYnULhzF0pkJAlhfiNRPXuw45VXSc7pwIQbrmv3/dM0DX9AYMggy81uT4IoIsoSiteHbGn9VAWQPmMa9Tt2U/D9jxSVlJKdls6uT74gddQIHEcLuPGHbzj0wcckm036RB+AGBXFoEsvZsu77xEREYnH4yZr4gSi0tJavcbRw0c48/FH2zwHgP7XXEnhvPnsfPs9ul9yIVUbt3Bg40Y8wOG9e7n2lRd1jZIADs+ZR8+rL0eVDZQtX4nHbMEoiRSUleFyNHJuoKMF9Nq40dAkVBS6NoG/LWYzPr/KmlmzuOilF5CiIqnatw+LuW0iZ6TNQr3didPuxBZpa3ci0TRNlxdvdLDuzbcYkNeR5IkTqPv5VwyxMTTu2IWclqpzAiqrEBNbB1BtwRggmMrtdLDIYcGOLOrv+bFNm/n63ge4a9ZXumdH8Ck6bL9m10ZfoG+jqhgjI0HQRcfkdkpFgiBgNhrwKypunxebxYzB0DyzEc4tCGYR3B4fRkkKGYuFjl2WAwqaUkAnQj/fYKtp+HYGgxzgbeiqnyLi7woqTpQpaLltcPPwz1SohTXQXaKEEUjDhw9/rfCyzp85WwGnAov/cwh+Z/yKQl2DndgePZjQowcLn/4nh44do3PHjkx69CFsnTrScfhwqtatJ2HokGZjJI7Xa+QXvv8uj582kvsWzkOzWij7ZbFu7R340m3+6BOqDxxkykXnc2zlGhZs38HRw0dIcTpbpdQH9O7Dlo0bGDJ5Ii/d8wAbnXYSgVpgCLBl+TKG8TcMBomkSZOZ+5dbMIoCrxzYxyPVlThMZqxAIuAEVh85hPHIIa67/Q72LF+BJT6Rzj274Tx0GFNKMqUH9nFo3Xq6Dz+NpEAQAUB6KvW//QYREah+P2JCHEe2bKHbmDEM7NgRtbqCmEgbo6ZNw2yzsfG++zACJcChI0cY1TGPh5cu5otLr2DK4MGI8XF4UtI4tGsnI9PT2b56NT67g0NbtyDEJ3LW888AYO2YS3rXrsRPmtjm+zbvqX8y5f578CtK0222jUKybLZgLy9HaBCJSG5bgD26dw+ie/cgGyiYPYe+Z09nzYsvM+ymGzjw0Sck9ehG9NAhVK3fxIGvvqbzRRdStX4DhTt30/96PeipO3gQyWLF4/U1a33UNI3svI66Z8hxVFozzzyDj4cNJy4xgZShQ0geOwqA8TU1bP7oUzJHDCdpYP+QD4toNiNoGimjRuJTFFxuD/3792XX7t3NbtJBmWWvz9+qJVMNlCl8a1Zz8YvPoUgSsiCQ1KNHu8cpCAKRVgs+ry/UfdNyUlAUFbvTiaJqHJk/n+FTJuEsLQHA1CWPmGOFeCMjSZ80gT2vvoGjsIi1mzdzYQuH27agqioi4HI6acO7GKfTSfCb5PK4saoquz/9jPQuXZDj40PHWr1sOc6yMry/LsKnqURERNJYW0daG463PkcYj+kEE6DZKCPLx++CCC8TeHx+IiytW8xlWQ75kQTJly0R5FBYLBZcLheiKAZURE8uUPg9GYuWraZtnUtwzGCAoxv1KYFyh94uHNTqCAYowbbbPztOBRb/h+FXFKpqGzCbjAy5807GuF28e/e9NNxxF+e+9ALxQweR/813+pN1G09MRStWMmLKFLQAOSltsq7e6VcV/A4nkstFakYmnzz9LJ27dqMKiEpObLNOf+Y7b3L4w0/56r13qAfSgaFduqIKEhoqw88/j/zZc6grK6d0/16Gn3c2udPO4Ny6OsZNPZNE4B+334rNbKO+vg5Kyrjup9nse/klPl66BLdfIdJqZt0TTxKZ1xmTJDH0mqs5tnEzef36o/r9HP3ia+ToKPau38CYoUNQ/UYOLl/N6Ntvp3HzFsz2Bmx5ndn/+tsc3LKFTpMmUAYcC5zDYeCev96I0WIhMikRGh1s27CBOcB4oKi+jn5jR3PHP5/ltunTGfmXm0Lnv+COu+jYfwDtKVkkJySy6cVX6XPbX5oWtrjvCYKAJoDRZsMYYeNkkHXWdDRNY/gjD7H6wUcZdOO1mAPeMYlDBmKJsnH0nffIuuQiEoY0tSpHd+qE1+enpr6R6EgblkBdHqDTlEnUrF1P3Kjjk2pHzJiONy4WKb2pHZm4OAbcfgurX36N1+++i55du3DGQw+Fzk+SxIAehUBWz96YwkpIQVgtJlxhIlohaBrG2lpiU5KRYmLQ3J62GX5hEARBnxxUBb/ThcFm1RPZYVyMRocLjh6lfM06EmKiqG90EBsVTcOBg0R1zqNm2y4KV69CBjqeeQamzp0QTlIa3+P1YAGUdlLn4RLsitfL0TffJTkqklHjxlP00xyS0zMpLS0mzuMjsk9v3E4XUTYbstWMWlmFv6AAOaBpgtGI5nIh/s40/ckEFaHjVdU2qwCCQMhFFdDdjfWZOFTuUJQmASxJknA6XZhMRgzHFYhrKqUESz7tZX/+CMIDDTEsGFJVQZca9+ny6gg0kxY/lbE4hf/T0DQtdBN2iAIXvvwylfPm8ejpY7nzpZeIzs7m8Oyf6HjeOa323fX1txATi4CgpyQDsrkGUUKMsNHrpusxiBL9br0ZVdPInDufxa+/iVJbT69bbmo1XmSnXKqB3cBY4LzXX8FZUUHRqlVkTW56kld8Pq4YNYZRH3/Mdd/P4p3bbiOtUydWfTuLqc8+jfLtD+TceC237tnN/oMHuHbsOIaIRnpMnUxCTDwdpk7BL0koooiyZRt2l4com5mogf2I794dk9FIY0KSTj7NnoFFEvEkJuLfuZPSAwfJPHMqm35bRl1FFRf07guSjOZzs3bXLpa8/CqW5GQm33cPd110CbsAFdgBlHz4EdMmT+aZm27iwI4d/PbBR/QbPpxDa9ejJSbSUFfPd3ffy7nPP9vq2uzasJ5Yg0w/QaB+1Spcfo20MaNQaer3l0TdJEwQRYQWBmXHgyAIiLLM8McfZdnzLzHuwfuahADsDhIHDeLonPkk9uiGrVfPZk9gHq+P8qoaIiOsxEZFIgoCYlQ0W+bNI3LrNioqq+jQqwc9Z05vJYZmjoikw5C25deH334L1cVFjDjvHGyZmc2OFfQnXHNKEr59e1udS5OiY+u4oW7bNjJmTNONutowNGsPosGAKMsc/GkeGcOHYYqLxa+o7P3uB5zV1WT37EHelInU5R8lYfRIUFWU+nqqjhwhedwofvv2W4ZMnRw6/si043u8BFuNDYEAxNhWW6yqYjCYQin51W+9Q49JE+l3ww2oHi+ZeaMByFhUizR6kK5Zs249Uq/eCJKIpXNXGjZtJTonC8VsAUWloaYaoaHhpK/L74XZaMTl8iBHtP58Bp1Vg9yK4OqgO2uTrLYQUpH1eLy63sRx+C9N2hZiaPLXtNadI83LFn9s4g8nfoYfUyizoYKq+nF7/YBGfOx/xsX5fx2nAos/EVRVw+XxEj1pMnfMmMGK556nuqqS4aNHceDHOXSeOb3Z9pNee5l5d93TzN0w1Ksd8AVQNJVgm3vnM6agVdXw/nvvcIUs0PemG5uNlzhyOIXA6cBt8+ZStGMXD991Fx9++HHTE2JxMXsW/IwAXPHCc6h1dWQOGoitYy49ystY8/xLmIxmcmJiuOjTj1jz1jt0/mkuKenpDBw/lmMb1vPx1KnMuOwyahsaqSkoIGfamfj8CvHdu6OoGpisRNksqIfzKdu8Cb/TSUxyMnVeP6rNSuG2HSTn5JA3cRwV+/Yy6qYbWP3+hzx4480s/Pln0rIymXXr7VzbdwC+tBReXTAfAagD3vv5Z+687hoqKyu5+OEHWfTw3zi2cyc3Ll8KQPS8Bcy59wGm3ngdcm4T0e+M227hnutvZMP4yQwa2J+e3Xux5s13qKkoZ/KjD+ltrhq6uJHRoKtL/t7gwmxm5A3XUvjt92RccC7VC35GTUoiqV8fcvv3xZefz65X3qCouIjsnj2ISkzE3LsPDYpKbb0dWZIxGw0Ur1yNSxAYf/stABz8cQ7fPvJ3jAYJW2Q0KH6cDY1YbJbjdpmMu+46nGUlbR8vENuzO8bVqyhfsJDkqVNC6yQxqKTYnCRXs2kTfpMpRPZT/SfvYyMIuhdH/vYddJg6iSOLl2EvLSVn0ABienQPXee6tetIABBFpNhYEmJjcTQ0MjCnQ7PxvG4XDes3YBYEGurqMBotGM0mPB4XstEEXh8cO4a9ogJL/lG8kkzEhk1olVWoZiNyZAT4FfYvW062x8uOX3/h3cJj/Hj1FXhXr8XZ2EhsXkcA3FYbtoCwnBYTi5SpBzXGtFTcx44Rl5aKFHAgjvMrFM6dS+xJiK6F3ojfwYm0mI3UNTp0ommLtkuz2YTD4WySaA+YfYW3/IYHCbrWhJ7JMBqNYeTI5lAUXVK8qcsk3Na+OW+iZTYhPADRNA2fXwmJZ7V1bdofQ8Ov6HoeLo+PYHvrnxWnBLL+xDAZDdRt3Miy997FFhHJmddfR+rY0dDQwILHHkc0m0nIyKLntVee1HiSIOKtq2fVg4+wf+cublmzvNkXcM59DzJ/xXLswCjAlJPD0qNHuXjiBCITk7GZLbjcDjoNGMja2T8x6aILqNu0HYfPQdoF52OKj0epr2fuI3+n04D+uAWRhNoaVq/fgP9YASndunAsPx8pJpZrZn2NVlrKkc+/osHj42BlBQNGjsDl9WHYt5+C4iKUmCgG9+xNVWMjaXkd2bdjF1UFBfQ49xw8u3ZRU1nB/p276NG9J0cOHaZDty54XC6G/f1hFv/zWQp37URJTqF++3Z2AY9dew1PvP8BAnoWY2SnPEoOHaRzXAJKdiYXvPm6fiG8Xsp37yU5oFK58vU3+e6LL/jLVVfR+eorIdDCp2kaXqX15Kh6fUiCblbWnjNle9A0DXtBIeVz5hI3fHhIKTM4Rv7sOZRu2Uavqy7FYjSSv3wVls5d8ERHU3/4MOVbt7Fjyybu++6b47+Q231S7qd7P/2cDqNGYs7Obneb/M+/JGFgfyK7NomC+f3+ZmZa2O3snfU93QIqqapfQVMVpJMsSQSx6a136TliOKvmzGP8Q/e1Wu88VoA1M6OZ9KOmaWy46x5yhwxDjbARER2NUlRIVDuKpy3RuGIlkafrZSXvrj0YU5L07hlVxbFuPS5Rwl1RQXRsDJEjR4Dfj3frjpCYln/TllBHiX3VaiJGhHXsVFahNDYgBYJYTdPwu9zIZlPocf54hFW/qrRpZQ86sVSW5Fb7uD1e3G4PUZER+oQNof8aG+269ojRiCgKBNt420IwSHC53DqZtAUBNxgQBAW6RDEootW+zkVb4wddTesdLhBAVVSsJiPWAAE1qK6qjx806GsaPCiap6EhiaJukCfpx2EyWf6UNZFTGYs/MTxeH5H9B3D5F5+TP+t7Pnv2OTouWkyK1UJ5YQk5fXqRkBjPng8+ovjAQUZcehmWXq0dOYNQNBVjTDTGwYNJ06BszjxSZ0wjKK374orlTAHGDBuGx+nm8e1b6QNEJ6cy4PomIytN00hctYoDX39DzlVX8tN1N5C65DdMiYmMeeh+TIpCw4ZNmJMS2FdTS4LZjLNXT1K6diMmM4chj9wPosg3TzxJXmIiSkQUY594HPve/XQe1BfHmnWou/ZQcPgg8oQxdM7KwtPQQKLHTb+ZMxHNRtYtWMDiNavxAz9UlBMBxBUdpQF4Y/xE7EAF8PnI0ylLTmbVr7+yePZsRCACWAt0PnSQxcAvNVV4a6o4bdESMieMA6MxFFQANNobkIEtK1fx6kcf8dqK31AlCX8bQQWAaDSgen0oThcGi7mZtsjJwJqZQcrkiRxdv4nYfn2a7ddh0nhcDY0YKqtoVBTyLrmQmk1b+Oiuu5g5fTrDJ45jyoP3nPhFTtJSvdvll3Lki6/IPU5g0eHC8ymYt6BZYBE+Gfmqq/nlyaeZ8rdHQsv8bvfvDioASg4fovOQwW0GFQDW7KxWywRBoOP0mVSuWkO3h+8FoGGhvX1l1RbLDeYm2qbiV0K/qzU17Fn4C7bERLrdcjPa1u36ClnG63ISPLtgGyqAseU5x8bg2n+AiEBgIQiCXiYKECVPhOPblLVNfjSbdHKt0+XGbDKGsgHB7IGuYhnMQASFpYRQoNFyPIvFjNPpwuPxYjIZw9bRKjPQpH7ZdsDU1oO0IAjYXW5UVSUuOkIX9goSQtEDF1mWAkGIv5mTLhAIOkSibObQ8j/rA3sQpwKLPzn8ikJ1XSNpM6Zz62UXc9vosTQC77z2OoZueWA0Im/fw9rZP7F38WL6BwILKVAnbWnCrWoqo665gg+WLmbeP5/n2jOngiiy7etZpAH7gLv/9ggbvv2Byfn59Jw0mYQ+fVvJBg+44za+uuIavAsWcvXcH8DlZtPnX/PB7XcRbbORMmwIG1euJK9rd/bs34ervp6MQQMZcrtuhqU1NtKlbz/6XnMlv955D4qqUrZrB4nVlRiMRmydOzFp6kTW/7qEIVdfgX/XXrLPPgtPTR3lK1ZwtKaaKvRbpxXdoMyEXu4oQzdhA7h51iwuSc+iK7C5uoadQJfAunXARYGfe4CnHn2U6EcfJckWwZ2Lf0EtKuLbJ5+mrq6OF9auBmDQN9+z6B9P0mnIMDImjm1WejJIEhq6zDKyBIqKX/EjqmKYNPKJIQoCtk6diNy7n8Y9+4jqERYsWq1YbVbMQwaj7tlP/fqNxA0ZxCNzZ5/0+L8XcT17Uv7TPJImjkOwtNEbIcvNtFOg+aSx+o23GXnJZaEWVlVREGUZ8Q/YposRkUT17/u797MN6k/pvLmhVHm904l07CjasQJkARx2OwazCUky4q2pxnj0KJIk43W5UMrLMA8eCIDRZASzGVVV+eDam9hZXsIra1YhCAK1NdUEqawOtJAXiMvuCPmBuN1umoUWskxjTU1oWyCge3FyQagoihjamKAFjq/xYLOYaHS6sTvdQYEMCAQSCAI+nx9RNAZKIUIo8GjyBWk+ttlswt7oADRMwXJXG9C9QdruOgkivB1U0zQaA740cVEReoAe1karBIzSdF6Iqp8DTVdPF0zzYw5zjA3/+WfFqcDiFPQvl8OFLElEoz9xG9KTQ+2ECX26c828HwH9CyWKot5TLwQ1F8LDC/0ZZ/I5Z/Pl8y+gOp0cWLaCvd/NIhY4BFw4eSopwIUDBtHvL9e3mbJUNZWLX3yGTd/8gBQTixapMOSeOzh8819JSYinx5RJHNi2je6nj8BgkDmwfAVdMjNC+6944kmMAiy5+14Uux2jLJN3wflYIm2UffUtlbt3kRAfR0KETVe9dDrA76duxy6iEDBJMh50/YosoBjwAQlADdADGJmZzarCY/xWXIADPQAZDUQDR4GOwBZAClzT4Db7HXZ+uPkWdm7dQhlw5aWXhI674wXnkKudTe2+fboPQyBrEXwCExCQRPCpKorLrVuqy5JurHScG27o3Ql7mko/YwpFc+YS2b1r043W5UL2eNBqa7F274J99VrUgkLErMzjDfsvIaZPL5SMNN6ceCZ/Wb6oTYepo/v2kjJ2dCvORu2WHWgaRA9oygBpitpcffIE8O/Ywffvf8jA4SOI+IPGZbLRgNfpombdOpx2F67aWoy9eyEkxiHHxBCevwnv5zED7rXr9PekrAx/TTViShL2HbsZOqAvsXU5TZNVWNCVHNWkA2KNbBrRaGodmCWmpbVadjLQP2+cuKbQBiRJIjrCprdPh2VHFL8fh9uDx6uTMoPljaaJvvXLBbMSFqsFt9uNLMvNOj+ae3RAW0FTeEtqMLBQNQ2H24soCkRYTM0CmqCYWngWRRCEEG+kiROiK8Ea5NZ8pz9zcHEqsDiFEOrtTu6cM5fV//gHRRs3kzFlUrP1giBgEKVmXzRDUOhG0/1EREGvLc7/+ltyBw7mjennMvL0kVz48QdcEhXF0utv5OFduxgEkJLcLjtbA9T4eAS3i/2ffM66Rb8y9YbruPjN1zn44Ucc3rQFWdUo3rmLAeefS9dJk9n9/Q/sePNtBp9xBt0nTcJx8DA5N17Lkc++BPSUa/Hy1RzLzyelew/KVq7lQEE+BgREVMQVKzDV1bPww49IycyiFhgM7EVX/JXQyx8DgTVAYeExJOCO8eOZu3gx+UAc+sShoQcXxYHzyUDPeqwBYoBvt27BBdw+dhyC3cH6Z55nyF23o0kSqqYSmZenZyaC10PTUDU11JkjiRJipC3w9CTgczgBkE+iBBEMLiRRJKVXb2o3bSF2YH+Kf5qLxWQi47yzQ0FlxPBhVC9ehsXrwRpQOf1PQIqPp+/oEVBXB220mHYbM45jS34je1qTLsP2Dz6m9NhRJj/+99AyTdNQvF4MFstJ3diV+npmvfMeF73wHJjNdPyDxy8IAj6jkbicHOIdbny5OYiSjHvjFuQJY4+7r0/VULZt5+juPSRbbZgQWPzp5wwePwbX0mVULPwZp8eDO/8oxpgYJLuDmn0HiHI40Kpr8Ht9aLGxmPM60RbTUvErzW70WgtRqv8EgpO8UWw+xciSiF/VcDlduN1uTCZjKOjQA5D2syC6cJYRr9fXjF8TLKlA274loAcATo831GViNhpRVAVFUbGZja2yGMHMSfixtQW/ovyuMuSfBacCi1MIQVVVGhxOhjzwAI7163Bs3sKGFasYc8etQFP6s60vkQiIgSBDUVRy+/Wl66hRUFZO+tgxSNHRaJrG2HffpvNpI5h5801ktSC3aYpCwbIVZI8fE1gicCg/nw4OO6mJiZgDRmZ5V1+lrzWZ6Bpwcyz97HPiIyIYN3AgjXv2EDt0MKVrNwDQoGlkWEx4fH5i+/cmc/QIShctpXTnduylJcR0yGbF3AVk5Xmorajm7Dde54sLL+XKAQMo3LyVCFTqgG1AJnpwEI7lixezNPC7DV3AS0YPKvoAE3M6kBYbw/tbt2JDF/k6CPz80EOYBg/CnJRI7cbN7PtxDl3OOQtREBFELZStAH0a8CsKgqAGbqIaWvCpCRCMBqB1bfd46WoAY24OJZ+vxXX4MOlTp0BkRKtHxvjxY3Bs2ETposWkTvhjBmMng2H33EXp4qUkjRmFFBvbbF30gL6s+XlRs8AiOj6ePtdc2WocQZbgJNsJS35ZwkWvvdK2D/fvgCAINKoKpKSAIBAsTJX/sgjz/AVEREWjVFVhSUvD2WBHEDUEUcZss3Fg0WL6XHIx3S6+kEX3PcCuVau447NP8PoU/Os3kjRlMgCOteuw9egOgCJJRAQIm7WbNgeCCpDbKP9oQovPhHxi0an/FPQsiP6E31JN82SybQaDAYfDgaKozYzB2ts1mKFodLrwKyoWsxE03UROUVWsZmPAG6QpeAiqfgaDl/AsR3gAoqgqLo+3mcbL71EA/b+MU4HFKbSC0+3BPGgwx1avpWL3brZ/PYs+F56Hpmls//pb+l50Qat9WvaI79+2nYyERLpdd3Wz7RRV5dXPP+PHv/8dOSY2JLoFIMoyHSeODz2VCwJc/OZrCJrG9tfepnDderp30Nv6Cn9ehK+2lqpdezCbzVTu20+/q66iZMtmIuqT8WkaxoAwU0JMNJtffhVLQgJ9rrwMrbgE3649eJPT6Ga2sOC1Nxk5bBiiJBOdnsaen39lNgpRmzczDH1SPx09c3EUyEXnWFjQyyLl6IJfvYGFYefaHbjzkktJ7tIFbegQYidOJA0oBC4G5r38Onnnn03vUaOIHTSA2EEDCMfhhYvwFBfS/dprCLFZNF1PRGkRQKiaht/r1Vssg94RLdLMbUEQBDLOnEr1ihUQGdHutrbBA2lcvITGnXuI7NW93fGCKFv6GzFdu+JsqCMujHR5PIhRUaSePZOGJcvwWiwknNbknlqxfAV5Pbo0297vdoPf30zcTfF4QTl5/QqvqvyuoCI87d4StTW1rZYl9OpBVOA8GlauwjxkEC1zSt1VBalTLu6jx1ixcxcTRoxkwRdfULp1O90HDQ29puLzhfaJDmSo9IEbQ796SkuRi1OakUMFofn5qT4vmkE+SZbFvx8GWdbbOiWx3UxAexAI2Jh7PFisbWmVNoemadTbXYBGpNUUCmaMBr3sIkoCOqlUC2hr6D/lFroiLbkTmqbh8fowyHLIp0ZfDqqqhBmn/Tnx5220PYXjwuP1ETloIKOf/ic1lVVcdvoYbjh9DL+8+iqgpxb3z19I485dzW4OmqbhLCxiR2EBzrq61j3faJiyMrjw3XdY8OzzIVLiqtfeombRkpBGgd/eiOZy6fuKIn1uuxmjKFK05DcAMidPQHa5OfzrYiKSEuhzx23Yi4qQXF5smZls/+AjlIoyij/6lNqNW9j2w/fEaFCzfAVFm7ehpSSh2hup9/rokpJCeUM9DUWFNOzYhbuoiM7o5mNfoPMkZqHzLeLQb27xQBK6GmcROndiF3q5hMC6eGDH3j08+ugjSKLAgx++zyMrV/DPF15k0iWXUql4WfTRR5T88kugF7/5007XKRPYsnELhrAOCA1aEWYBRJMRLCYUWUQRBfx+H36XCy2sy6A9GGJjMKRn0LB5y3Fv9Cnjx1G9f2+768NhSU6idsFC4rJad1GcCHKP7hQtW8bSfzwVelo8vHU7nVrorCR2zqNm05bQ35qmIUgiUtgT5Imwa8uWE28UNn749dn/zvtU/fIrFb/+imP1OjYdPkTRhx/j3rkb94bNNKxYTX1FZWj7owcOtTmu1+nGdfgwDUeOcMn11zPy3ruY/NBDdOrYCWNyQujdFsNaOxtLiqlatYb635Yjej3ULV+Je90GfFW1uIuLcKxcjX/jZpzr1uPct5+G5Svwb9qCe8MmHJu2/v/atRAUygJCP08WgihgtVpPesp2eXwBt1tzswyJIOpdKLoPiIKiKLouj6K0skhvyoo052D4/EozZ9gmga+mrMefFacyFqfQLjT0AKPvZZfyyrQzsCSn8PikSWiaxravvsVQWsqu4jJYsYqh11+DJklUbdjExm++5YbLr6DnOTNbjSmJop6RkGRsMTE0rl5D/KjTSVP9eL3+0BfXWVVFwTff0fuBe0P7JuZ1Zum77+EqLKR6/z4yO+WhiAI7X32TrH69iTtjKnFeL4v+ejuFR44wpFt30idOIFXxE9WrOykzZ1BSUcPhYyXISRIdR48h6uA+dntBiY6lW04qDRs3UyyYKFq8CA2ddJmNTrKLA1YB/SFU+gA9AwGEbMT7ohM9zcCcLVuwADeOn8CbH37M1j2HsGPCPHAYM/r24+177uKur76i41df8dzSxRDeFdFop3ff3gChm6Kq6WSxOX97jOmP/a3V9RWC5DKzCXzKCcn/wesdN6Af5fMWYMmqxpjUvoFWfLfuHJv9E1ktJvmWE3l0j+64qmo5+Mmn5N10I4QJMgE4y8sp37qTDpNbl1asKckUu9wM7teXjy6/iukXnEd0emsCojU2BsUZ9uQe0Gg4WblzgNjUlJPeVn+JpoxFbKeOJIzTy3Z+v5/xo8bijozA1FMX1DIDX19yOWdIIpEx0Vg9Xip/WURkRga1RQVEREbjA/7+0AOkRkRx/rVXUbVnP7LbRVp2DtWVlcQN6Bd6ba/DHvrdlJhAwojTWh2fIkmYwzJfMuD1eIgadXrob+obT9BG+p+GFjJPU46TXWqrrCAIuvKqz+dDVdV2NTCC+7u9YaWKIHFZ09DU4NgBBTBN/27JJygT6WP68Hj17FFQryJkWBYYM5j5+LPiVMbiFE4IRVHZ/NbbWGSRvzzyKI07dnJgx3a63n4LfS6/mLzp01n9+tvs+vZ7HIcPM/qvf2HAjddhTkpqNo4gCIiCqAcXmsaI887hyLYd7P3ia6okmcJ9B0LbxuTmYuvSlSNff0Pxz78CsPjDDznrzdcQoqPIGDAIl91OpMlIpChwYOs29r/yGlVLlmE2yqR3zmP92jWQnsqKjz4hdehgjAaZ+gY7GpDqasC7ZjXP33c/HlsUO7/4hOqaOo5u305taTkFwAB00uVjTz2FFViEHmSsAVqqE8SjZy4K0YOKnwN/pwCNwBFg6eyfqK5pIDYmkg65WWQOHcS1X80iBVgNPDt2PD+dfwlqXR2aplGzcRMDLr9Ur+2WVyCLEgZRYsPrb7Bs2W9sePUNfrj9HvZ/9W3rN82voKlqKNA4EQRBIGnKJMqWLm31ZB6OyB7ddHZ+YSENdidOtwdNg9lP/ZO3L7sSgFWvvo6vvJyUUcPRKirY/PiTOAoKmo1jTU7GVVqMt7yizdfpN348bz7/POPOPx+7x0f3GdNabeOqrdW7YoLQQDI1CT+dDIxttbe2g6CYkyiKUFjMzp9/brY+p0MOXo+HfZ9/GVo26bxzSZ92BlEjR9Dp5uvRNA1zTAypkyZhGzoYoqOZMXkS5ow0nnj5Feqjo8idfiaG1GT6jR1HSmZOaKyo+MTQ7/FxbbvOyG28bRZL80BLNptCLZX/bQQVKsUAGVMQOO6TfVD8KvwzKQi6vL3P5zvBvhqKooValYNBRYsjakHWbJtDFgwo7C4PHp8fm8VMpC1AEBYICyoIjXGKY3EKp3AcuL0+hlx/HYdnzSZl5nTumjyZ7uhP0RaTEUNaMgNuvgFZEpFPUmZakCTyLr+02TL73v1Ur15D/HD9Sazj2fpT8dZ77ydt+DASExPB7abTWTPA62X/9z8iW8xEdu1GRuc8Vr72Bnv27aN+22724iMR2PTk0+QOH4YxKwtN00hz1ONat4ajVdVEigJRSKy48xa6xMSx6sUXSYuOJsugTzZ+oBR4+cEH6WmKYKXHzj50N1ZXYB1AV6AzeiCRjx5UZALuwBh29GxHxpChpHbtQEl5NbsPHqNv944cKSzlgr89QeaTT3HI78JbeJRVU86gv2Ck/7kziBs0kEM//MiBtWsZc/edVKxdT8e8rry+egU+RWEwsPThx3jr9DGce+GFjLj5BgKqQxis7duAt3o/BN1PJG7IYEoX/ELq1Entbps06nQOzP6JDueegxq4UZ/14P1sePVNXjz3fLpn57Dm489ISUpiV6ODs//2MEJkZKtxup9zFsteeYMxjzzQal3+1q1cdestZE2bir+qir1fzSIiOpKKqmq69+qJsXMnyg8eIu+cs0L7qKrCyudfZPB1V2NrEdS2hwiLCe+hQxh/R8dL8Zx5rPrlFzJycpotV+x2ul9/C5Vr1oWWRbUkocbEQnqqbsiVfxR/WRljH32EscDsx59Erq5G0KByy1Yyhw5mx+rV2Btq6XjG1GbeJx6frxVXA6CxqBBTelozjkVLConf7UaUbAj/hcfKoLJlsCVdURQ8Hi8WswlRFPF4vBiN7ceCugupiqoFPqMEAgtZxuFwhoS2wl+PwDaKqiIHTO00DaQwEquiqgEDtEDAIjR1lIT7mDQRNTUcLg8mo0ykxRxmGd88MAp6iISP8WfEqcDiFE4IVVVRExLJ37cX1w8KU8eMZe2ypaHI3CBJzXgAfxQR3bqQ/9EnuOrqyTgjzBsiMZmtX3xFbW0dHo+Hsp9/BqeHpH69ie3RA9+xAjZ/+SVVe/aQN3okdbKBw5s2cuaUqRRV1xC1/zAlXh8pkydRHhWLFh+PPGw46r599MrrQvHyxWiFJSh+jdSb/0pJeRXJ338VKn8UAqs8TWnoTgYrX/iczY59CzqJczp69kECjEAUuqiWCiR360JxWTUGg4TH66OorApBEEjIzSVv0hSK5//AAmAGUKN5+WHWLE4rKaXPlEmkXHABm7+ZRUbHTqSfOQVF1WvToiAw4cnH6LX0N1LGjdazuoofQTb87qdSQRAwJyZQeOgQCfldMOZ2aHtDs5nEhET8RUVYOuSEFg++9WYG33ozAAc++QxLXBxnP/fP9oObqCishrY/N+VHDjM8QPyVExLodoWu9ZEJUFfHwXnz8Xq9rVx5nW7XSQcVAD0vuICVb77DyDtvA2D/97MxxcaQM3ZMaJufn3yKnj174fV6cTTUYU1I5II3XqN0wcLmgwUno/CnYmNz4bKKdeuwJsaj1dfTUFpOh6mTQt0GZz36EOWLl+LctIX4rl2oXLmKDQsX4pYE7jxjKvaGBoJhilpvRyksRDAY9LSzJIMgYgkELuFQ/H7Cj0I2m/9rGQtFUWlosCPKEqgqskHGajEHWkfVQLkgXHKKsLJCmNy3ppvKaQFJbdC5Rh6vD1mWQvoSLflePr8/NMmHd3ME9TmCmQad4KqFRP8ETWjW+qqqqi7XbWryLNHH0wJy4npQokuKB4/uzxtZnAosTuGk4HJ7GPe3RzCoKg3Pv8Q/A2qA/270uuoKLhw2nLp//IO/jTydUq+XSFHAdcRN35GncWDOfPL69Gbbho1UL1zEjq9mYTUaGfzIA/ScMJHSDevo8/wz5K5aS7RsJLmogM2bNpFQVormsJPavReWuFh8dVW4/U7SBg5m9PiR7Hn7XdzxCcRVVWCoKCULPaDIBfqLJr5TPZSgZybW+5x0AzoAC9DFsiZMmMA7ixYhBZZ70Amdx9C7R6zAmiefYMxjj9Fgd5LasxMGWSYnI5moCCt5996K1FBFxMoVVKMHJZWAJSGJQz8voqyhnryRIzEFnoBFQcQgEeqgyZgwTr+AmobH7cEUHfX73x+/H+dvK+h87dVULfmNpOwsfJWVVO7eQ/q45loMMWNHsemZ5xh0+61tGo15fV7yzpzaank41rz6OrbctpUjHKoKERFtriMmhryzz2HTN81LQJqq0lBb16wl8IQwm8nOysLvdvPczJkM7tYDLap5YNGhS1cy2ijFOF2uZn+XV1TQFTCEaYk4FTUUDGiaRvqE8RRv2UFMTk4oqICmSW/f+k0MmnEm5i6dSTSauSQ3l+jBgwCIHjUiNK6s+FAcTgRRxKeoqH4/BknG3VBHa4ZJ82vhd/13MxaSLBIZYW12rqqq4nR7UFQlTOK7baGsttQ4NUCSZVweL4JPl7SPtFoCGQQVUZKaXHDREBBDY2mqGsoq6G2lrafBkFy3ougaGG4PRoMhTBhLDR2jnvVornmhabRqp/0z4RTH4hROCj6/QoPDiWA2kZSTjVBV9S+PWbVuHa+edS6b3nmP/B+aJKMvSEygHnhi5QrGXn4Z0alpjLv7DiKjYsiIjmHBiy/Ta9QIVi9cwKHdO0nqmseh776nYsMGGg4exnnoCGa3kx9efxUtJYm62lr8fh8LPv6Uda+9SoTfTbykEWMyIRcVYKqsxBQbj6GkCO/hg3z11D9IQRfHAihRPZyNgaHABNGEhB4oRKIHFeuBNxctwg/EINAtJQULegkkGnj7u2/wAxMvvZik+Bg6ZaeRkhBLfEwk0RFWBMBokMnLyWbqzJk8u2AeB9GfzpNjY0jq1oWMznk49uylevFS1j7xJMd+WxnWlttU01W8vt8tZX3kp/nUbdjI/IcfJWryRESrhZjhQzj4xjtUb9yMpAlseO2NZvu4Dx0ic9AgNn3ZthlZYlY2voKC407wCXHx9Dn/nDbXDTitNTGxGaxmBl51ebNFoiwTYbWBw9nOTm0jOjub2i07eGDePMa99AKW2BgWPt1kbV9ecAz7wTY6OgxN4tkaUOfWAw0t2P5ZXErdQZ03FEy5H1q0GGdtLRED+7S+Nm4vWSYjtl49EAwGhEgb5vRUtAhr6PyCUBPiMHbtgqFzHqZuXbD06oHcvQvxLVxWAQSxeVZItvz3MhaSJIKm3z+gOQnTHBBh8/v9KKqC2oxHEQwsAn1Qmhr4p29jkCV9f0XBFsgi1DY68Ph8gVZPaHS6kWUpYNTX/Lj0rIgSclZtkhXX27kFAVweL/V2l95+bzRgMTXlffQgIpyLpI+nBkS+BFE4WdX0/5M4FVicwkmj0e6kuraB7PFjOfjjT/9yO1XC0KHcOvs7Bt5wHVE5HVj7/Ev46+oY++ILPJqcRCTwxV/+QtWO7Sx64WVKt+9k/+6djL3wfJSScsadey5dYmKZ/e0sDs9fyI7NmzmwexfzHnqEmEEDKS8qxItI7+GnIcsGstPSiEtPJXHkcJImTSSmVy8yp02lfP9+ut/5V+KysojLzGL60GH079qdUcOHc+cDD7AL8OLHBlSoHjKBHGAj4A387kYvm1gjIrj62694/ovPkNEDD03RGN6hI4c2bmrVuhb+r+N55zDqvnsQYmMxArm9e7F47hysA/rTMa8zB9asp6qmiqEPP0jOmNNbE8TcbkRJRDIY8LvdJ/3+FGzcSPXRAibdfisEWPGG2FgiunQiYfAgUsaPwWQ06poRQN2+/aiV1aRMGEdyO10VyRPHc3RVSymx5mi029tdV1NaCmEdHxvefp/vbr+T0vWb291HEEXG3nITGz/8+Hd9NqMH9afhWH6orDL89ltoOHpEd2gFumVn88sbb7Xaz1lWTuH8hdSt3UD5dz/gLivHeySfioJj+AqL8BzYj8HpQikoxLl7H48NH0miJNJ52mSE2nqoqoKaWmhogLo6amb/SGr/vvrrqiqq4sfv9bZ9ru00U/jbaC9u6Zvhd3v+q62QJrMZh9PVqstDliXMJlOTWmZYYNE04YsBoSoRVdOl/n1+3XFVknRrdQG9nTTSasbj9ePyeHF7vAhATGRznlHwEBRFaSWupaEHE26vHlD4/AoxkVaibBaModKNGsp0tIkA50JXx/jz4lQp5BROGqqmUW+3o0XYWLF+A3nnnwfRTZ4F7TkHngzi+/dlaJc8Fj3yd077y010uPAi+rzyCn2Gj0AyGlmzbClRmRmkpmdQ1tCA/eAhBt5yMzuNMnXvf4Cxe3dkg4Hhjz3Gsdk/sPGTz5k0egwVmzbhR0Dy+4lLTWH3goWk9epLzswzie3fB03TWLx2LV3q6jAcPYbhiksRfjQwaOJ45Kwclj3zDHnR0VTV17MEOAfoY47giNuOBBSgcygGAtdddx22iXr7pJCdzf2PP0b6hPEsuf8h+o4cSY9LWguLhcOa2MT6f2XtajZ+8BGjM9P55aNPGDP9TFK75VG0YQt73niLHn+9udm+i++6hxqXi/Nee0XPXPj8KF6vbsZ1Iv5LdBQdzz+nFfM+efw48r/8ho6XXkTvKy/nyDezyB0/FrGoBFtAHdUgtK/26XJ5jvuybsXX7O9wu+vEjAwOzJlHlctF+cqVZAwbyjlPPMaa9z4gdciANscTBAFLairWqCiWPfsCY+6964SfvyCpcPvOnXQME34bOHES39z3IA6Hg0kXXsjgGTPIf/MdjF264KqrQfP50awmomJi8fj9aAnxKBFW/A0NJHTOw11Ti89sQRVEfC4nB377jXqg0GTmrSuuYm5jI0MEiafffQvFpyD4vNiNBtRjBagWCyaTGfvBgzTa7cTX1GGwWLArXowaWE0WHPv241f8mIwmnC4XBllGliVc+w8geT0ofgW7w05CQgLrf/6VQX4/YmkZ7uQUFJcLw6jh7V6TP4r22kNNRhmPT8IdIG02bx2Vda6M1qTPEjQkC3Ic3B4fB44WI0sicTGR2B26vk18bBRmg4zP78fh9lJcXoUoiiTGx6ILYpnx+wMBROC4FEVF1RQEQQxzBdYzFG6vD69fQRRUZEnCbDSgqWqIoHwyUFUlpNh5qivkFE7hJKFpYHe66NS/Hxs//5LBf7mp2XpV04lSOmGqicV9PPiqqylb8htFa9fQ94ypVC34BWtGKtPOmsnbs3/k2nET6dy3H5k9ehDZ0Eh1eQUd+vbh3QlTGHjZJUzp1oMVe3aTm5JGxc6dGOIToKYWp8+PobqKTRs2U+Bxcs6w4fQePYY9S5dSXF7Gaddfg6YopJvM1Ozdx8R/PolgsRDdvx+Kw82SV19l+LixDMvKomDlSkrWrqEYsLrtpCalkiCLpNY2stDVwIRBg4i//JLQTUjVVFLHj0PTNLr06U3CgH6ULF2O32wkZ3L7HRfhyEyI57G/PcaLa1ez7elnKHc66JCbg+tYQTMewbqXXiF72DAG9+8bai81WC34XS5UVaN6+0ZqDh3BXlpKvcNJp855xPXqSUSvnvz6j6fo3KsXTpcHWZbwK0qo718URUxZ6Wy870EisjtgLzqKLSaOuInjQpNIzIB+HJ67kLhRpyMAETYzhsCTf1xCa8+PcOR178nuTz+jx+WXhX2+dNJe5wvO49ub/orf3kCX3n0YeN21+KuqKN61+7hjCpJEt4svYO15F9Lzl14kncS11jSNQYOGNFvW8Zyz6HjOWRz46lvSx4+hZudOyiMi6TBudJv71x06zNQbb8Tatw9BxolQUobQ0IinoZGe48fx0l9uRBAE0vv3Ye4tt9G1Uy6Wnj1C49gGD8SzcTOmgA5FRGwsEV4vpq55AM26QIweD7aAomdU2HKX09lqeW55BeYhg1h03wNMeOZpPHbHf+1pOvgZtZpNNDQ6MRmNSFKYUJUAPp8/YPfexK9A0ELZBa/XR1VNPZmpiYiCSH2jA1EUaXS4SIiNItpm4eDREpITYjGbDKiKwtGiMuJjo2m0O/QMnEEmLjqSmvpGXYNCg47ZqUTaLIHX1AWvIiymgMOpiAAoyu/L7Ii/wzn2/zJOBRan8LuhKCq9Lr6ErR981MZaDVUFv6oExLAk6nftwWA2hkys1jzxJJmdOyOIBjCIqF4/1bVVRGdmsXfzNgaefza2Dh3A78c2+0dkm4V+vUdjLy1H9XtJHzCAXb8solPnPPKys3l47zv0xkCnTrk0lpVQVVKOy2FnyAUXkjl+DNtu/AvLd+9i49rVpKBrSly+cT2ZCfGYLRZG3Hc3ckQEznWbsI0aTsK4MTi27mDIzBlIHXJwbd6MGhfH+IQUUrMzWbl5I3J1LaWKmz3A7dNnYO3UCW9pGXJKsu4Aq7O6QBDICDwJZ3TuzLEffmp2tVa8/xFJUdFkjhqOqKpYUpsY/b/OW8CZEycC8MPixficTmJHjSFjyGDUujrdT6OiguioaPLOPbvZuIIgIFss+BxOlnz2JRe8+BxCSRmkJoPZzKK776PzkMGUHzrMqLvv4mBBqR5IGHWCmi3QUhc1YBCmHn2o2bCJWZ9/wozsjpj2HiE9JQGbxUS9IlBSVkFjYRmyQSYpPhqX20t0lA1DGAehLSSNOZ2dTz9Dj7BlwbR4xapVpOZ14vS77gitK9y0lcjYmOOOKQgCosHAVd98xYJHHmX6SQQWe+bMo2zzFjLPak7Q1DQNV6D8U7VpC12vvLxdW2/HoSMIGenE2O1oNhsIAt6EeD794H2ufuRh5C55oX3iBw5k7drVbR6LHNYbKqAhmgxtbmc2t31tbRGt23rTM9JRKqsYda7OZ9GP498/+R3vAUKWJIxGAx6vF6vF3GwfSRIDhxPMVOgZBEVV9ZKQpjYrk4AejJRX1ZEUF43RaEBRVExGGYfTrRM6BQG324PFbKLR4UTVNA4eLcFsNlDf4CDCasHr9SFEWPH7FRoC7s56V4eGoAGBMkl4wkIQxYBSt348YqBLJdhpEm6C9mdW3jzFsTiFPwSXx0vF0SNoYf4FwRuuqqmBGqNA1aat/Pb5FwiNjRT+8CPb332PXhddgCElhYzzZpIxczpSQjzWpFRyhw4hNjUZW4cOFPzyK8uee4npvXtTcPQYGeefS9cbroH0dDZ9+AGOxnqGv/oixZs2c/HgIYy8/WYKXW4SczqSm5LMaRdcCDW11O3Zz6TL9FZFJ1AdONYjQMaUySROmYQhPh7PvgPUHMnHtXsPe95+n7jePcgeOZyUTrlE5GQTn5JC11EjiE1IwADE5XVARhfGMvfsSfLZM3Du3B26XbeXCk3v14eKhb9Q9OMcvJVVlCz4md/m/IQRePu6G9n15juhbdO6dqVqz16+vORybrrlFiIBwe0kdfTpVK7VtRL2r1lHUVk5NTt2hTgQzdDQQHRSEqooQYdsMJv55tY76DZtGtnnncOFzzzFhhdeweL3U1VTj9PlwedXyC8q41hxBdW1DZRW1lCfnsnM2+9m2Scf6rLtLg8HjpbQYHcR3a8fdRvWo6gKR4srKCitpLisCiEqAuobjvs58ribyiXhfJOyg4eJD7MGB+gweQLReZ2PO15oHFFk+Lnnsfifz55w+85DBrN66VK06upmyzUNbLJM3eZtGCP15/+gVHM40VBVVTweN3FuN7tXrtEVHlWVAz/8iMvt5ejCX6j8ZTHVi5ZSPH8hxXPm0rhqNf5NW2hYtYYjP/6Ea+16lC1bqd29v+kAVBVVbVvy2uNt472GZloXQbiOHmPVs89jkA00rFpNzbIV//WHakEQMBpkvAFRK1VV8Xh9AZ0KETVgrx7eDULgb1mSiYq04fX58fn9xEZHkhgXTe+uHXB7fRiMBnIykikur6bR4SIm0kZSfAzpKQl4vD4sJhPZaUlE2ix0zEwlJTGWqAgrETYrmqbh8HiQJBGr2YimNjWJBo3IwkuJmhokk+pBULCTRRKl46qA/tlwKmNxCn8Ifr8fm2zkt1deZfRddzbVTRFCdUvN6eTI6pVMfuLvGCSJzH79dB0CILJTJ5zbdvDz2+9wpOAYdy+Yh3fjZrylZeR/+TU1tbWMeeAelNpaFt19P3s+/4rY9AyIjiVp1GhchUUYJBlLTjYHjx5lw9vvM+HiC/DV11NYU8O7j/2ds4eexoHXXqEYPY08GEhDNxOzA2KYiZG5Ty8y+/Si6P2PyB41SnepDCAhLQOhsprChHiKi4uYeccdLP11EQJQCxStW0fKpPGIooBB1fAHzZWE1k9xcoccVrz8KqeNHMGhjz9l6t8fZcXzz1O3dj25vXpR53LjKCtDdHvYvmgxebk5RMfFUV1dRedePYlKTkWKiUZBxH+sgC4zp1O6YyerP/iQaS893+y1SpYspXLbdhrKyxAaGyFOb3yMjI0lI9C6aEhOZuR9d/LbCy+RfuElRFjMlFRUExmh33TLq2qJibRhtZqJHDuK/d/NYsczT3Hmq69Q22AnITaKBoNMYoQNyeUkMiGBmrpGVr/+Ctffdzdb3/2AfvfcQXsYMHQoJb+tIG306U0L3W5MPh+rN2ykRwsTu9NuvO74H8wARINMbP++pOzYiVJaipTaUiu1CX7gpheeZ/2nnzP0jttCywUBMkcM45MHHuT6Dz/Qn6dFkYq160ns35e9n37JkdpqCrdtJzoikugunZl8x62oikrZkmXk9OrJfRd+T92y5cSOHd3ma0fRvJQRE/6UK0oItB1YaP62SZ2eyioaV6/FIMvU1daRmpFOQUUFQ84/F6FfH6IAU6O9DQXK/zwkscne3OP16Vk1g4zHEzT+EvWMQABBvQiL2Ujvrjn6vUUUAxmMQHZA0LODsVE2Iq1mTGYjUjDrIAh065gZCgZ7dclGFEWiI21oaEiiiKKoKIpGlM0ccm9u5vmhiYFMRJN+RtDfRBD00m+w3Ptn5lS0xKmMxSn8Ifj9Cn3vuYfExETm/+2J5sI06F+0vd9+S/cZ09FoesIL/vNWVZG/eStnPP53bvzwfQAM/fty4OBBzOkZDLjpBgCk2Fg6zZhBze49lO/fz5EfZxNVW0PBkUMsfuxJss87h5HXXIvodrB8yTKWr1pFn3PPo29KGrYe3Tn35Ze57Pbbefryy/EC8QlJxKCTLm8fNrxZxmXPF18hZWYQZTXjKS5uOtl+vfEkJbFj1So6du9O2vnnUlJWRt/ThtMtJgaltg5B04jt05ua1WswSHKoFbQtjJk0CWNCAlGdOhHVuwej7r2HPes30rVXL3757lvevuFmGiuruGvBHMZdfTVpmenEJSYTl9sJuyQhAMl9enHkm1l4d+3GV1/HtGeeaiaxeOSXxexYsZIti5eQk9uJ9R98rAsMaRoDx43hi5v/yuIXX9E3lmWGnXsOe996HQ4fpE+3XLrlZtC9YyaDenemc24GuRkpJMXHcsXXn5FttZGAQv/uHUlKiKFTdirdzz6TTvU1dMhIoV+PTvTPy+OzJ/9JSUUZjTt3tXstNi5bRlxOc6OyvXPmE9uzO6LJdJxP4PEhCAKCLNHtvLNZ/MLL7aalBUHAmpJMwuABlBYU6p4mYetMmZnExcZCoDvju388yeZvvqVg7gIOlpYw7f57icztwNE9u3n3h+95ZPIZPHPu+WgRNiJ6dAMgukXm5bjQwvgHstQu8VZTm+y8wyHHxRDbpxcRfXqRcdoQpNwcupx/DkpYNksK02P470Ig6LSqqKpe6gBkWQ4pVgYndwh0VwRKJEFyqigKGGQ5YBSmP8hoGgHrczUUMDWVJDQURcFoNIRIlVJAIRjAr6oY5IDNQOBf8LU1TUNVlBbkzebXTW9NPRVQtMSpwOIU/hBUTcPj9WIbN4HFi34BoGTpbwCBvnGBrmeeSfm27c33C0xuZes3EZmWgikpkYiUFGrWb2D351+SlpHO5rlzqN26A1SVRfc/QKfpU+lz5aUkdsjC0qM7li5dGP/g/cQqKhveeZf6ogIGzZxJYmwMo6dOwZqaxLTbbiWvc2ciUlMwNTrB6SINKKuqYAvQD3AA3978Vw5/rQst5YwYTuqkCRw5eADvj3Mp/uRzapcsp3bBr8hOJ3lpaZg1gcJNW+jTuzcb1qxhc10d7shINElCSk3FX1+Po7QUIfBUM+fRv7e6dmV1Ncx/+222/fIr7poaInt2Z8h1V7Huh+8BGDdtGj88/U9m33gzh9atY/vGLZQezadi506SoiIRBIH1c+YSNXgAq196BbMgoplMrH/vA1675DK+v/d+bvv735A0hamPP8Hgu25DirDi2LUXNI3EkSO45M3X6Tt0MHMfeQwAU8dcpv/zKSr3H6Bq1ZrQTVYOBDKKqrs/iqLI4LtuY+6dd+n9+gQmcUlC69wJ745dyJLIoFtuZtLlVzD+/ntx5Reg1NW3+TlK7JCDuYU0drfzzyF5+HDMAR8QT03N7/lohiAIAmJUFDnjxrLu6WeOW/MWRZExl13KimCwFYZO/QeExLpsgkyv8ePIPGcmhiS9i2fK9OmcM30aw2NjURx2VpWXkTpkUGhCapRO/jbr8bTIRLRzyO6iQpxr1uBcs46GlauoX76S+uUraCwq0o/VbIaoKF28LCYGs7GJ16B4vf/1+r+maXi9PiRRf18MsoSiqrjcHt1YL6SAKTTbJ/hTUZRmDsBiKBDQyxGSJGIyGfF4vM328/n8mNpwuw0GDm6PF1Mg0GovQNBCbaYtS1NNraqngovmOFUKOYV/CX5FoW/3nvzztBFkZedwydjRIedEOSkJQQ0o1WkqIgKKpiIhkhkmZVy1Zw9KQwOdL7mQtGXL2LhqLbLJzIInniIhYKBUu/cgEVE2klOSqSsrpcuUSSQOH8qSDz7CMnQw3no7Lo+HrHFj2PjUM6ScPpLvX3iBztkdmPHGKxx68mkmTJ9O7pDBdPzoE4TqWhI753HwwEE8+flomoY1O4va7TvIik9EiU/EffAg6eNGhc610usmOq8LsampRN14PR3zOnFwwwa6jxxB2a9LKF65itRePfnu+puJ6dSRqPgECg8eDO1ftn4TiVnpFO3ZS1ZSEtYOHTAHJqyq2no8xcV4AIvJyPS//pW4lER+felVpt5zJ3X5BSz76isGnzUTgKSMdLxVNVSLAkdWr6LvDz/hr6jkli8+A2DC0aNEhU3YA2ZOZ9fCX+mak4UxUn/NhNOGsere+xlz7EoisrMB6H3lZSx+7AnM0VHE9O0T2l8NCADJaER07kTf1Ay06mqE+CYzLF9cAt6DR5BrapDj4kju3pkNn3xO57592hVkSktObvezZbbqk+Gxn+bR+bKLW8l3nwwEUaDzpAkUxsSiKSqC3DoDEJwUYvr3JXn3bjzbdiBGRiKZTQhoWCMi8OQfxZiTTWp6CmWlpWQIAmfcfCOaplG0Zi2L58xj1HnnMXvJYu4aOlSf3FQVJAlvXd1JH6+qNmUWVI8XFY22chaxXbsi9e/T7PgB/Jva1vnwKUpoHMlk+q9OhFpADdbr9xMRKD8aDAZEUcTv17kVfr8fMIW2hyBRsqn9WW8NDu8oaVFmlGUURcHt9mA2m/B6fRgMckgTIzi2X1Fxe30oii6QZWjjM9EEgSaRrhZrhHBp71MIx6mMxSn8S9A0mHTv3fiBgRec22q92WLSv5qaTnzSNA1fC5W9uK5diRszClXT+OHdD0my2Yjo0YUUq5WU3rpteOaMM4hIT+fXz78ie4KuFZEzfBii04UP8EmQlpDAvCefJr+6Cv+6dWRmZNJn0AAcx4ooqG/g5zlzmPvGW2SlpjD4soup83mJy0ijrLKSve9+yOF33ye2T2+csoS5S2e8qoIz/yjfXn8jR975AP/2XRhKyzg0ezYVn3zB9vXrcR7Kx3+0gKp9+xE9bhRJZOSUyXTt35exd93GX776AmpqWPPqG+z/bRmbv5pFhKKycONGGvPzIaA+mDGgH9NefxUNKD90hLTTh1N04DADpk7h88f/QdrEcYy9/HISunQF4LunnsYpS+T260dKbi7ff/sNw++6PXTdo1pkAaTUVMoPHkQ0yM2eWC+46krWf/IlSn1TRmH83x6haNt2Dv44F2hZP9br3Gk3X8/2Z5pzOowGGfr2JX++7qGhRUai+b2s+PJLxKgo2oLL4w6VGVri0MZN+rUZNIj19z1Iw6E21C9PBoJA+sB+IeXG46HLBedxbNUqfA47zspqZj39DIc3bGD2P55k75x55PTozm+zfwxdD1XT2HfwADn9+1NUXs7Tc2bT+7RhzcaMaU+avA34fE2BRXty0wBOp73Np+y2BLKAZr4X/22BLAC310+E1RwS6xIFvaRhMhoxyE3iU0GoqoYYJpAlSlKglEG7duSCIGA0GlEUBbtdb0kNt0EPBhV2pxtZEokIiGq1vIZ6uUR/PVmWQo62+j8pVC4JEjdPoTVOBRan8C/DabWRFh1HRnwCAIXz5pP/9beUzJ1PVVU1kighCkKIeyGgewXkB+zQ1QDLHiB3QH+IjUdtaCC7Tz8yZja1AAodc7nk9Vf47Pa7eeuMGax55XXGX3Yx9X4fxvgExjz7NDl9+tC7W1cOVdXQa+xYOt51B3aPhx49BOBjigABAABJREFUe3H/ol+Iio2l4w3XsfSH2VQfKSDBYGTb2rW4igr59aOPKftpLu6qKiSLCUNDI9bICMaeey6xPbrhFkSM9XWIfpWo/n2ZcMUVbHLYSZlxBolRUThUhd0bNlK4ezcGl4uGTdvY+frbbP/iW5TGelxlZayb9Q3VPi83Pvwwdd7mAlENFZWsAqLiYinauImYbp1JnzKJcy+6kFXPPMv7n37KsXXr8O3ahQJ0nTmDyNhYcpKS6ZGWwYZZszkeyoqLaVkj7n/NVYy+5UZ+euwJqjZtCS3veeXl2GtqWfXcS3jKy0NZKL+qqx7KGelEi4ZmnARZErHazKipqdRv0McafPttDBo3rs3jOTJ7DiWVNaHgqvmHyklqahpHP/oECY2+N9yA4Pa13i4MLSenIILtlUrLMkNbMBpZt3cf1t69sPbpydn33UvukMEMmzyZxsJCSvPzEevrsO/ej6YobHrvA17Ztg1zVBRnPflYQJzMhxBWr7cXl0BxKY4jR0/48lExTQGYKAqI7bSVau3USBSl7W4RfxiXSDabQlyH/xY0gh0fLTgKoi6Epapqs6AoaHAYmtADv+vKOGGupC0ginpJBMK6S0LHAE63B4vJiNloaNeJOVz1M7xTKVh60YMdudm6U2iOU6WQU/iXoSgqg264lhvvu5+n77ybRkcj3a/UfRzSNC1E0hIEASFo3IPGrvUb6DB5ov7FDNwjjFHRmONjObZ0Oal9euL3+5FEUe8p93k58t13pMQmUK5VcNo9d3Lkp7moRcX0P/8CDsz7mYHXXs2CBx8ls28f9q9fR0V1JfEWC4rHi+PAYXbtP8jgYwXExMfTZWwf9m7axOAu3QEYdOMNbPzwYwYG+v1NKSmodY346usR848h+LyUlpdTWVbG0cJCUqIiqdAUlj/1DDu3bWHc6DF8+dsyaoDRW7dw89rVdJREpMw0PrruRnY21HNaVjbTH34QIiI4unQp2959D79fRdE0TBE2ugB+j4dd38xi1C03466pYdfKVewtLubNtauhuJR5L73MMeDts8/lSGkp6QmJjJw0iX6XXtjm+1O6YTOlvy5GtVgQZQkx7CkOdILs2S8+T8GPP5FfWkaHabp5WL+rLwevl/WvvUXfa6+EUBeN3r+vdu/Cnif+SbdHHwjdYI2yTGxyKju/+Za+FgO2nj1xKk0TxpZ33uPwjp2kZ2djiItl9K3NFURDsFqJS00h56orQotqfphDZPcuzUiqwQnGryg43V5kScRmaf0UKsoSmmpA9fmQ2gpkwjB+wniU4mIOrVxFotGEln8MISsLrbIKR0EhQ8eM5aeXXsBmMvPs1i3kAJMee7Tpego6zygIp8lIbHoqvuUrITfnuK/tdrgJ5jdUxd9uZsHjdLe5XGqnXGQMc1n1u92IsoTQZpHl348gp8Lr8yHJUjOCJujES7000qTI2f5YuhPp8RIuwTKL2+1p1gIabBM2yG0HFMd77XC10OBxnEL7OJWxOIV/C6wDBtI7Lp60YYNCQUUQkiiGWsAKVq5BEiUEBLJyspu0L+x2tEY7Q66/Bk9DI2WFx5CyMlHR8Ku6AZFkttDtxhuY8sJTjDvvPDCbyb3gPEbeezd33Hcvyz75mCV334dV8dHjwvPoO34c4x9+iLQzpmKvrePInHlMvOB81r75DpGair2mhtzUVPIb6jm6fgO+fQeRExLI374dZ3UNCQMH8Nnzz+Ezmah2u8iOjUNMTSMrL4/cjrkcPnKEPcCRgmMcBf7y2zIagVt69WXMRRcBcHT7TjzbdzJs2nSe/fQTLvnmS8oPHGTTm+9QVFZJr4suxJqYyJC/3EjfKy7j3Z9mE5PXiRFXXMqiF15i2jnn8cmKFWQmJbHwnvvYNXc+1sgoxnTrhknRWAmcc8F5dJkwjtIlSwGo2bev2fXPX7mclCkTuPyNV/G72p6QALJmzqDw0EHKV6xBc7nwl5SA0cjgv97IyqeeC7k1Br0SMi88H4fb2exmXPvrEsxuB30fvI+ag4dxHT2K2WIJBQCfffwxk2+/hdPuvYtB117d3qEAsHXlSrY992Lo78ShAyn87sdW27m9Psqr66ipa6Cu0YHX33pC1rUtBDRFRVOashqaplFTb8fp8uD2eKmua8DpdFG4cjV4/cT26kFBTQ2W6EgqS0rYvGM3lU4nRlsEz27dQhIwKCObRZ9/qVfiq6vxBjIjwc+2OfAEXXMCTQ8AMUyVUvH42tSlADBbW3uYgq5S2RbCjch02/T/7q1fkuUW5ujNYTDIJ9UB29Lfo71tgsGK0+nCryg0ONw0OFwYAp0lvwctMxNBv5AgEf3PLITVHk5lLE7h3wJV1Zhx+218++wLXPjqS6HlzZ5MBIGIhDhWPvVPItPTKNi2k97n2hH/P/bOO7yqKm37v11OP+m9h9B77x0FAaXYsPfu6NidcXR0mjPWUUdHx967KCggIAhIR3onJEAC6T05OXWX7499zkkHLO87fq+5rytXkn12WXvtfdZ61lPu2+GA4hKOrd1Az5uuQ5ZFFF8AWZTCksd6RTmF23aSNWUiZd+sIKVvH/bPX0Cf8+dizswkGrj0X8+gV1bhqanGlJxMt8suRdd14uLj6dKzJ4V1tfTIycKZdRlacTFVufnIosi8t17j44ceISI9hUbFj18UWPzXvxFvMnPxP5/EEkxQrJn/OUnnn4eydz8Hly+jsaKSgUCvEcNRli7Fh0HC5bGZ6XX7bwCItpmxjx7JwFlnG53g9bLwoT8x47e/IX//AT578I8MnTo13EfmxES6nTsHgEm3/wbP8/+msb6BmX//G0se/Qf9br6epX/8M3aThd6DBzBqWSlpl11KZX4+QnU1B196hRMV5Zz58EPhcxaXVjBm6BB0XUe2Wgg0uhFNcnjl3vwZTbjrDra+/BpHvv8eGZ204UNJnTCezNHD2fif1xh503VhJ7zJJJPTqzd6ZSViTAw1K74lUFuDNyYWq6KQMnsWO1/4D9HJTRoo886eySM33czTK1e0uXZr5IwYSXzXJll1OTWVN555mttGDCUuOyu83WoxkxgbjdvjpaaoFCE2ut3zicHkPsXnxdRM6r3B5abSH0CUjGTCHdt3Ultejl0UWfX1NyQlJ7DtWBH7a+uoqKuiOk+kpKqCKCAZMLk9fP/1ciIaGomOjsVaV0vD2nWGZ0XT0Y8WUr92PbbyclzLV2CNjMSnaaiqhiwJeD1eIqOjKCkqIRYddu6msqKShoJCsuec3e69eNVAC/6LxqNHKVy5ihjZjCgIeOvrcTocYLWhqgqeo8eIH2wke4Y9Fv8LhE5GRYeG1+vDEWTc7Cj8oAQUMLfPNPpDYeRbmFA1jXqXG4fdhlmWf3JehOH10IJlrqHETSHsROsMixjoNCw68bPBMWAg0WvWUPz996QOH97is9AXLql/fxL79aNm8zbiomN4/ZrrGXvuXAKFx8maNBEBgb6XXUr1im9Ryisp27IZq9VCfaOXrAnj2P/OBxQWnWD6+eehrm9Sz3wsRJGckoK6ZFmLkrOSnXuIz8lBLTjGxm9X07Vnd0o2bcFht1PoDzAqMpJLH3uUDbffgWSxY5clBk6dRsm+fVTu2kNakNzIr6hU7tqF3+Ph5U8/Yw8wENi4YQNrgQQgGti4ZQsjFy6i+lAuEanJVBQXkxJv5J94PB60SAdHDh0kZ8Qwhl55OSKw6pG/ENerFwMumRe+p8jevbnoxRfC/8/865/R/H4yu3VF79OLj/9lJHsG9uzhxPKVrJj/GWdffQ1n/PHB8DG5H3xEYpAGWxAEJLMZQRTRNQ1/fQPmCGc49yWEYTddH/578cN/InXCeHrMnYNzyVLcBw/h6NUTPSgvHTHnHAqf/zdRo0bi7NcXU3oaZV9+hWNQfxrcHrqOGoncrNKh2+jRXJKQSN6/X6Tbb1qGQUo3bMZTVMzqb1dQvHMnGb16Y2k1+V3z+D94/bd3cP+XC8L3JAAWswmzrrH0lZfo8szT7Q7woftXgyWJoX3iYyLZk3sMXddJS44no3dfYudciHvDWqrXrkGPiSTaGYG/rIpIYHFVBVcPHUnasWMkZWaSf/AAmV2yKal3Yxo2En/BMXLGjQ17eMpqa4kbNwaz2YToVxCzMnA0I+wKmTgZzbTV4oGI/bkgtj/5O+SW4ZzSrdvpPWEc9DCYSZ0ARSWQZlzHZm7iBJGt/3tVIbqu43J7sJpNhhLpSUINitq+d6aj/U8HimYQWJl/hKcihBYcPbpOc9eLQfEuommEpdc7jQsQfq1unH2H83+dN/4/CKfdxvlzZgOw4v33cOR0MT7w+9tP0GsG/4FD5G3dTp8rLkE9VsDRLxaQOmYMthHDwomdobj1wbfeQdF0alwuxv/W8Az4S0vZ+slnFOfmkhMTTbcLLsTerw8CEHC52P/5QrZ88w2x6JTX1aNUV9GrR3emv/4a1Xl5lG3dQfXOnZj8AUOaOSUFayBA1359qa6spMv11+H6bi0BVeHvf3wYG4ZseiPGIN4D2Ar0AbIwqL4FRK68624cF84FjMGwIS+Pw2vWMeiaK41yNY+H5668Bq20mN7nzGLm7+8/rb7WVRVBkjjwzvu88dKLpAFjZp5DbFIKcUMHEDN0CAB5739Mt6Cq6tZ3P2DYFZcax+s6uqoS8HiRrRYkU/srxcNfLqLk0AEm3Hcfuq6z7dXX6HPmmViysxAFAU3XqX7xFeJvvdEwWHSdwKFcivfsIXHWbDRN49A77zDkphuo2LSF6r376Hr1Ffzrplu5+/VXEASBb59+FhHo0asnqWfPAGD9o48x9r67KV67jq1r1zH7T005DBXf76Dh4H5yLrukRb7F2qefZeRlF2NObl/KPXTfflcjZoc9HA7QdJ0DeYWAIbNdumY9gR49iY50Ur57J8XffMOGHVs5CDQA/YG/3X0fK/PycJgsuE8UkpTTjajoKCRfgKOHD7Bl724efPBByg7msWXVCs655WZqdu7GmpFGRJcuWPv37bCNIbi270CorKbe58MkSzhjYkCSsMoyRVu3E9kjB5szAlWHjStWMunO2w3+ivbOtX4jzrFGtYqvwYXJbju16u2PRJhcStNpdHuQZQl7q7yX5iq6of/dbg92u+1nm5gVVaPB7cEqSwiigNViaWEknO51QvcSSgTTdB0hxGEhNHG5hOyN5uc1mSy/Siuj02PRiZ8NgiCwYcM6NL+fl669nt+88xYvXHYFXbNziMtMR/P7SM/uSm1dDZEpqWRNa6oWMPfuiXvtOm4ePZY777uPXnfcDsGJSmw1AESkppDUrStyTk7T8cnJjPntbYAxEOz898tYdu8mPjaWhqPH2PjJpyQlJWDq04fs8gpmvPYyuWs3Uvj8v8m86w4cMbFEdsliw6tvoHsDpEfHYmlspPrwEY6WlVLz6QIc+/eQfe1V3DprNlvy89mzfx8NQBJQGWzH/uDPRcA6NIYVFdHP50cUBGRZIn/pCrpedCHF5dUkxkZj0nV81TUkDxiIu6ICf00N5hiDertw8dekTRiHFNFWWEqoqeG7t97l4K5dNAIHgZEiNNTVENi1h6gu2eiCwMZvviFr7jkUr/4Oa7PSRUEQOPz1MqJSUojr2wddbn812X32ORQ9uif8/+Drr+Pgy6/Ta955uErL8BYcp8Es0/DBx+RcfgkV69fjq6jCIpux6Br1ikpcVBQnvviSyJwsvJLI8uf/Ta/4OD675z5kk4l+I0fR/bw5La7rSEoCs5nUM6Yw+4wpLT5LGD6YiJQEypd+Q+LMJpGxAZMmsX/JMgZdexU/BALQo0saICCJAlKUg+g+XRF8XpJHDmPTm6/zPfDH6dPxNbjoNmwYny34gpH9+2FJSaCiogS7CRpKjtN71CgUIcC4c+dgHzWCxkO5zH3iH1hSUqivqyVy5AjkUxjZIYiyGdvQQTiacYWEEO1x4wiWtcrApGFDTnquBpcrnBQqdlAN8VNhKIQqeH3+cA6CSZZbSKWH9vP4fKDT4rOQhsjPpbnh8wewmGTMsozH60UzmYJGQUuxsJPdT1O7VAhJueugCxroQpgMEDo1TZuj07DoxM+G0Nghms3c+NwzXDJuAs+/+jIJ/foB4D1xAsliISMhgaNffsXB9z4kKiOd5AmGbkVsXAzPzv8Ua2pqs3O2/bqWHCskbdTINtsBdr3xNn1nnsXg224Ob0sEbpx6JlvffoecocOIH9iPxvwjdJ05jYLFS6j8fAHHN25CSU+nzx134928BZvTydFd25EqKrBHRKPaneyqrCb/saeQevUlMbsb5v37iAE0DM8FQDdgXFomiX37Ejich98XYO+KVUjZ3dj42N9IHzAI/4HD7FiwgISEeMYOH0SPLtks2bGDdCDtk/mMvul6tJJSYmNiOLZyFV3nzm5xj2U7dnJ8+XL2LViImpLKhWfPZPfiJexf8jVn3ns3DXlHOPzFl6z46it69OrNZ3ffR2pMLBMf+1uL89RVVrLu40+47MUX0FQVk8Pebn9LNju+khLMycmIgkDvyy5i4xPP4EhLZtAN1xGDwIKrrsERHUVl/jH6/PYWlOpqDnzwIWnz5uGIiSH+rKnouk6my8NHDz3EjXfeSc7cWW2uBdBQVET53r18ff/vGXXRRcQMHdxmH2t6OvW7W1KFRw0dhLhjB3i9Ha7cwci10PUmqiUhyKkQgiyLuLZ+z9P33kdy37785tX/kHLPfcTLJkobGtBlE6SmoGgaAy+6gAPff8+5N1zHun/9G5fHR3REJA/cfTevbFhHWmZa+H1OSUltQSh2KkiC3qGnTxJ/2NAdHRUd/rujhNCfAl3X8fkDuD1ebBYzslVG13TkdiowdN2Y9K3t3Jum6YTsitZejR/aHkVVsVnMiEHujJr6BiRJIsLe/nveEUK8GSEODgQjDNiceKujNvxa0WlYdOJnQyih6bqx4xnbrTsFQHyz1bY1PT38d5fZs9B1nY9uv4P6/7zM2Recz6J332dQ3lHG3393h19Yz9ECuvXsYdAVt4P0qEjkxMSWx+TnU7JzJ8drasiWJKSsLISyCsxOJ6mjRlL05ddEjhxFo6se/xuvUWC2IAb8RFrtxPTtgzZiJAdff5UYh4Pl69YwwWzBOmYM4xD5GI0EIB2Yg8Br6OQVFTK0qJBkoMpsgvIy4i5IwmlzkBwbR4IkUr/nAElD+qNGRnHuay9zXvB+PSeKOPjaW2Tn5OCcMoH2qJWSBg/iiyeeJD4jg7n/eBSTw4Gn8DhZY8eROXcOB555nl2ff05URgbVddVc9ORj7Pj406b+KCnBlpJCRlY2KVdeiclhR/F40VUV2lnNjr/2KlY99wK9zz6b+vx8us87n8zRI9Eb6qn+ZiXWyCgGT5yI4vGSPnEs615+hSFTz0Q0mbGoCvWahis/H1uXLphTkpg5dSpd5pzT4XsUYbEQm5rOsPvvYs8rr7drWAD4PB70mhqEoIcHwGS1suQPDzPzn+2rmgqCYCRper2YHS0rK3RdB5eLT194gWVlZczt24/LX34RXdcZc/55UFXLhqNHGWCS8Rw/jldXqfz4M/Zu3sT0jd+jlBSzu74eu9vNVePHU7t6DVpBEcq27aBD9b59RKkKfkXFJptwuxuRzGYsJjOqqqAoARx2B6qi4g34ObJ+I/0uuwja8VjJph82dOvayTlAfioURaXR48VhtSAHmSyloFHRloDKCJtKrd41k8kUJjH7KayWuq7j9hqVOaG2mExGIqfdZj3tXIvmbQjZCILQ5KXoNCo6Rqdh0YmfBQJgtZjQgYHJqUx7/HFeP/88xl18KetDiZWtoOs6kRYrcX36kDh6JLedO4cTi7/m8Acfkta3L/aBA9p8eev37iFpVseTkjU5uUXcHaB8zz5yzj+XnIsuDG+LGDEMAEdWFlHZGSSdPYNNL79Gvhpg5pkzOLZhA+nXXs3GN95m7HlzSH/oD0TYbUi/ewCnLPH9c89wNBhzzQ2esyT4/wAMxcypfQeAxYo5Lpb61SuZctcd2FOSYecucFVjQyNh8OBwXwAse/Jpplx7Ddbu3U/a3zd/+D6N+Uf42xVX4tV1coGHc7pS+vUyGutrWVpdRXJ1FaPGjMZTUcHQG64LH7vs748z97l/UnL0GIOvu8pgeDSbUTxeTM52yhijo8kYOIDjO3fSY/AAaletIePs6VQuXYbYJRvXkWMkTBjPJ394kOkXX8SBDRsYMnMGveecQ96ir4mfNYvGdWswRUZSsGYN4x5oP4+kIfcw699+l4qyUsbNNHItGhsaOuyDjPPPpe6bFZgSE6mtqqZi3wHSx46m9+yzqVmxipgzJ7d7nCjLaKqG6ve35bRwOjn7mqvJ/mYFA++4w1DqFUVy5s4hf/FSzp91Dg67gz5p6Qy85y4c8XFcIULBiUJ6TpxEyvgxbPliIWOCJdeV8jrkYL6Lp7yMxGFDCaVRNjeNZQhvlwAH0N1m69CA/qGOdz9yOElU+AHaJSeDpihGjo7NRqPbg91qCfNlnGzibe0hatrfKJeVg5/9WKPC6w+gqKrBqhm6nkkmEAi0CF2E9m/ehvZgJGUK4TDN6barI4bQXwM6DYtO/CwQJRGrxSh1k3WNTx94kI9efZ0/33Ad/txcTN27h1cASmUlK156BVdFBWfedAOlW77HHHQXZ5wz0xgcjh6laMGXxCYnUXCskB7du+FWFQSrreNGFJVgcTZb3QVdvjExMQTKKzi6eg09Lr0Yf10D5qim/eKHDqFswZf0HjaUkddfQ9nq7yiuqaH6jTcZ3L8/sVFNfoPePXpwcN9eMlPTkIuLOIFOMZCCkcAZhTExKMDR6ioG9O+Ho0smVr+fjN6GsZBfX8thNPqeKGLD008x/v7fBUvYDFEuU0Ic2Dt25QOUbvme7999H5eu0xu49drr2PLhR6SfMQXB7SESKAVm/vWvyHYbeL1s/tNf2J17mKiEBBBFSo4XMpjgKt5klGLqRnp7m8GzWzAco+s6pV8vI1BWTvz0szjw7gf0vvA81jz0CFOvuoJ1ny/kgvMvoGj1d3S96EJcubmYNm5i/8pVVC/4koufebrDe1r96uvMevKxFtvSu3Wl8KNPyLx4XrvHRE09E//RY3z/5jvMebaJYvyk+g9BY6F5DJ1gP2iaxsOPPc7ds+dgClbyCMEk1S4zpoVj8yMVhQ1vvk2iw8ne1as4VFVFYcDPjO49yG4WpnM2q8aIsp8+tTeArGl0RDVUW11D/A84lxJpR9m2A0EUWPXBR5x5/z0ICQmnPrADhPpMMptwNbiQzSYsZhMhYa4fYxSIzZ7Jj4Wm6/gCCk6bpYVxE/I0KIqCqZW6q6bpHXoxQmMWBJNSoU3OV0f4NReHdBJkdeInQxDAEXRt6rrOZQ/+gT5Dh+JzOrn/T3/mhauuYe6YcSj19ei6zrO33s5Z99/DBf96BoqLcDqd4UzyEHWuLSeHtLmzsY4YQY9550Pf3uxbs5b49DTKt2znyKefU7xydZuBSBWa/g9UVpH7yuv4y8qp2LmbHsHJqW5DkwdFq6qmbtdu/NV1HF+7Htf6jZRt2caQ4UPxVZRTvXMXRz/7As3rRRAEyn0ebL16Et2rJyNGjqIYw5AoAbYBFcDtl1xMN+BgSRGyrpN+9gx6X31leKDrNmcWt990C28cySMlIpqN/3oe3/5DiJrGmNt/w57PFnbY1+VLV3D4gw/xl1dw1p8f5uYrryRj6lns2L+feo+bl377WwqLiqnAqFb5+IabjL4tK+PONWuoLymmtKSEhY/8lSRnBEXrN9Cway/HV64GVcVf37GHIITkGWeRv2QpeL30mnc+x79exuh770L3+iivr+XGxx7j9pdeYunfH+cfy5fxtz89zLTrr6VLVjbCSXIfstrJm0kfNIDvvvySmi+XULxoCWpVVZt9zF2ySe3etcU2ISeb+qXL0VyuthfSdQJudwtvha4Hkw/dHpxA7LgxREc4WyQWKpoW5vBQNAVnYyNWp4ML//ww5/bpw31dutBv8iR6TxyPp7KSwNYdeKqalFlNPzB8oUKHI7TNaW//gw4Q368f8tDBSIMHMfr8cxF+giR9CIFGj/HlN5mwWi1hr8OPRZN0+o+jyTbUSgPIQUK+5ucQgsZkewRipxMaCemV/JBW/ZrDIZ0ei078ZOg6qIpqUPZKIm5NRcH4MkcPHUp6j56U5x5i3lkzEIBbzj8fMTjBzH/rPa5/5w2Dj0FREXSD1U4WRUSTjCAa2iJYrcR2yebxa6+jZ+++zHzun/iOHqVi8ddglkmYOhVSkxFLS8NfaFN8HL7ySqKnT0VuJsqVkBzkEFAUqtdtIH7OOcQCGcHPB06aAEDKVVcA0LBuA6Wff0naZRfRZUB/4oIiaAXrN2PbvJEJgAmDHOvs/gOp9/q4b8M642TbdiAEY+TqvgOs/fIrJj1wP/2vvpx/9+hOY0kx/dLSeO9Pf6ZXn570mTyZbmPaT0wF+Oq997BEOLj8pX8D0P2WmxA++oSGujqiBQFpyyayhg9lntPBY7t3YT2ST7e/PUrWtLPohTFPHakox7N+LR80NnLp8UIKjxzl/HvuxmS3o/iMXAuhmau6PXdxz/PmkPvuB/S45kr2rVnLluXfkBEXy9zbb+O7Bx/ivb/8iWWffMbTv7ufr1ev5US9G2dyEqqmIQgCcjuZ/wPOPzd8PS2ggCigJ6cw/Z67iOzdB//2Hbx1y21c8o9HsWZloikqoklGCyj0HjEC15592Hv3RFNUrCmpBHw+KjZuImbMaKOcVhDQNa2FjkeztxhN09ny6BM8+dEHWDMzW0xMYrDNoS0eRWP0nx6m8rvv2PTFl3yxayfbgDcjI4nrGywljY8nYuMmqK0FsxlJ143EUmhSahXFNqG7cIvKq6Bv+595fD7a5948NXSbHU0UEXUdNB1EgaCQR/h3qJ8UlwvZ6WzzuaaoSGYTgiSDHjBCRj9xiR7yGGm6hsQPr1zRdB1/wBA7a+9Ys9mEoijBBNFT04c3bxf88FX46VSe/F9Fp2HRiZ8Fbq8Ps8WE025lxUcfM+HKq9n/wXsUlZSx4+hRzgM+D+67c+ECtn+3hvSMLMZOm0Lplu1EDx1Eo8eLFghgs1gQRAFNVRBECV1V8JdWkGp3cs+SRRz98GOOLF5Kz3NnY8nJ4dg779PoWkhKWgauouMEik6AKKHU1pG3chVp/fsS28ywUKw21C1bOfrNSrr95qZT3lvEuDHUu1fg+m4teRs2hw2L+EH9mZaSRqLdSlxsHAlWK6kTxhE4UkD92vWYIiKo2baTOL8fv6pQvGY1k/7wh/B5k4IGhL+0FLnBxcS//oXjC74kbUD/to3QNCr27sPssIWNihCyZ8/i8KP/oP8D9zNk937efegPVAQ/OwC8sORrLqis5PY77iBw4AC3/+YWPv3TX5nZvx/Lly3nrnffZP4f/8SFk8az+MmnmXnrLZjiYtvEopuv3vWICCRBZvfb75I6ciT4fDgbG3Bt380Uu4PP33gTS0Al+eyZdC0pp3jTJrIH9DOMlFMM5oVfLyN53FgEs5lGt4eofsZxccOHctXrr6IFE/w0TUXQRDRVxdanFy/f8htuev1VdE1FEEWqi8so3LmHmpJSus27wAh/qAahkdiMtyN0X35/gN2FxxjXyqgI7SM1u3+bzYIkSSRPmUzylMlMefhBcj/6hJ5B4ygET1k5iAI2uwO/zYrpYC6KqmAxmVECCrX1tTitDmSzCbfbhSRKWGxWfH4fvqITWDqYnEw/obixvq4e6cgxrL16oHh9yFYLiseLbLOGf/sbXJgcDhq3bMU5bgyqL4BsMaP4fEgWMwULvyJz5gwE9J+1zvLHhkNCVSmiJCB3kENiUH2LqKqCJJ1eyW/r43/Ivp0ei0504idC13W8Xj+RdjvukjLe/sffufyJJ+kOTBYMEaLRH7zPfZ9/znxF5eLIaC554TkCAQW310uDy40sS4hmMzaH3VA8DGo+FC5dxsHv1jFq2lRqVqyiuKycSbcYBoEsinQdOABh2BBEWSJuxBBKvl5G/MABHHz3fQZfPI+K/CPY9u9HLTyBY/BAxEgnJQcPYEpMQI6OPq37S5tmGBNxxwo58cEnpM2Yiruqhv4pSRzOPYRTlIgbM4aCr5ZginQSPXEc/ppqxNgo5IED2froY/Seeka7q9Olz/2bIfPOAyBl3BjWvfIGE/7QMsGxsaSEF2+6maxu3ShY8S1ZZzZxO7x444248o8wBZGhd/6G5RgMoMMxSLyGAAW5ucx+4nG2NdRTU3Ccvv36s/ijT/j9N0tY8LsHSMtI5e7RY3E6HMz6/f0oXi8mW1M+S9uSQR1nSgLZ085ECCa06X4/hQu/QtFg77ECukZE8u0fHuarnTuIVTTmWi3Ejxtzyhh1eVUV6TYrAa8PFQHRZGoS9Wrmwg+ReoV+T5s7F6mmBilYFbT0ow+59tG/olRW0pibT9SAvoTmE6kVdbQgCKglpXTLyYHSUvTk5JNOJCXFJSQ0yyXQ3G7SMwyf1+G33iG1ew8cdhtVQPZIw4AMpWGGfDUytMiTaJ3M6aqtp3LFShyRUXgDhjFS31hPbEwseWu+o7skEREViU9RMPXtjXSa4Y3Y2Cj8peXY+/fFLMsgCE2/JRlEAUtUFIIogCggeTzoldUEvG4Ujx9vTTUnDuWRc6ERjhEwvI1m00/3Wsiy1K5C7akQyq1oTwY9BEEQkGWZQEDBZPrxFSetz9n6c8N4Jiys+GtEp2HRiZ8NPr+f779YwKaCo/xl/uf4gvFMPeiiTJ53MV9ccglLH3mE2PgEtF27aMjqgt1mxWYTjcGNpi+rZDJx8LW36HHBXLqedy66rmPdsJFxUya2SMoqr60mQVNRfSqyzUpUZCTmtFT6/+5eAKq37wRNZ+/Kb+lnMWNJSyemW3ec57YkZQqxUQony/w+nMf+ygqSenYnXhDI6NWH2qJSbALUlJXT//prWfPW2/TSRRoDKg0VldS8+jLZsdHYMtLZ8twLxCfGkzlnNkVr13Fw01aSlQCDrzeqNg5/uZgJd97W5rKOtDTiMzPZnpeH929/p8eadUz5q8FGecvjj1FVWIRYU0PJ/IWcjcB76IRIo6OAEWdMQ62oICMzk4ThQzn48cfER0ey9b33SUrPYPTtt7Lki4XQ2Ij7yDFszbQ42usLXdcRE5JY/LsH6DZ4MF6fj9yCE/Tv2ZXIrjlM1DQaLCYiRIGAScblquHY2jVU19Uy5d67m/o7dI1m1xp2wXnoogheLw6H/bST5ZBNKOXl4XLjXr37QGws+9/7gP7NVFI7Qu7y5fj27uGdPzyEH4GrH3sUU1JSm/vWdB2PxwvV1RDkpTj29rvkBK/RpX9/5GCJbHZQn+PHICYuHtOwwQiCEK7ocAAoCkOzMsBuB7MZq9cLHTCntgd7jx4EQu94qG9Dv0MhglDyq8dLw979NDY2ktinF5LVz67Vqxg0dYphjGkaiqaj+fwGZXerazXPneroPTIuH/pcQFEUzKdJIhY6h88fQJakFqqy7UGSJHxef4twyA9BKBfHUPjt2DNiCJX9/Hwh/7/g1xsE6sTPDk3TyZ44iYf+9rd2JwNN16lXNKb94zEqKys5dOw4omhUk5iDzI8tBp/yciSnHTHoVRBUlfKiIkzNSYYEiIyMQrZaEU0mGg4dpvTECeOj4Pnihg7G2rcPfW64jvJDudTlHcakqeiBlolcBV8t5vBXi8OqhQD+8krQNGqKinjv1ttRMjIYedUVmIYOxiVIOKsqGHf5pfgcTuw5XdixaBFxksihZ5/j9Ycf5sCiRRzZthv71DPwHTzA3p27cHTJYeWzz1N+IJdp996BGGvcT9H7H9P77BnGhBFE/sJFBiU6kJqeQb+kFAIOBwtWLGPlCy/y8o03I6emsn/XDrwWK7u+30JmTjYzgDTgKmAj8MX8T9n475dY9OQzHF+2nMJDhygoLyN/zVoK9+9n839eYeLIkfxp7Rp8qoJkOfnALooipXt3M+vJx+l1+aX0vvxyIidOZU9hCXn19Tx7YB8NBUXU7NrL7poaEoHy/AIUn5/cY0UUFleEq1D0Zv298T+vsuG11/EXFLL8iacwB3MyTgepg/pzYuvO8P9pQd6U2KyscJ5LR9B1nc+WLmVtaQlXvP4qg8eO6XAi1HWdXj278+nzLxoTSH09dY0uvLv2ULNmLSfy8k+rvaeC1+Nu/wNZhsREcDoNAq3IyA7zNNqF2UxU796ntasiykSOG0PKWVORMjIQExKwxsQQOXJ4OFnSbJKRRAG/P9Cu+/+HRAQMEqofHkbwBRQsJ9EiCcFI4hRQm0nSh57p6V2zKcG8NTTNECjT9F+vQRFCp2HRiZ8Vbq8PunXHE5SObg8ut4cpf/ozWWdOISrC0XHNe2Iih/e0ZFfUlZaS1/j9FBccN77sFZXU7t5D5jkzw2EUgONrNyAIAs7EBCxZWcROPwtVEqn6+msKPl8Q3s/u9dNj7uwWg4bu93H840+xFZ5gyvjx9LrxWqKC1Qv2Pj3oct21uAuP0z0rg35zZ5HTvz+xkolym5URffqwp6YaySRjOlGEyWbj2jdfRauqweFy0XXyBPIWL2bYXbcTKCuHCDskNZF7fX7HXRz49ttwot+5Tz/BjQs+o9f0aewG5r//Pmv27OHeMeMoyj3Clvc+JCU+keJaF8kmOyKwBDgBHAc2rl5NVaOLVf94mt5jJ9A/pwc1Hj+VlTUcyctHTe9CYWkVkd27nXSADj0vTdMM705wuyPCSfbMc5jwW8NT5KupYn99A5ckpFJlj6DLoCEcP36CvZ/M56snnmTfR5+Q/9GnlCxaws7X3uDoFwsZMHQwuzZsYuWrbzDz4YcM5dvThD0zE3N2BtuefxEAk9noN2+jq8Xkoes6gaKiNtvyS0tZB9w2djzLliyBjqildbClptCndy80TWP3518w6NZbsI4cTszE8UgnK3X9AbBYf3rlxo+Fv6YWgGPfb2qx/fiadXQdOAgwPP2KqmI1m7BbLfj8AdRmRmIIP0T868cmPFpMMoqqdvh5c8PBZDKFq0NC21VVDXsjmmudtBf6aHLyCC3Ooesamhr8+RVzWEBnKKQT/wM4HcPfr6r4VBX7KVYYQ8aOa/pHlomIarnyLFr5LV3PNvQi1KPHyJx3Pqo/gK4aK2FREPAUFMD4MTRs205aMM/B1rcPtr59sB8/gXvNWtz19ZiTE/GtWoN10oTwCtCSnkbS9GmINTXEJzbV/WuKQt4bbyPV17N52zaGjxvLsdfeInHW2ezdtJHdO7fTNSGJ7OxsZrzxCvj9KBs34zmcj9ksMe4PvwOnk0BxMfWFx8lfvpzBtxmCasfXrifKZicuPZ2J993Tpk9stfVcnp7JtIsuYOXSZXTr1Rs9K4eSNasoqKwiNTOLuoJCeopRCFUlJAMFwBfAKDSqfC6Sd+8j7+hhJOA4OmdNmoSnvoHD+w8TEzX4lK5oQRCIio5q4jOQRCIj7GRqCrtrqrghLpmIjHRSLrkccg+x/vWXOFhUhKNLJmlnnUW6INCjVxfMJhlRFEkDcLlY+e8XufWlF1AdDoMJ9AciZeIEXEUlxj867H7ldTInjkPTdISAn61vvcOW9RuIcTi45KUXQNf57Imn0X1eQnd8GBBLSnnxnt8x9dzZ9Jo9q0XoTRQBVcNiktjx+pt0nzgeoZmXKSE9g58Dbq+CmZ9Gbf1DEF7Bo/PGtTcQkESivH5O/PZu0qOj8fr9xPbpQXnAR9bwIWhBNdJQRYjVasbl9hLhsIUTXU/Hg9D82mCweP4QzRBBELCazeinSGrQDMvBCOGoKoFAADGoHhvSKRGEJuOmPebPUFJmeznIBqurhB7kxfiffl6/ZHQaFp34r6GuwU2Ew96Gha85THLLFYzF0dKwiLA7kWJi8O3bj5BixMMlswlNUVC8Po4tWULXWTMBkC2W8Oo/9KW3pqdxZNUasmfNRI6NRamtpWHJciLOmU7j8eMUfbeO+q1b6TpuHPU6yPsOEhsdRV1VJUX5eaTHxzP2jMnEde+OVRfY+NTTDJ53Af2nz+SLp59mgDOJ4k1bcSTGETV8KPVfLADJarixK6uQbHbKVq6i/0UXhe8pY+xoDrz2OhPvusPYUFvL8tffZNo9dxltd9oYf965VFVWcc0r/8GnqCx//Bk8AY2UtDQaq2uIGTuG3lPOYEBeHgcWLsBXVEAM0B2RQ2jsOXqIs664ErdkwaQq5OblknbWOWji6buhUwf0p3TZcpLPmsbRZcvINlspralGP3iIpVWlnJuRgunIISIG9ueSCRNx26z0ysgkS/HgGNDPILESmlQhcTo543f3gyAg6jp+twdRltulGT8Z9IBC/br1fPneB1z33NPIwTyJNS++zKhZM3E3uplwy00IQEPhcXw11Uy56kqmZGSyq66O1G7d6DHzLF695z4++uBDBq9egz05ib59+iCbrZjNZj546kny/X7+ufirNnoeR/fvo/fIYS0b1eBi67vvM+zmG047bPH92jWMEnRkSaTqxAliBw/EcQpG1p8CHUNfQ9d1uo4YztRWDKnVBw+y6LEnmHPLLWGGy5D3ShAELCYTugaNbi8Ou/VHlaAahpuAqv4wMTLDK9JxDoeug64ZXgVo8lpYmomPhq7d/Jzttb81X0dr+nHxB5Sy/l9Fp2HRif8aAopCdV0DcdGR7fIaAJQfyiVuwriwqFRuXh7DJo1v2iGUlV9Ti61vn/BmUZYxOSSSx44Dm43A4XxMKam0h6ScLkhBvQk5Ohox2sjPt0ZEIiMSP2okMeefSwzA0uWcyM3FW1tDbkkp+9avxwpc8fobWHr3YNzIYex44I8U19fRNzkZxSzj3vY9HoeTencju7bvYNpfHqHg2eexZ6UjpKWTOXEickKz+gBRJCDJFK/+jqrjx9EUlYxmOitj77qzRfvL1q0lKcrJ+Dv+jsNuxV14Av3IUZzDB1If48R/YA/7igrQgOQ+vdm8fx9n9etPZMEJEsePJumsaYgff0qv/j1QLVYcp8ivCMHcowfq3gMIgkCkDtFTpxANBN57n+PAsapqqpctpbvbzfeHctlfVsIlvfugVlZiP7CP1EEDiezb11hJ0iyBL+SydjpR3B5MDttp0xgKgkCXyRNwFxdz2V8fYc+n8xlyu+EJmvibm1n41LMk2C1UHcwlfvAAlr/8Chc+/EcqvllJzLjRiEuXsvWLBVgqKzhj7DgK9x8gMiWJ4Tdc12J1PVtVOHzieLsiYXu3bEF2Oul+4fkA7H//Y3Sfl36DBnFs7XqyJ45vc0x7GDz1TMyDBmCSJJISE5BtP4wU64fCyBEw+t5isXDg40/p3YwGP7ZXLy5/7RUOf/AxEcOH4lcUIltVYVjMMqDjcntw2Kwdfq9PBlEUf/bERyFcwSMCOhaLmcZGN5qmNQu/GCbu6WqAtCbggk6F0xA6cyw68V9FvcuN2+PrcJUclZHO7o8+Jf/Tz3DvPUBU6ANNo/Lb1WxZuJCSLxfjrijHv3kL3k1baNywiYZDh41s+tRkNFXDXV6OKScbXdcpXreOJQ/+ETAGhEPrNobpv8FgcnSv20DD8hXkXHQ+2Rc10Ul709MxxcdhGTacsYMGM+OGG+k3bhzfz5+PIAiYHQ763X4rvbOy2HjwAHkHD5E1ZxbVubm89e67DJo+jRfvuIs9R46gVNZSs3Ezlj49ceXnU7ByVfg61qgoKo4VEqisoP+MaS0G+NbInDKREb+9FYcksOPPf6Vg5Qq8dbXIFeU4amqo8fvpgoADWL5/H9dkZDPz5ReJGjaIb956h+/uvpd4twdbVCSREQ4EdDRVRfX5T+m9iE1LoXrrDnxeX9NAq8FdgwZz3VVXMPPKKxh62aVEqwFigKFXXcGQe+/i868WEdG3D4qmhn9UTUVVVRTV+I1gVCdowZDI6SbZmbMyCVRWEdGjBznDhlH+zgccW7kG3WTi80VfUllcSsDrQ9N1EhMS2P/sv4ga0I+y3Dy+WbaCsdPOJOPyS8meO4ujNdXUBZMxm19btJrJiE9oty1xUVFs+udzbP/H4+S98TapMVF07dsHOTP9tI0KXddpOH4CBGO60/Sm1fb/BFr3a++zp3N0x862OwoCNpstnH/QOidCEAQsZhNWs5lGjy/sAWnves2TpJtP0pIktvjsp6B1qEUQhTBBmiS1LG39NfNO/Nzo9Fh04r8KXdepbXAhiSI2m6VNNYnFbmdAUKei8MNP2bHmO6yJCXhcjST370Nc3z6kzD67zXl9u3ZT9tnnxI0dg5yUSMSoEUbMXhBIGTsWc6MXpb6Bxo2b6TlsMNXbtxM3fDhlu3aRNHAgrupaHCZTE0NiENZ+fbD260NjWRlqfh5ROTkUlZYilZez99XXiY6JwWGzsWv/AZYCvdyNTPxyMRZNZwmw5Ol/ArDhrTfw1dYh7tjJvqefwecPMOSeO8PX0UTokprM9txDzP/jI/QeNYbSqip6T5lM2qjhLdrkrqikfNVqXG43AZMJpeAER9ZuYHpqKtbRI5k9eiQN+fkUfPU1aUMGs3f5NxQs/Iqi7TsZMXYUDQWF5G3bhiUni6RxY9EUlVX/egHcbs7844Mn9xakpiCsWE1Gs2dgt9vpN3wYxS4XXc85B1EU6dGrJ3nrKskePw5d03ngow9Qda1FVNwIgavovgBGOZ+x2vU3eLDGRANwdMMmirdvZ+xtt550ZVntcpEARI8eCSOHs/uJZyisrWFAThfOuel63HUuir9cwseffkoB0GvNGoYKkFtfzyPPPcez8Qn4/H7KcnMZOmESm19/i48/+JAzxo9l9JlnsvnTT1n+/VZ2PfooAInAuZMmIVosbF+zhqEJifS9/FI2vfseEUkJROV0QWjulToJQpNubFDLQ1FVFFXpkPjp50LzHIXVb77DBXe0LXvWNR2Pz2NwXGBoqEitnoMgCJiD9OWNHh8OqwVJEltM8rpOUwisFSRJRlF87eY4/Oh7axYSEYUmQbFAQEE2NXnJToVfc3jjh6DTsOjEfx1en5/y6hqS42OxtcqEb6itI87rBauVzCkTcaanEDveSOhUVZXUghPtntMycABxioKvvBzyj+BTFcwImPv2wRQbQ3xSIvWlJagN9dgz0qnZtovI2FiSBg7EW1tL/Yb1xNx0Q/h8uq7jO3yYBU89ywUP/wFN0yjy+zk4fz6RDgdJXbpAVBSROV0ICAJjrryCzf/4O7HA2+++w7pW7Rtz5jQmAX9b/S0R2Vnkv/4WWkkZYpaR+CeWVeM8dyyTZk7n6BcLKSkq5sx772x3VWVPiCd73gXoPh/PXnkNhYUFVAJn9+kFgFZfT+5nCwiUlhLo3pVIWSJOlpFHj2Tl0qXY3W6iamvRa+rY8ffHGHLrzdTt3cfYEcNOGYKwxcdTExVFTFwsYAy8EXY7dXUNRERFg2AwIZ7z978T86e/GPcmicaEooGiNyVo6ujo/gACOma7PTyIy8F3Qgey01LI+67xpG0CsDYP54giqUMGEDf1TAbu28eB7zYQm5GGGh3N3TffQqMssnfzFi6eMI7Sjz+jb5dsiouLcMbGMbZnb+IGD8DhiGD6yJFUVdcQM3Y0c8eOxnv3vSRt3kwUsAawnjhB97598XXtxhVvvApmM736DyBx2LDTNiogpEui4nDYUIP9gqb+j05qOi09FjnJyexd8BX9b7mxzb4REVEGi+VJ8nFaGBfeJuMCmnRXJEEMGihNx+i6jhjczxAH+5luUBDCZc26JBnJvALoumZIBgSbYdxO20qQEOeKQKdxcTroDIV04heBgKLS0OgJu0BDA1b2eXPI/3KRsZMk4nF7mg4SBNzudkSmgpBFCcfAATjGjSF24gQkQCg8zsEPPsZVeAKOF+NMTUUeNpSUyy+l8cgxfLmHsURFISYmUvbtdxx8+33chcfZ8fhT5G3YxLm33EzRrj3seeNtKvYdJCW7C33OP5/y0lK6zruAQGQEcYMHsf/blUQAxUBb2SMDq4FZk6aw+pG/EDFzBu7yco4v+hoAzSwiJhtJh13OncOY224Bs5nvnvgnG556hpq8vLYnNJsZNnQIPiAPeH/6TBpWrKJ+2w4G3nkbYkwMNbv34OzdG19UFEl9+jBi0hT6TZ6MpW8/amqqSRsxkvIvF5Gbe4h31nzX4vTthSJOLP+G1LPOaPFZaWEBr73+CqkjhkFwwnJt38Un367k6388EV6lioKALEphL1Uo/S5Mtx0kcBKCs8uqx5/kr5deRZTZRMWW7zt87gAnSkqatRuswaTfyX/4PVaLiYRxY1BPFPD6/Pm89vIrTJk9i83rNzHmvHPp228AsTXVxNgsxMoiJlXF63ZTUlfD9EsvCvMYnPfwQ9z95JPUAf/64x+5+N23Gfr7+7nhvbeN3AuXi6qaaoRmJcSngq7rYU+ON6QrAvh9Cgj/c8N1yIMA8NX9fyB71AgaKyva7CeIIugqHp8fRdVo7XNo/n6EjAubxYTL4w3uD2pQD0RrZszoupE4qiiq8Q4ElUh/tvCEHjYL8PsD+ANKmD7c5/fjDxgaIiEDS9P0H1Uy2qJc9UdUNf1fQafHohO/GLjcHuw2CzaLuSl2K8sc2rufrvNA8/uxBicdXddRa2qwmjqu9W+srmkh1BQQBKyDB9Jr0ACU6hr8efk0NrrYc98DOCMc1NTUgKIR1yWbzOwsGo8dQzpyhMbUJEyuRnJGjcTcsweZg/qTOXM6itvNx9fegNVhJSI6ityPPuXE2nX0uWQe6RkZXNKvP8tefw2/xc6tOdnkHtjPHqCsWZsE4L3iEwx97lnu/mohckUF9Uu/wRmUf1d9vjBV85d338fQ888lbeyYdu9XEATG3XcPqdFR3PvmWwyYPJV6WSZt0nh0XWfog78j95l/EZGexoFPPmXsU4+T2NjAhqefJb1/X47m59H/xuvRdZ2bMjJwjB4dllEHOLLoazRPIxF2JyazidraOo7u2E7igAFU7tiJMzGRvMOH+fyDj1FkGTEmGsHrQ6mv5/3HHmNwYiLnPPj7Fm2WBAFBF8Irct1kQtB1/A0uZJsV1efHHGHIjR/avZeUrl0YesdvObFgAfqI4eH7bvEerdtA/+nTg+8J+BWFuro6RK8fs0kmZdxYpk05Ey9wZf8B5NbUkLd3P2WNLra8/AoXXXIRK75dzU1jx9LlkUewWQyZ7XFuN5GDB4evY42NxTpuDA1A7ZGjhLhKNz//ElaLmZSUZPpceUWH72drNJ+UBARwOsIrZJvFjPgDEyFDLKGt2Si1ZqRjTeWTwbJhUWTM5EnEjhzBqD5tSbQEUcDn9eP1+omKsCOJbQ2L1kmNJlnGbhVo9Hhx2KxIooim6mGDUtd1GlxuAooKugaCiCwaRFYIhr6HKIo/TegsWMlRU+uisKgci9lEWnI8Xm8ASdGorK5HFAVMJpnstKRw25vfR0fhEl3X0RQFAQE1EECymNFVDcXjxWL9n024/aWi07DoxC8Giqri8frCbmyltJSlz//bSOQDxNRU/N9vDQ+CgbIKkjqiTPb7ObBzO5k+L6quY3U4iPT6aFi7AbPVTG1JGXWl5XS96lKiN2zh0IoVJI4axfCzp5N38CDR580lRhTZ/ejj2Ovr6f2H+3Gv+Jba3MNIPboR2asXRctWkBwdRUJ2F3Yt+Zrh/QcSe8YUGvcfpNvsWZTt3M3wvv0ocrs5eGA/yV1ymNmjF0uWLSEdWI8Rmz8BfFlVxeIx41ix7GuEnGwsO3ZT/flCLGYzfknG4/UwYs5skjswKrwnTiBYLBxb8S2yM4KXr78OKTKaot17SB0/BkGSEEURU0IC7rIyKjUVZBmvLmCJcFK+/yCTH3uUohXfUrB3H8VHjtDrSCHdzjoDb30d3qISUtJSsOZ0oWbdBiQErGYTJ2pqqdl/AMXVQOS5cxg6bgwZ6Rl8tWY1gmAogqrOCG55/hl+f+vtLdrcXDVSlGSDsVCWUX1+TE6DOE0LKOH9b3rpeda99ib5n81n98pvSRwzGrW6BqWklO9Wr2HK1VcQ0b079dXVpI5r6qfCE2Xs25dLn979SIiNwme2MRiYNWsOg2/7DXvmf4Z5yCh6J6ahZXZh5579FAsC9OzFkcJiumQk4/H62bh3PynTzsQOqBUVfP3y60y+6TpuuvFGel5xGQBadTXRVhM9b7juh7z6LfrEJBnDsnnAgPB2TZTgB8qu60Cj24Pdag2XTgqCQH2jB3SdCKc97LIOVYPsf+tdMkKso5GRbc+p65TUuUi0mttIk5/snkJhEYPnwihFDRkKAUXBr6jERjnDHBMeX4CAP4CmBwzyKnScdlvLENcP6Ytgsml1bT0JcVFEOh24vT5KKqpxe3xEBCuPNE1D9fmMMmeBFiq/ze9Vb5YkoqsqqtePZDEb76yiogUCWKJOzvb6fxmdhkUnflFQVY3C79bx8RNPkJ2ezpQrr+SbDz8yPqus4tiO3TijYzhecJwYi43kmWe2OYdWWcnBT7+gz4UXYsswyjRDg0JoqEwGfJ9+FlyEqPzH7+GC79aQmZJERHw8FZ8vJOnC8+h97ZUooohyMA+3olBZXU1aZCR5CxaSduGFiMkpVFdXkj54CKs+/oie2dkcq6oi/8ABzDV11HpcbCosxAt8d/QIpUeP0FOyUqB6KQQ8gAtDsj0fGHvWDEYBT7z/PoKqIHfvhkPTCCxdhlWHyhXfEj9mVAvab4CjX36FIymZqtxcug8fQdwF57H/o0/pNfccjn6+kC4XnGuUYl58IbvfeY8BEydRvWETyd27kXDbb9j8xltsff4lYh12hv72N4yy2XDl5nHo88+JHTUSc5csrL17GQRAVhvRZ04mGrhqziw0TcNfUYF3/UZs48bgMZnw5eWx/YOP6H2+Ia7mV1S2VJSje30IrfJowtowgoSuaSiKQsDfNFCH94uIZOwdhnESbbNTtGET0dnZxJ85hTlTz6Bs0RIiunfHZLK2OH9AUYkxm/F8v5nvN23hkY1rAcg+cpSdjz1N0dbNZC5eTlKXDAoKTtBj5jn0E0QOLFjMoR3bKU1Jw+50oJWUhqsI6g8cZNDggTgSEugZ1Ag58u0qqrbtZPhpKOa2h44maYM624/9BxaFCBi5Jr6AH0/BCWxZGZhlGY/Ph9vtpcHtwWo2E+m0gwC1R4+h+/zE9urZ4TkVRSU2MRZ7q2dzqnsAjJwMDN0gq9nUlMyp6aBrYcNHlmWckoRHMLQ9zGY7fn+AxmaLjh+L2KgITpRWUVXTgN1mIRBQMZlkzCYZq8WMJ1gJJQgYSq9WCwbFuCEjrykKktkCukbA7UGymA2vmtMRDNkFw3g/sZ3/v6PTsOjELwpmk0zSpAk8MHlieFvcsm/Y8+J/sMTEMvrhP6ALAr0CAbY99SzyzkRiE+Lx1jagej2IkkhjQwN9brgGXZI6rDsHiI6JQ7Za6HPJJTwiiry/aBFT/X40TcXlchG9+jv89Q2UHj1K6tjRJJ83l2QAtxtHdhYNB3MpW7aUen+AOLsNIToKZ6/esG4d6YMG8v3nC5lx1ZWse/JxDgARwE5gh+qlChgK+DCUSCOBGci8gMIm4IM/PsxV779jNFQUSZw5AwC9poaGzd9jSkujoqiYjMkToKiE6iPHOLBrD5MuOI+YM89AEAS6TZlI3vsfkRgbw+6X/sOAW24GWSZ/2w4mnzeHIytWkqb4iY+MRqqvJ8kaoNsN1yFYLCCKRPbqgXVzMnbZhCM9HcXjxeSwEx3VtJLVg/1qSUykuvAEvk1byJw4jnMqK9BFkW/+9TwWTWPNmu+YArx2553c8J+XOn4BBAHZakXxeZHMZoTgqjgk/BRK9vOhkT58CNbMrPBz1cxWFt11D5Ki0CfgJdJuw2Sxkf/dOv6zaCEjgXLgH79/hLpN64mKjsaemsaumnK+2LmDmqJj9AZySso4mJdHr2HDwedFra0mr66Gnbt2MXXXbgRBwF1dy3+e+ScTdu5iyiUXsWPxMhLjohl+310tbufg62+T3CULs9VGwO9FQMDpcBJAQ1c1/AE/FqsVxe/D4YgkPy+f7N498Wu6odoq6AQ8Xmr278eekXaKb0/rrhQwm0yYZJnKA/uxZ2eiqBqyKCFJIh6vD78/gMNmwWSSOfjya0RGR1H/3VrQoa6hnowB/Sk/lIc9NRVn314IooDD3Db82II5UzXypCRRDHtKjBwKY7tJbiI80zQNt9eH1drSGBQEIyzhDwQwY0IQhXCJ648LhxjvT3SkE7vdiqZqmE0yqYmxhpKyqiLJMiBgspoNj4osowUCaKqKrqqIsoyu6aheL4gCJrsNQRSDz0n4CW37v4dOw6IT/1XYrBYCAQVFVYOrlbZx5PE3XktNQSEZwWoQdB1kE3sPHWDYdVchWCzYM9LDq3hn6Mt9isSvGo+byNJS9Pg4Rt/5WzL698NXeJzukyYgZWaC14tn7wGSe/XEfzgPh9ttXMNux5ydRVx2Fi5Bx5qXz+HvdxCTnEjB9u04umSzc/VqIpw2Nm/aSACC2f2gADYgE+gnmVinBigDEoANKKRjhEYufeQRVFUzBmZdR9mxBzU9GUtSEhGTJ6Ls3kt8dTWaooAkMPT661j56qthowIg4PUR3aM7cXNnYzl0GN/GzVSVljL5xhuIHTyAmEkTEc1mY7BPSMTWvRuHFy9FSEyg+wVzAeh51eXBrtQJuBpBB0XTwwOHAOHKkbjhQ/nmrntxrlxBRFQ0fS84j5hp03jn1lsZ2DWHJVur8e7aHVaQbQ+CICCaZGTdEjZkQtvD1wMyZs+i7MvFWDOzwpNa8tTJ5L70ImefPZOkEcOwJCVxbM061i9ayNioGMrqarjpmuuQ6qt5cfUK/nzXvdT5POiixEVjJ+ArK+bMa68javAgeuVkkHXOdOLTkilYv4Ezr7+eDSuXIcdE4ezTGyfwt7mz2PXGW1TkHmb47Te3ez9dRo9EAMzBCp0QQlOztfn/ikJyYSFSVgY2nz98s6aAilZeAT+y3FQQBGJj47FbLei6jsUsY7daKKuqMUisTDIly1cw/KILcQTzVlAUIisrKdi6naxJE/DkH6X66+VoZhOexiZxtBbMluj4/Qr+gBLmohCCIQ8tmJxptRghlBAltsfnRwDsVkubSVmWZfz+AIqiIEsSsizh9nix2zqWRu8IkiSh6ToCYJPM4XbLsoTi8SDIMn5Nw26ztih5F00mRFOrMEjQaxVKKg7lspy2Cu+vAJ2GRSf+q7CaTcRERlBRXRtmwVNV1XCXBpM4nZmZODMzWxy3+613iOvaFSFI19zRV7p5klprWFQNISoKk92OruukjB8HooTgDKZ8Wq1EDwsm6+Vk4/p0PkJGOo5xY8PnyDprGvo0ncoPF5BQWcaR0lK0/COsPniQPqIFd2EZWciUYOg+HAJqgZHAbjVASAczBtiO4dVIB6qOF1O59yDZZ02h6MOPKc89RI0sMfvvfwNA7NGNyl17yP/dA6QOGIg5KgqlVdVARLeuRHTrivfAIYSyCn77wO94+I47iR08wHA7N2ON7DpnFtHDhtC4ZQs+T1sBOSG4glMDfqxmU4vtYAyuu+d/wZ7Dudz9yDtgNrPt62V0mTaNq5/9J46YGOYB1du288lNtzHvpX8hdCD1HTIudHT0oNBZ62eo6zqR2VmUrlxF4pSJGMFuncOlJfj9AYq3b+fj197EHlC59aGHSJ9xFv+4+DIOlBRRW1nFvBEjSO3VA3Xr91w070JWLljInMcfx5mUgKKpSIofk1kme+JYUrIz2L/4Sx755zP4847Q4HAQkWW8jwOvvbrdewjB0qcXtctXtjEs2oUs48hIN+jenc226zoBu60FidsPRVVVBRE0sZvabBaiIhxYzCZkUUSta8Axc3qLtpCcTNY5Bh2+bWB/bAP74yotY8MDD9L9wnObN88o4EHAHwhgt1mRJaPiQtX08PdaEGiRgKlpOj6vH7vN0q5QmSAImM1m/H4/druMw2rB5faiah6czRg/VZ8fyWxqURrd5OVqaqSg6+iKka+heLxGHoUoIskyosmM4vMRCARa6OToeoiNs1m72qmB7TQqWqLTsOjEfxUutxenw05MpJOq2npq6o3yUb8/QHJ8DA67re0xx45RW1XJrD8+eNJzn2xVoxUcJ6pr17CXQxAELNHR6KqReKUFlDB/AkD99u1EDhpEo6ZQvXwlsdPOaHE+NTOLutpadLuDSFFm7JDhJEZGs+fgIRKdVqLycmkAYgEJMGPkVsQAZ0lW+sw6h8ULPqNbZBw19TUsfeMNsiefQeLCRfSYdgY9L7+4JVmX2Uyt6mfiU09QX1BAVHY2xYcOtrnnPR9+gnY4l/4P/YG//P4BCCbIte6nmOFDjX6vrmXz118zc1JbhkhBltE1DVd5GcLGzag+P6qqoioqHjWA2edl6kUX4fP68ZkspE6cRKPbg08SsQVd4zFDBmOxmFj9r38zuRkhWJtriSLoxqQhtLNCFQQB24B+LH3oEWZPnogg6Dw6ey47gb+/+w6ZgsT9zz9PzOD+CKWlCPsOEG+3MbZvP/wCFO3bj9LQQN9rrkJH5+yRw3D7m8obCwuO0CV4LUtWJoOvuQpJMNq04rnnOXbgINNnz0I2yWAxGwaQbMak60Q4HCAIuNwedFFAcLnZ9vSzxI0YQfb49pNvQ/D6/Vjb2S6L0g+TRm8FayvqcQGIiXSiajrlq9aQOWpY+we2gikmhsFTprQ8lxD6bXCWaJqGEAx3GE02DMOQCBgYuVT+gIIgiZiD+Qgh4qyQkaHrOrIs4Q+A3+9HkmQinDYaGj246+oxm81IJtnw2uk6qqIYBkUwbKGpGqJs5O0Iohg0UkVEWTYqjQShhcdNlmW8Xm+QlVMOVjufXnJqJ1qi07DoxH8VAUWhpq6B+JgooyywoTE8uKvtrNB0XefQV4uZMGf2T/pC1+UeImZqy8RPQRBAkhAR0FSFms3fI3o8eEtKiB42FLp3wwFYoqOpXLoCSRKI6dMLUlOJi7Bxwl3H2b+/myPHS3C99x5RcXHkrf6GJcCVGV357ng+WRj5FC5gX/C6H6lePpl+Fmnnn0d8TDR73n4Xb2IS8qFDVDU2EDt7BnIwBq3rOprfj3/NWmSLMeFGZWcDUHP8BEWr1pI2ucko6H/RBRCs17clxKK6mvGAtAN7375Mi4kxVseiCDW1VK5dT0y/3ogZGXjdblwBheTRI9s8FzBKO8tz83HY7aiKiq5ryEEPx9I//JGCgwepKynm+kmT2nAUtH6eksWM4vW1286Q+9keH0/l+o289/4HfF1dzdz4RKZefBEJ2ZnUHskj99sVCJGRZCYnM2XYMNJGj4K0FLqcf27TeTQN0SQjKCp+xWC4jI5un9BKkkTOvPN2qj9fQOyZk41+Cv2EShJNJtA0YgMBY7skUVV4jPcee4xz8i9g0NVXdvwA9I4SONV2dUlOF85WFR4hz4UoQt2JEySfMfn0TiQIOJwRzf5tG75QNZVwEmPzQ4PHe3x+PG4vGmAxm1ozYWAkS+phEiuTyYTH7cFmM/hDTLJMAJAFAQJKOFwmYTHCFJoOQtAYQ0cNKIZHo9X9h6+o66hqk7KpqmrI8k83GH7NFOGdhkUn/utodHuwWszEB8W/aoNeC4O8JoAsSYhBlr/DXy0hJiUFoXu3n3RNtVkZY3MYxoWIJJpw9O0DjY00VNci5+SEXbpyWhrxaUYiXeO+g9hPbKVm4wa6+H2ULfiKiuMF9MrJ4tDadTz51BOsnb+Q3d9vpgiIB+KA3cBADAPj1gvnMe/mG/j7VVeTceXlTLzjVqrXbyAiKQ4tLo76xUtxjhyBKcjKufn1N0mLiaHXxfNatD2+V0/Sxrac8BFF8Hop/PATvLV1mJKTiD1Jv1gz0yEulppvVmK223GkpBA/YSz+dRvR6hqQvF6k6Kg2x4Vcz26vHzUmFpMshV3tJtlY/a1d9S0mwA0sf/V1hja68TvtfLtiBVfOnk3kjLOankEQuqqAbm7DAKoH1SrLSkp4+ne/x4SOAzheWc7AS+ax8W+PMu7hP9K12TH16zZAWkqbtktB6nCLyYQ/YBgWXXt2QxLFIAeEYTCEyJMkUSQyKwuTw9HmXB2h9x238cBN1/Pl7x5gwLwLEO3t8xvoQvuTkYhwUo9FfXExkanti+wBWG1tPX8hWCIcEGS3PSVUFY+nY+ZTTdMQOyDyEoLlnB6vD7vDhtcfaFPl0fzZhzwXJllGMZlQFBWzRcJmNSMFRDy+AJIkItMUihAkKeQgAYz3RGpWgdIxmnIujHBIO4ZRq/BKax2S1tt+vWZFp2HRiV8AdAgnb8ZEOPH5A3h9flRNp6SiGpvFTFxMJF6fn23fruKSZ5/6yauJmN69aNi6nYhhQ9p8Jhg+UEwOO4ogEDt1CnUuF5EOR5ux3dHXiJ1PGWkkvdVs3EzP1GTiRwyj+9zZFC5fyVlPP85Ur5e7yst54OJLWQFMwEjkvO2qK+hz443M/fQT3nn7LYZecTn+QICE4UOp27WbqMEDsA3qT8O27TTk5lLe4MJks5N58bw2fZAzcUK7cfgjny/EFBVJyhmTcO3ac+rOcdiJOWtqi02NNivRA/vjb3CRENWW3yAEURBIiInEYja14Tm46s67KM3PJyU1hWP79tNl0nikrEy+27MbQRLZ+eY7YJYZeOEFCGYzWkAJEia286wFWPLMP1m09jtswGHg7xMmMOHBB9j12hskdena5pCAv633o/lEoGoaOjq7Pvscp8VMFEbeQOh9aNEfZhNH3/uAPpdf2mFftL6OaLVyxnnns/m99xl1w/XtvsNSB5Nyc6Ky9mAqOA4nMSwCzRJuWyN79mwqlq0g4ezpHewRbIOuU7h8hfGedQBFVdudlEMQBAFJkowET1FsUSHShpCqGaxWC263x2DlFAwOFYvJRH2jB7VZMnAb0bHTHCfCnCrBPjYk1YMhGlrmcBlU460N3bYVIfpPyIn5/x2dhkUnfhFwe3x4HQGsZhNxURGUVtZQXVePpukEgtS+iqqRl5f7s8Q0pS7ZmBtc1KxagyRAZFw89Ozewt0sCAKy3YbqC6C5XG20EdprR0wwRNBYVESgtJLaslKyBAHJZmPRK28w44wzUVau4Dvg3zNnUFrXQF9B4K6vFnL3rDk4rBYaPEZ9fNTIEWGXdeSwoVR98SVb33ybea//p91rJ/Tv1+695lx6EWCsJj/701+55pyZP7gPY5KScB8vQo6Pa9fFGzqfSZbx+vxN3h1JwmySEQSBHhddQPKiJaxbs4aA14ecbXBV3vLnP6HrOgM0HaW+nryvFrPv8GGGT5pC4qB+Yc2IFivG+gZm/OY3bP58AX6M6grdamX/ex/SZfAgYgb2b9NG2ylkx/0BBYtZRlc1LNrJXdnxgwfx3Ztv0+fieW2E6jqCIAgomkKXkaPZ/t4HDLn80jbPocbtIm7rdhRNxVVXj9lsQtOhctc+bFYrroZ6TFYbkiwR8AWIjHDiC/hpqKlB2LKVY3l59Lr04jbXLj5eSNeRbfMoyrftINbrw6VpBBZ+RerokZDYPgW5z+3B5/ZgT0k5CeeGYYydCmZZwqeoeP0BLMH342TvZLj81B/AGqwgEQSQJRG3N4AgBEDXMZtMIBjPEozk8ObGS0cI0XuDEXoJeS1EUWxzN+2dKlwdQ5MR0umx6EQn/svwBwJU1daRGBuD1WohLjqSmnoXfi2AruvUN7qRJZERo0aj+3wG18JPhGVAv3DZn97QQN3q71CcDuLHjKZs2XI8jR5sdjsWux3B6cRvMdOQl09E1xxkq9Vwi4fcrIrCwbfew2I2oVZWUVJSTM6wYQy8uUnEacDIESDoPDTrHNZ/+inxPXox5NzZHFm8hOyZM+ianMrBJ59GTEzAG59AtzOmYLWYkCVjYGyw2znj4oup3raDlJnTUcvKkGJiTjv2HqrsCBQUYA7mZZwOjn74KbIskj53NgGf32AWFAzJe4CoCEeYNlqWRBq9XgQdTLJETFRTeYNSUUmDaKLe68UmtCw3NVayAlJMNN3Om0t6dS1rP/2MgxvXUVlTizMignqXm5r6Orrn5BBjd7Bxwzr8JjNX3HQT+5etYMqfHznpfdRXVGCniTo7NJnput5MKwIGXnQBpYuX8MU99zPvqSeMnIl2MOKC88n9+FPqa+sY9pv2y03btKGyhoxJEzm2cwcHl3xN77Nntvg8aZLB3yLTVIqqaTpetxt52BBims1qoeCGBYPBFaBbq5LU0IQXEx0NQNm6jVQdOoTF4aD0RDEjJoxFHjvKSFT1evn0oUe48KnH22179abvyZkysYVwWHtob0IN9bk/oKCpKhaHHUkyNEd8/gB2q+WkBoBhWJjweLyoqoocNObsVgu+QCB8/oCqoOkEw1gCbp8fwWfw41g7CIk03yYFv2v+gMH42V7ScOv8jOb5IIKgo4eSQjtzLDrRif8+3B4fdQ2NxEVHEOm0YzGbKKuqwec3ZLxUTSehe3eqNmwmfnLH7tgfAyEiguhpZ1K5di1Vi5YQP2K4oUgZnIAaduykYtUqLLIZT2UVoslEbU018SNHYEtOpviTz+kx7zwa9u6jqNFNfP/+pF10QYtrdJl9NvkffETcOWcze8QwcHtZcM99zH36SRS3GyewZuECxt1xBwNnzcQfUGj0+LBZzJhMMmlnTOb4B5+Qc9ZUct/9gJr6egZdehGWUxgWmt+PaDaYEq946QUC6zagZ2WdchUH4D5yBJvdSvLZM0CWMUkS7tp6av0BvP4AkiRht1rw6zpur8/QeZBEJEmi9KtFJJ41NSzClffVEl569WVmnXsew0eO6vhZCAJmp52pN14fnsSaew90Xefo5ws4ceAAj69fh9/vp2HTllPeizXCSfHajSSPHYmma0hB40bXweXxIopCOFaffPZMxsXGUrloCQnnzmn3fOkTxrHnvQ+oaiZ4dirognGNYZddwva33kFxuZCdzpMeIwhGjsRpPS9XA60DVcbEp1K3ag3uygr6XHc1AG2CRVYrg0aOaL/dug5+H6a4uFO0QG+zwtd1Ha8/gNttEEs5bAbFuFmUMclS+D2Pctrb9QaEEDIu/MH3zkg+NXRU2rQ1uL/FZEJRVVweHyZZQj6J3krzcIjZZArbBaHfobY1fxc1vUlsTIdwfomu6016R79CdBoWnfhFweV2ExVhxyQbNLt2iyVsWOi6TuLEiRyaP/9nNyxCiB/fqswyOJpEDhlM5JDBLT5yNropXbKUrVu24ZZ0ki88l6LSMnpfOo/Di78O76f7fBR8uRiL3Yo9oqnc89CCBUy987dgNrPng4/ZVlrMMy++RGVNNaIgYDHJSKJIg9uD6DNWZVpsNCc+mU/68KH0OAn1cnOUrVlH7ZGj9L7pOkRRxG2xYKmphdiYkx7nzc+nZNMWul52iXEfuqEEqQuGvoOm66CqhudGkvD6AiAIRDntuD1ess+bS9myb1DMMr6ySlJGDee5IS/h692LffM/p212SxMUnx+zyYQQHKibx84bi4o5uGo1V913Hy/feTf7d+zgziltqd1bI3rkCCx79hkTktC0OvYFAiiqhtPRkk8hbvQoNj7zPEM3bCJi+NB2eTf6X34p1oWLTnntEMx2WzjPYPAVl1G+ZCkps8/pkDAshIrSUvRVazBbrYCAq7YWkyiCxYTFZAFBoLHRRf2evUhmK1JQmr6+pJRVq1YjetzMffRvRMWf3DCoq65qs03XdRryj+JVlTaiY82haRqapofl0UMIBBQaGz1ERTrCYmIhCIIhUqZpXvQ22QwtEQqHBAIGaZbpJDwoIYiigEmQEAXw+RUk66n1TQyDpZVRIDR/B5uFQ9rwXATDdacI7fxfR6dh0YlfFDTNKP0yyUa5qSiJ2IIc/mDETl11dSdlb/zfgmC3Ue3z0nXCGJLOmori89Ft2lQUyRjIdF2nvqCQ0m9WEjdkKPFDmwTTCpcuJ75rVxxdjXXjgCsu45q8fMpyD5F69oywq16WRKKc9ib/8sQJFLzyKukXX3ja7UyZOgXz1h3kv/IGyWdMJGroYNybtuIYP/qkx/k9XjKalSHquk5DTT0BRcFusSAEWVKlYB5FVKSDhkYvfkVBkkVq6l2YJ0wgNS6a0iXLmP/bu8gZNYyk3n1588UXGdJOLoCu6wQa3Zhs1jZERLquoygKa//5LNP/8ShSZAS95s6i/GAumx97uu0KvDXsdqqKS0gPuqqbVp6C0b0aiJKIHpQtBxhz1+34ikooXbaCqJgoiIjE1r9vi0mj+5xzaFy7ntLD+XS99iSlpICqG6tbQRCQzWYcQwbz7TP/YuJN1yNHdCxaFRUTQ0wzmvv26lEcGAURjmalwJH7DxK9dh2VCGiNjSiBACW7dpEx/ax2r2MyGyE+1dXIns8WUFZbS05GGpgtZM+Y2jZBMRgG8AcCTaR2rfbx+AwSrFBIr/XxXn8AWZZPm2TKbDbh8/mRgsJ6pwOHzUqD24PZJCGJ0ik5KgShueej7WchiKKIKDYl/4YEEwUB+C+PT/9NdBoWnfhFITxQNTSw6eVXmHDvPUQ4bFRU19Ho8aJqGn0uvphjny2gy0Xn/1fbuvnZ5+l3xmQcwaRJyWRC1zR0RaXa7SXL66Xy22+pKijAXV+H3ePGPm40KAqVh/PJvP2W8LlUVWVz7iHOGTmckvWbSJs03ijPUzVMtiYOCwQI+PzUbNxI7JiTky01R9ywwez44D3cAR99b7mJgoKj9DmFYRHZr2/475ChY3M6qK+pw6rroCigQ6PHi8nkxGo2E1BUnDYr9a5GAoqKJEpomk7K2dOZVHSC+EkTseXkMHXHrnavqXi9aIqC3Mz1H4pj1+8/wMJ//otpl1yIGJRSFxCI7tKFfVUVzDlFYm3B0hWo3uZ01OD2+gioatg7ZJIkdF0kEFTU1AFzWgrmYJlq0bffceSDT0jv2wufpuGMjECrr4fIaEwRDko2fU/KqOEd9mmgwdWijZGZGUy49WZ2ffQxab16kjS6/RCRIEs0d/F3hOPlZTS+9gaR3brh93ioOZxPVp/e1JWUsvnFl+jSrx8ZQSXW1vjm8Sfp06s31fv2s+XTL5h0zx0MaCbd3vrauq7j9wfw+AKYTDIOu7VdxVOTLKGo7VdIKKqGLxAgsh0ivHb7QTBEynz+QLhy43Q8EHJwgdLg9mGSRBx26ylTTDvS/miTYxHcJgV5Mwyhul+vtwI6DYtO/MJglPaBOSICrcGD61Auzp49iI+JIqCo+AMBvJLM0cLjROzaQ3w72f//GyhevIyuo0bhHNDy+oIkoYsiw6+9Cn9ZOSeqqhn1u/tY+/fHOLxjG+bcQ3hrG8jskknN18uxREaAJCNkpGGxWMicdiaNe/ah+vwoHq+h8CkKyBZLcICU6X37rbgWfY0+UqV02TckTZrQIS9CCL6yMmLiE9AkCTSdwA/MK9M0Da+rEX9AQdU0Gj3eIE2zgNfnxyRL2INueh0joVOWJepdHjw+P067lVqbFeHQQdJzcli0cT2z27mOKMmINglRaqbDoGksvu8BiopLuPrxR7FmZqDpWrgUVJIkVlVX0ud3f2DOY492ONHsWPkNQ0eMDJ83oCj4AgqRDhtyM/e9IAiYJMkwLoJEXKqqoqgacWNGc+z4cb5esZKufXoza9J4xKys8LHfPPKnkxoWUQ47jRs2Gs/E68PhcKIE/HTN6Up13hE+fO8DJs2djbuhkejYaBobXZhkM/f++c/cVVFBanQ0bq8PTRBQa+uxx8USCCg4HHbsZgsRdie+yioqqmtx2G1s2r+fTbt28PzKFbz3hwcZltOFxsOHcXTvzvGvFpFx1jQwm6letYYUk8yebdtwllVw5oP3YzpJ7k6o/7x+BaejfYMiBEmSwh7H5sfruuHNsJnNYbGy04EgCFgtZrxeH2az+aR5GS2OMZsMxk9FPa3rnAphQ49QUmeQN+NX7KkIodOw6MQvCpqmUVvvQgAm/fkh8j6dT83Kbxl2y03YbRb8gQA60GvubLa/9x6TkxMxBfVC/jdRUVLMwLPbdyeHBsjcZd8w8YrL0J0OcDjofe21xiCoh3gJBCTZhOJy4dqxi0iHnfLFS0k512AVNTnshoy414ccrIKxmk24VJWoKRPJe+Ip0mbNRmlowHwKw8KSlMTQ++8l/413qfxuHZndTxk4aAF3QyOV9Q3QbAIJjeeqplFeVUtsdCROmxWvP4Cm61gtFkRBxBLkNXAXHCdagaV33U0FcPXosUwaPZqr//lU+DqaqoKuIWFMapqmMf+e++jdtz+znn68afLRhXBEXqqvIwAcyc9vWZJKy9Xl7Jtu5J1/PM7V48dAUhIBRcXnD1CHTpQz6CEJUkpruo6iqMGyRQFRErBbjMqFKdddzfirL2fH2x+gpqUbCb7Ba/Wc1JLqvc1ziInBMcbwFIXCGaHKpChdJy4rC+e4Jk9SKAvmP6KMfUpTKASgbsv3RI1oacQ4gfo1a4mcOA5d1xljtaKrCh8/8mckVeGhP/+Fm2fOIvtcC5E9euLa/D3m3j0x22ykXnsdXcxmzGb5pEmOYEyqHq8fm9Vyyn0VVWuzj6bruNxeJFHEbJZ/cD5CUxjk5HkZrdvs9QcwyVK7h7X2CIXUVENor40t8i2a7WPkIyk/hSz1/2v8etNWO/GLhI7hWi+trMHr99N93gX0GDqUQEkp0RFObEH9Dp/JzNC77mT3J1+gBwL/u43UNGynmMgBKkrLIDkZQRDIz8tj6UuvIFutSFYLktWCyW5HNJswx8YQe8Yk5v37eVxuD4WvvmVklUuSwQmgaeEBTpZErGYTldXVJM2ahZqfT8WadTRs2hy+7rfP/Isd737Ypj26JHG8qoLDm7cQ3UH2f0fQdR0NISx9HR5wm9Gv19Q14PZ4McsSZtlYpTYvI4xNSiBQWkxqr95cNG48f3/iCVS3u8V1JLMZEFADCpqmsfWVN+nbtSv9rr+6ZVJeME9CEATEuDjunzyZ7pkZaA0NKJraLh282K0rMy44Dz0pCUXVCCgKNosJq1lGCQrfBVQFv6LQ6PESUFQcNiuRThuRdhtmk4wWLmnUqd+8gc1PPkXhmnXsnf8Fuq6TObmtxkpzmCwds1sKgoAl0okkSW1+VDRkWWrx466pabNNliV87kYkSUKWZbpNHMclTzzOgP4DOFJUzOXnzKLrHbfizsvD1+hGdjrY9J9X8fbogSiJKKqKz68YoQZFaTGxNn8XfAElSK996tW5SZZQlJZMtwFFNejBbZYfJeDV5CE4fdebIAjYrWY8Xl+QdrwldAyDJ+RNUdT22Xnh5Myauq7j8QXw/W+PS78gdBoWnfhFIjTQA0SPGsEXf/mrQRPttCMKxmrV7fXRbcIY1j/7r5/Ey7/jjbdZ84/H8RQWntb+m//1IhYdjnz2BfjbKoECaMXFSHrT5HbTW68z+7e3IogioiQhmUzhmvjQjyiKdL3kQoTkRPL/9W8jxitLSBYLqteH4vODrmM1m4jMzMTcvRv26VNJSE5GKC7FdeAgAE6blR5nTkJv9OAvLiZQXMLujz5l0+//QHlpKWN+f+8PXiFabRZEXQu7rCVRxGI2wjQmWQ7SdgtU1tRRVF5JZU0dqqqh6lr4Wj1mzmB/STE1R47ScCSf7YsW0SMto8V1BFFAlCSKv13NpWPHc2jFN/S57dawJ6L5qrL5PSSmpzHp7rtY/Ze/t1DQbI2kGdPx+PzUuRrRdB2TSUKSRHx+Ba8vgNvrp9HjA0Eg0mEYE83d/KHQiG/fAeL7DaSipJQdX3yBv7gMn8tNQFFP+i66Gzumwwbwd6AV0t4kZe+AmMsZFdPivTJHR5I9dTKzRoxk0G23oOsajokTcR3OY+n7H9D3mmuIdNqJsNuDisICvkCARreXBrc3mDPQBFXT8Pr82E4jv8HIw/AbYm3NIAUJqX4K04PepGl22vD6A0hyqMy4lVYNrSpKhPY5QVqGQNp6MnQMMTmH7adz7fz/ik7DohO/WHi9/vCXeNRZ0xEEAafdRlQwcc/vDyB1706k08nK3//hB5+/dv0G3rvxFlL79Gbiffdw9Ns1fPW7B9jy1DMc/PgTCt/7gIqlywkcOQrA1v+8wpp//gvR6yVx3Cgyx4yk9OtlbU9cXc2d51/IhFtubLn9FH7RkHGRfs4MYsaO5Z0rrqZ6zx62f/Axuq6hBfwoqkaD2xuO5YpmM/K40VgzM5AO51P4+UJKcnNxpKRQuGAhdbv30XD4MKqrgSH33MXAER3H/08G2WTCarVikuQwr4aiqphkGYvZhCgKSJKI1WJGVTUCwVyM5oOznJpKSV0D8ZGRHCgu5tCW76kuKualK67GtXYD6tEChKoq8j/+mH3zv6APENnNCNlommaUt7ZCaKLvOnYcD9xwIw0WM3U796DpHdMpy5IEAlgtJiRJNFbPCEQ57EQ7HEQ57ETabe1WHMiShCSILHr1VQbdfgtzn/snblc9os3Mwr/8jeWPPYnX3/FKVTCdPPrsraxod7uzHRp1fwcr4tZ6I4Ig4ExOptsVl3Hg/Q8xpkSdiMx0Bs2ZiyM+Ftlk9IXFbMJmMRPpsBMRTHCsb/Tg9voMLgqvj4ZGDxaz3IKtsiOoqopf0XDYWnpqQoaFov7UfIcfZlk4rBbMskyjp+2CQAhyjLT2hoQ8GeEr6qEQSAcGbDAB/deMzhyLTvxiYbhijVWBOVizLooiEQ4bjR4P/oBCZU0d9R4vcfEJrHr8SSKio9m1cwdTps+ky5xzTnr+HWs3cvkrL4X/73P1FSRt307Zhg30Ov88OJwPvXtS+e0qir5cREr/vqSd0VIyevf+90ieMyvYYD/rnv0Xew4d5P7/vAiRHWtqdITQYBUzZCBZI4bzr5tu4eKrrkYLqJjsNhp9fmRZwhoc9MOkPkMGY4qO5vijfyd70iT8xcVYYqJImD4VXdeRM9LZ9cl84uJiqdqyhfiRLcXKKnfvJa5fHxSfH1VTUf0BI5FSU1GOHMXStzeaoqAhICIEvUk6kmjC5w+g6RoOqzW8sjbovMWweFzw5rjonjsoXruBS7t0xXHuHNJGDOOTBx/GOXIYVFRx4JuVxHXvTrYsM/Xfz/K3a2/A/twLyK56/KLIWQ/8vp0+g6h+fXh+ySJUVaVq+Urw9oB2wlW6rhuJphYrbp8Pq8VEQNGIctg6TCBsPXlu+/d/SOzaNbzvZa+/hq7rDAIajhxl68uvMeY3N7d7PnsHjLH1Bw/SsP8Asr19sqzaympaf2K121ErqyhcvRbZJFO4bx9JXbJxmkxYNn/P0QMHyBw/DnvXHMO4SE0mdtRIXrzsSvKPHWVot57MfvF5ZKklbXWozZIk4bRLhnEQUPB6fciShNNuRRIldPST0nfruk6j24tJElt4fVTNMI6bRN46Pr51m34sQucym4z8kZqGRuobPVjMJizNjL3m11HVprLjltwbxu+AouL2+jDLMpZgnohBtuYLJzb/WtFpWHTilwtdJ5Rl1Zy4yCyJpCTEUVxeiT+gkNa/H/FpqUT06Q3AMOD4gi/Z++mn9LuwA74Hr5eMrlktNum6TuzgwcQNMaib9F49QNeJnzKZ+ClNfA5f/u4BouPiyYiPoVtKMgCNR44i5h1h5DVXMTa+fcntHwJRFJlw261k9u/P4SVf09NhR/X50Px+VE1u4YYWBIGCL7/EW1/PwMsuIXfrNqq/W0vy+CYSsYguXRh28w0c+nwhW+YvZMaIEUZmf2Ul7D+MfjiPrdu3kRaXwLJt25l8xRVgMWMNBLBUVCI2uo2BU9PQdQGTrhmVCDYrdY1u3D4/vkCAgN+PgICEDpqG4vYgW8yofj+SqlGwfhMle/aiVpYzISIKW3IyaRmZaKKIGhNNzrlzyXv3fXpdfQW+unoefO1lJLOZe8eMY0jvPpCXB927h+8rlHAZYuiUZZmoieP56oGHOPe5f7bpVx2oc7kNN7ym4fMr2NoRTGv+Tmi6bnhAfH5Kl69gz3ffMb6V9Hno2IicLvQcPpzitetJnTAWkVaTYgcL2WPrNjLg+ms6fB8UpaV3ovbgQY5t2Yq0YzsD7vgtyDJJw4dgbiZE1mvkcKqXLMOemAgRTgQEErrmMPeaa1jxwYfMePopzKaT02iD0aeSJGFt9s4FK587RKjfFE0n0t4yZBIIqEiCiNN+8lBBKN+hufHRmoH1h4RCQuWjoigQG+nEryi4vT5UVUMKetyaJ5kGC9Sa/d/0nz+gUN/owSRL+AIGC22kw4bL4w0bX79es6LTsOjELxmhb2Z1NXv37zNopYHir5eROH1a0FWtovfqQ96iRQzKSEcIkgxlzJ2N5933OfTmuzTU1BCZGEePeRey5NlnybQ78Soqw1oN5CEtA1mWUBQVHcIKjCHkvvch3YaPoM8F5+Lat5+afQdwrfqOitzDdLnminC446fkfIRvXxBIGzMKsaoKUZYQZTsRNhv1LjeNHi8OmzU82Fl0gezLLkUXBLp178G2554j6aJ5LePGkkTGpPFc+8w/sb3yKoN69cIaHU29p5HISeMZnJ1JY30DZ3fLQcnLo7iigvwTx5lzxhRMTicO2Ye/oRFF1TDJMlERTho8Xlxur5F3YRbRRAnCmf4imhGE5tDnC9i1ciUeh5MESaCgoYG4bVsZ2rcnsTYLh958h8ypU9j//Xa8fp9RFWO3B5M54Ykli7hn5jmM3HeArt26hfun+e8QTFYLx3bvpWrPXuJblQMTdGNHOx0EVBWvz99iwmwP9bm51O4/gGg2YY2K5NJ778I8Yni7PAeCIJAwahgrHn0MU1IS8T26tlytt0piRFEoWPAlMdktc02ao27vfpytqLRtCQkMvv9uTixcROPRYzi6d2thVIQQO/MsTnw2n4SRI7BkZFCybDnbl69g3jNPEZAMg0HTdXRVC0+67fVpa7e/8Wf7fRYii3K5PKDrLcJhethYOHV5acg4aZ0eqml6M72SH5a82fTOGBVWuq7T0OhBCyZIWy1mLGYTuhY0jFQVj9ePKag1ouk6oiDQ4PYSYbdiMZvQNJ3K2gZqGxqRZUPWvXW+xq8NnYZFJ36xMBjyBIiNZVD/IGuly4WiGLH9mEgnZVW1KKpK7LSz2PXO+wy89aamZMErLjNInGSZ4998y+qnn2P0mJHU+RV6jxoBzTQaNE3D7fXh9viQJBG7zYIkSiiqSvme/Rz8dgWa20t2/770CWpHOPv2wdm3D9TXI+haG2XUnwpjoJewlVW0WG1FOg3joqHRg91q4eA779O1ZzcqN39P/OiRRGSmM+73v0PffxChr+HF0XUdd1kZT5x7Pm9dfQ09brwu3Mb64yewdc8x+sFkQkxKJrlnT5J0jZ75R9n55SISa+qIGz0CfyCASZLQJAlBlnDYrTR6vJiDHAFmqwVFUdAFEZvNoGOXEeh3+aVkDxvCgU/mU3H4MIHoGHr27U1daRlJffuRMXc2RxYsYO+iRZxzw/WIsowYTE7UdR2iorAjsG/VarrOmWVQV+nt97MkSQg2K4/edDPPbFzfqk9BEoXwhGG3tmWKbI7G/QehsoL02bMo3baTusMHibpoXrjqRBbbrvgFQeDMB39PxYpVFBUWkHbmlPBKuLDoBBmbtoCuUVlUgr+mhi7nz0WOjW33+g07duMpLSF5RsvSZkvQ0Eg/dzZH3/+QLl2y21dZ9Xpx+QIcfeE/ZA4bSmxGBrP//ldq3V4sJiPpNgRN01CDRFbNXfmn+y7rusGa6/MH8Hh9hvco0hk2VowSzAAuj5dI56mrqiRRbGNUGG1rlkjbrGKqOdp7Ji2qmYIwm2SsFjMmWULXNBq9flSvH01VDY+W2mjomXj9eH0BAopKhMPIFwnJw4uigM1qwu9XcNqs4VLWn2Nx8f8rOpM3O/GLRUhuG8AZE6zodzqpKSlGr6rCbrMS4TAGKJ8k4hwxkj1vv0f11u1NX+rgwJkxdQqTHriP6AkTyDpzCmJr4adg+WJsVARREQ6sZjNmkyGSVPrdKqbceD1T//gAPdoRpGrcsIXq2lrDiPmZIUki3lb6DKIoGgRUkkSdqxHJbkOMjCa+GZWzFB+Hu7IKvaEBTdM4tuRrGrbt5E+rv6XK5W4x8MYFV7q6ruP1+ahzuamqrcPt9WPNyWbYnbehqAFWv/gyQm5L2XqzyURMZAT+gILb4wV0bFYLTrsVRVHw+vzUN7pRNY2I3r0Zcd/d9Lr2WubX1nDN408QqKxixdeLuXDceJ5+6mleyT1ERFZm+PxLHvkTQnCV+PD8Tzh4ONdgxDzJmC0IAje+9AJZySkttmuahhJcmfsCCoJAh+WSepAUy9qrB1Hjx6PrOvmrVxM7tEnhRNU0FK39KhBBEEg4czKay4Xf4w1v73XhBThGjcAxehRZF5xLXXlZ+0aF30/xgq+wxUS1MSpaI33COI4v/Kpl++vq2PbKKxz7agndp09l/OOPknXheUSMGo5uNqMJQphiO/QTKm0VRTFMCqaqWoeTd9s+g9oGo9om0mkn0mk38jdaeDqE0/YxNG9bx9uEHzWBK4qhZhsIGKyrZlnGZrUQHx1BXJST2CgnZpMJSRAQgQibBZNJwmm34PEZFR8CTVUpEXYbcdER4ZwirR0j5teETo9FJ36xMDcTGfI3NoRlpAdffSW1R48SFRdHbJQTj9fgHNASEog480zKv1tNzNDB7Z6zo9WXKAgGoVMrF23x+s1I8YmIHSViahouv5f0qWfgWbsBn8VC9JiR7e/7IyAIAmi6oY0it0wys1nNBmPk9LOQIhwtjwGso4ZT/skXyKnJVK7bwLC//xVBEBhzz29bXEMOZuh7fX4j5qxp1NS7EIVGzCYTDruVzCmTyZl6Bg0Fhax5/33kSCepN1xvXMuIdhATFUFDo9ugefb4CKgKAgIxUZF4/QGcNgndZiN3uVFJc152NtWuRi57/nmO3XATk5NT2LV+Lb+ddxGDevXCYnfSJTqKmu+3ETNyOJaUFO5f/FXwHo22tw5HhFal3hNFJEVGhT/Xg4RMTfTLAqF1VUAxKlg01XDhhypQGt0edCA6wondZqHfjLNwBsMwIYQ8F6Igtl/mKkrUbtqMbeL4tiJmikLawIG0hu7xULl4OSlnT0OwnZrq2pSRga2ojNz3PiJl+BCObViPKJkZctFFCFFRbfZXVA0tEGi36iU8cTcrrTQqHAya6tD3o02JZTBsoKkqFrMdczvVL4IgYDYZ+UGtS1h/DNozOk61f6ithoGjc6K0EpvVTEpCDFW19fh8AeJiIqmpd1FT50JVNSIcNiNEEvz+yUEhM0VRg6GR5uc2KmEQDLr5DnJ1/8+j07DoxC8ShnRx0+tZWVbeJAdttxPd19CxkHSdRffcy4zHHkMTBAKKimx3Ur1zN3GD2w7aJ0NrVUaArIljyWJsh8c0bNhI4uTJCBEObJMnoO3azY6XX6P7GVNwdsv5QddvD8uffJqD6zZy25WXojudLSZSQRCCsV8zXl8Ah63l6lBXVOrLy0kbMoDY/gM6HHhdyYnI/gAVQe6JEDRdx+v34/X7qWtoxGm3EZOVyax776Ri734OfvgJstVC99nnYI2PRRJFHDYrFdW1YQrnkBqmKBjGi8/lYvWGLcyOi+fqx/7Oa/f9DkFROH/MKD569z36AT7AK4p4Ghtx9u7FgZ07GDNyeNhAOBVUXUNKTqLRY3hKZEkKlgyC025BEkWjbLeuASUQoKHRg18xqlzCp2/GsaAoKkliNLH9+4ZpvltcT9NQ0TBJctgFrOs6XrcHn6qSNHgAxV8twWKz4qprAFlEEEV2LP+GUefM5MhHnxIZGYkAFBUXYzJJ9L7k4lOWJzdH/KhhxPfrxes338p1771z0n0VRcVis3Kyebj5OyYEy1c1LRh6gGZlmQZLqcvlxuNXcNosLejR272+qrZrePwotMMj8UOgKAaZWp3LzdHjZVgtZoorqtFUDavFjKKq1NarJMVHB6m62xqyzf/XdL2F0ftrRadh0YlfJGRJRA4KLxmqmrXt7nfw9bcZN+1MYmOjqaqtNxLDhg1Dz8ulYft2nIMH/48mUblra4lo5i1wDBzA4IEDyH/vA8oPHyanmRv7x5TPTb33bpTy3yNYrcYEpqnh1XEoDm42y7gaPejWponIfbQAvaCArr+9hc3PPM/gZiqlbdoTGUVpZU2HvAhgTAa1DS78gQCRTgfxffuQ2L8v/tpaDn+xALPDTpeZM7CYTcRGRVJdV4/H50cIuoZlSSRQVU3dgq+48/23WXTzrTxy8aVkxMWxf8HnlGoCXbvkEKUq9B88mAGjxvD1lwtIHjEcX2Vlu/3WnLCoxcoVAXN6KulxCc1ulvAqMtxHXi91gVOHrwKKQlVtPckJsciiRKADRkZFVQwDCsMVXrT5e4PLIzKS2HOmo2k6MWZzuMqhob6e5HPObjqB34/3iy9Ju+iCU7apNQ4vXkb5kTyue/GF9nfQNCq27SCyVw+8qo65HaXRjtBUfiqgBwm8NE3D7w8gCEJQhM6EzWqQv52qZNdikmn0+NA1HaulfenzUyH0zFuTl4WYuk/VhrC3Q4DS8mp8URGomsHGKokigYCCoqoI4VBLkxZIqAQ+dI7mpG2i0VHoOmjtsHv+WtBpWHTiFwmDAVDE5zdctjFpafgLCjA3E3w6sWIVR/JyGT7vYqKcdvz+APWNBvthoG9/8t59j7j8o3S/8H9GBbVq2zaOHzlGa6WSQwsX0/PySyn88NNw8mgIoUHIW1bOwSVLGXjJPASrFerq+OiZZ8jOyGLHzp0MHz6C4ZddjBpQUDUBJINPQBAEtLo6Ns9fQOmunYjA3OeeQQjGxQUdjr/3Pkf272fyY39HEARG3393i2uHoOk6dfUuaupd7VJgtwe314fH68NkMhlsjZFR9Jh3AYG6eg7PX0BUSjKJ48YgiFFUBw09XdfZ/f4H3P7yy0wERuzbw6bqSroCKTndqKqv4+NDB8kCeiYkEJeQyAtPP8lVt99OUt/efPXMc3SfOb1FO/xHjqDJMrmr19FjxlSsCYYREeb1ECXSIyLCk7ggGKtst8+PWZYMAq8OFDfbg8fnx+U+edKhjuEtCSFx1HBOLFqCrutU7D1AfVk5aePGEu20IwgCGYMG4tl/AFuwTBqzGUtMDKWfLyD5vLnGNk0j/4uFeBvdxMVEU1legWS303vsKMg0clF2f/gxCYnxdL/9N+03TFFY9tAjDDzjDPIWLyVtxnTM1lOzZraHpv4VsVjMNLjcRimq2WQwTvoCYfGT0PtmTNgqmmYwnRqhEEPEzPIjdELaa08YJ9EAaY5QGCgzJYH6CDtWi4XEuCgCikKk00Gj20tAaZKBt5hD32HhlJ4eI3ykIgi/3hTGTsOiE79ImGUZj9eHruvYTSYy55xD8eKvKf9yEWndulFeVUNSj67MevpJCj5fgDhiCHExkcFYugdJEhly+y3Uf/Ntu2WB7eGHehTi+vfnuy++Ylir7T0mGHLmKdOmsO6pZ+h35mSiBg/m2NfLKd27j7KaGrqPHUPG2TM5uHgp3ro65i9exI0330z6GVMYJQp8+ZvbWVpZiSCKvLlxHdOrqyn45luO7z+A6LAx/uYbkW64lprv1iNIEqIAXq+Pz+68m3H9+9F92lQgyBgYTCbzB/U3bMHKjZo6Fy63p11Gy5P2EwbrY2VNHS63h5hIJ46oSLqeP5fiTVtY/cxz1Hq9DOg3gNv+8Si/OeMMpPJKUoDfv/Avlr/+Jk4gKTKSvB07SOrRnTlR0SQFFCLT0qjYuo3cykr2bN1GReEJ+g1v2cOBXXvZ9PkX1Lga0M0W+l5+cYtnHFrFfp+fS1+3GxwOBEHAaTMIvAKKisvTlqr6VGhwuXHYO9b6aA1ZlmhUFHLnL8BT38iAqy/D4w2EV7xRgwZy4vOFpIcMCyB+2hkc+vQzGj78BMlswu/z0WPmdMToaACSAfx+9n7wCVazTFxqKq5Dh0nN6dZuGwDwenEKIpuXLWX8H/+IWRbDiZsnQxvK61b5DIqqElAUoiKcBjNsUH/F51cQBMFIblVVNE0zuDBEgUaPQShlGGE/PsExVBGiKAqy3Nw4aZvYqxsHtPJ2GZ9YLSYs5qhweCeEqAg7fp8fURIxt6j2atuW9vrRMKI6y0070YlfDCRJRJIk6hoaSYyNDpeXpZ49g9T6eoiMpJmTm/KyMhKPFWDNziI+1hgkGlxuAgEFryRjO5SHo1f3dq/VGqFQw+kYFoXffEvPHm3PKwQrWExxcYy7+QaUmlp2vfMe5uQ0EidNZODA/litFtB1HLPOpmDZCqaOncCJ3Hyc/fpRuXUrk2+7nYjePdA0ja8/+Zj9S5bS78LzSZ8wjpqNm2g8XkRUdDSxE8cBYDWbuXPiJO568EEi4+KJGjqYOpeRSBlQFCNBMcgkaDWbWmix/BR4fX7Kq2uJiYwk0mkjfcwokoYPw1tUjFJbRy3QWFXFjH8+TfT8+bz++ltMGz2Ggzt2ICanEJ2XhyyKOF0uVFVh8OCBnCgq5Yv1a3nh7vso3LSJ8RMnUhmbQPxwIyFXUhXsXbKZcPUVTRn4zcpPjeRD2FBczIyt20ieaBCFiaKAzWI2iMF+RAVPQFVQFCUs6X4qSKJI3wvODZM8qVqIv6FpH0dUpKE302zy6nnhKUIhZjP9rr7c+Lu+4f+x99ZxVpXr+/97xe69p5OBobtLujtFAVFRRLADC/XoET12dzcWBoIKCAIS0t3dNQzDdOxc9ftj7b1nhhLP55yjv69zvQ4H2bHWs2Kv537u+7qvi8QjR/Cdzjnvx4tOZPH50sVMuOZaZFHAYv1j2YpIIFQx5R8hdYqS6bUiCBKSZN5f/mAwesxyWOY9kkVwWC34gyHTp0UySw6GYUT9Oy6EaOgQJkjquoHPH8Bht5+TH3UhaJpuip5VCEIMDAzdiGYzgsEgzjPUWyueg/PhYhcy/y9D+LsSTHbuP/j3PPD/H8Bht5GelEBhSSl2qxWX0xF9GJ/5g/UdO87hJUs5sG49ossJ/jLyBQsZtetS87IRxHlc6CtXcXjTRuqOGU1K48bn2KOJ36vRVkRw3wGyd+ygViRlfQEYhoHXHyCkqIiCgMthx1KBvHb86AmyCsuoFuNm04wZ+E4cpcznIyUljUDAR9HW7fQddx1CrUwC6RmkJyeQM30GMelppPfvjWCxEAgEGdS7Dz8uWEAwGMIfDF2QM/GfhCSKaJqBx+Ug1uPk5OkC0pLiOXDsJMHVK1n04fvENG5CmSyxfvt2BtRvSKwS4rDfj2R1gCgy8+hB6gItrC66DB7Aim3byA0phIqLeOixRzHyc0nt2BEpJRlCITZO/ZK2N02Int+IvHTFevvShx9F1VX6Pf/sWdcjJ7+IkrILG4JVOkZJIjEuBo/TgSEYFYiMFz+JKKqGoRmVyyk+H4XrNhDfs/v5v3gRyFm9lrzdu2g64fpKrwcLC9n12dckjboMXZRIiHHjdNovKKV9Js6cIyKBhq4blHp9CGBKY9vKxeEimbLy0sGZuhLlfhsm9+X3cSa/Rtd1fD4/DqfjvMqpF3M8EWiajqap0QxFaakXp9OOXEnrw4jyK84HVdOiHCiLxfa3jDD+vkWgKvxl4bRZkSSRxLgYM/UslLcRVnoo6Dqr33qHptddy6Vvv0H/W28mo1lzrnv2KZr36cWud98jEFIwOnYk3+Fk/ZvvXHC/giBc0BkzgsDhoxxasfKigoroMTnsxMe4ifW4KgUVAILVRiAY4lhBMdUHDKLpLXeQ0a4jqxcv5PVVKznmieWT774l60Q2Ob8sZNf0mZzUITe9Oru+/5Gtn33BA7378OSoUcS6nSTEef5zrPuLgG4YSJLI8exc8otKKfX6KSguI7+wFEubSxh41TX4du9h0uT7aJpRE8nlxul0YnO6qZuWSqLFXK32b9iY7SEvewqK8ZWW0rttO0ZNfojZH31IteHDOL1uPTlLfoNTp1DLisvPnyCcM8vU6bFHWLN5y1njDYQUvBW0JX4PkiTicdrxOB1mNk0QsUhSJZn5i4EoCKhnll+cTsqKCv/Qds6FstOniUlNq/SaYRgELTbiRo4goGphjg5/yKY88ptTNdPR1OcPEgyaLcmmWJsLq9VCIKRQ6vWZxymapRZZlpHliPW7WOlPROwtMh7hIv5URER3w2azEgqe22H4fDj/PoAKwak5vspGaxU7Ps4XoBh6VcaiKrCowl8KkijiDDshiqJo/ok+WCr/WLPmzGXt8mVc36kLy596hn0r19Dm5pvB6SSpaSOa9+7Jmk8+pdTnp+nYa1AsVrTcc7tHng/nCmiO/LaUxhOuu+htVAxYzvXAkWWZmtVScNhN11DDMLAUFHL1fQ/QDhh9zVXUbdwUd4sWJPbtTXKnzsR36Ypms1Fj2BAaNW3K7Y8+Sue7J4U7MKRKxkr/bRiGgc1mmpEdP5lLUnwMJ7JzsVpkTheXkTrmCho1a86mN99hzD1389GWjWzYtZPiw4f4cf0aDhzYhwVQ3U5qOuPQNIXGNTLJ3b6V4/N/YcSUKQCkDx2M7HGx9edf2L99J+ruvRccV+nOnTRNr1bp+imqRkFRiak18DsQBYEYt5P0pASS4mMryV0LgmC2l4YnngtNNJFzFAiqOM7RQprRtBkFG7f87nguhLr9+nB8z55K+yv1+sktLEJHIC7Wg8dlN0twF4mIxH1RSRlefwAlrM8QUjVKyvyUlPkIhUKIguk6rKjndqA9F84XMPxRyLLlogW8IohkO873vUjmEsLlEaM8QxUZ+4W2bYQJvBdzj/2/iqrAogp/KVitlkqKmwC+I0dYP/WzSrXpfVM/w12zJg+vXsmnq1dSvWljig8djL4vCgI1+/SkeZNG5KxehaKqtLnvPqY/9sRFTQQRhBSV4lIvWli/4PiPs5D/w2zvpPgYqqcn0bxhLRrXrUHDujXocsv1nF67hjG33c7JXTtZuGIJ4uED1KqeRkad6tStlU7DOtWRdu0iLxSi4cD+0Qe1qukE/gP8iT+CkKKQEOcx2/UkCYtFJrNaCukpCRSXenl2x1YWbVhH8ZGjXN2lOz5gFzoWoEXzlsiAGtBo060rQ++fzO7sHNSEJPTYGBJq1oher4S2bWlxy41c9spL7Nm5k22ff8nxmT+x86tvgApCTbrOsfkLadirR7Q9VFE1cguKz5utiGo3ADEuJ0nxsSQnxOGw285yq4yk+yPhrhRuAQ6/WfkeM0xCoaZr0YmqIsT6dfEeP/Z/uwBOJ063ByN8n5Z4feQWFiEgkJIQR4zLiSRKlTI70XJCIEhRSRlFxaWEFKXSb8MfCOF02Il1O/E4HbgcdmLcTmLdDmxWC4FgiLzCkrCgWuV23v8FRNHMXCgV7veL/X2fO0CokJ0IL2yi2YwK5+18MMXETHXRv3OtvYpjUYW/FBLjYkiI9UR/9HkrVmJTNDSPi18+/oT6jZrgBxxFxbR97OHyL6oq70+4gZG33UZSx0sqaRys/2QqQkoaCS1bop84wazXXqNpy5a07dCWlH79LjgeTdNY/unnJHncpCUksOPwEWrFxVBz9Kj/aLrzzN+hkpfP9mnf0GbS7ax47wP+8fnnZAJvzpgBTicOmxVx23aU+DgcdWqbIlCGgS8QIqRqSCLk5hf94Y6P/wtsVms5wQ7zOZwQ50EURLQyL/2HDaMJ8OiUKcjp6fz67HNc0qED738/nbVAXeCabt2Jq5lJaWEhne65h73Tv6fNddeQtXwVeQcPkNK0Ment25sS4oEgsR4XoiAQyMnh2IJfSU5ORqxbB0fNmrw4fAR3Tf0Ie3IKhm6QG+5iORdEUSQuxoOiKIQUBV03sFpk4mLcUSfZc2loVISqaai6qX0gR8y9woJSBhFjLrNl1VHJKdSgcPESEnr1hD/AfTgTp5evpCgvj6RevSksKUWSRJIT4nDabQTCbcLxcTHR/ephYSh9xy5EXxklxSXIHg+xXTrjdNjQdTNA8bgclTxFzjwHpV4fkiDgCJvi/a/LAKqqEQgGw1ysck+QC6lynqsDTNM0VFWLeoD4/AHsdluUc6XpOgKcFWSeORZBMD+j6ToOu/NvWROpylhU4S8DSRSjD9ySAwc4/N33eNLTcffshtCwIZmNm9Jm0m10vet20lu3qPxlWebm995h76pV/PLiK9EHnCiKXDLxeqzFRSjHjpDQpBF3ff0FAx5+ANH4fSVHURRxSRLJffvi6taVusOGY23dlo3vvo9eVvYfO/aKqeFTS1aQv2Ilbe+6A0EQOLR7L189/E8G1KvHoW+/we2wcWjGTEqdLrwJSeTkF1HmC+ANBAGIczvMwOP/MEn9OwiGVToDoZD538EQJWU+JEnEFuth8bffsAvYN38B1Ro1YODk+yg9dIh/PfUUHuDZe+/FUa8uK5csY9rPP1OyYAFpSYkYhsG6H3+kxfhxrPjya44vXIS1uIj4GHc0S2BPTaXBtWOJH9ifgq3bGdmjJ7Gqhj05Bf13ggowJxpZNFP6CbExxLqdSJJIYUkpOeEshz8YiqbPz5XK1w0DWZSwWSzIkoQlnLmJZDWskmmcF1S0sNBS+ara0aAB3o0b/63zHtmOp307XJ27kF9cgiiKpCTG47TbTK5FSEGu0HlhGKaqasGKlcSnJBLftzc1R44grVFDTsyeQ1Gpl+IyL3arpZKVeEVES0Lh9tE/I6iAsGKuYURLDxWFqyouMM7LiTjHe4YBeliiPHKtzHLm2b+pyvvRK2W+/q6oCiyq8JeBxSJHVwvGocPUvmIUtrp1TP8Gw6BB357RH23oXBwCp5Mu995N7r7d5G7ZFn1ZEARajL2Sso2biHPYzQelIEBSMgWLFld6qMz91xPkrV5babOpyUlYZBmrRcbttBNXvRotrruWo7PmYuTm8Z9Geu9upFcwO2vZsgWnN29l9Juvc9d30+nVszc+w4DqGZxctwFRECjx+gkGFRx2M6AQfkfI538Fry9AIBAyBZVqVOelm26k14P3o4siRijE5twcXnjkERKB3JMnUbZsYV3WMaY8+RS79h/glaefZkyXbrQfPhxREKjdpBFbly5l9iuvc/C76VBQQNGBg3wz6V6WPv8i+777nqObt1AdqNGoEYZhkF9UcsGgAoh+LievgFKvD7fLQXyMh9SEeAzD4FReISWlXkq8PlRNj04mpq+IWVO3hPUUFNW0Yy8u8+L1BZAlGatswSLL4dUugMmBKCr1Uur1I6SkcPR3OCPnG7eiauQXlZCdV0AgGCLG5cDjsBEKhiguKaWkxAyAneGMQgSapuMyDMQ6taOvSZnVsRs6cTFu4mM8Z33nXJAkEVX/cxPAFosFVS3nNJwZ+FUMMCq+X/k9Knw/kpkQw9yayEKlctBSUQvFCJe89Ar7+LuiKrCowl8GSnYOxz+eSs78X8kuKI7+eP2BEMGQSnx4ojAMg1qDBp53O9d++CEJNWsA5asJQRBoOfZKDsyYQfgNYpo1ZtmvSwjuP8CuL79BO5FFi6ZNOXXgAGXbtgPmqsXv8yGKIqVefzTFaVgsZIy+jKIDB8ia98s5x2EYBod+mY/xb7Z9/jr1c94aey2q10vjK0ey+OXXou95Cwo5NH0m6dVSkSQRu1XG6Si3AD9Xi9+fAcMwom2doiDQefx1CGmp6JKEvUULrvzkE+rVrMUxoM1dd9Llrklc07cPW1etovddd5CAgB84vnsX7199LSAw7JmnGPbAfRzbvJV3pjzG4nffZ/BVo0mpXp1agweycPVabrrxRvq9/Bz5RaWUhbsVfnes4T+KoobbCgU0Qw+7WOoYAvj8QQqLS8PERoXCkjL8wRBef4C8gmKyTxeQlZNH1uk8TucXkVtQjKKq0fS5EeZl6IaB1++nsLiUguISFFUlLiERfyCIpl4c6U/TdUp9fk7lFlBYXIokiiQnxpGcEEdcrAeb1YLDYcfjcREb4w57XZRDEASs8fEY/spBV2x6erhd8uLuH1EU0TRTXfPPKK1HJnztDB+XysHDudpmywMAXddRVAXpDOGwyH+eaU4IRM3qKm5PFIVopvB/nTH8K6GKY1GFvwQkSaSax8Wxub8QOHKExpPvBUHAIkuUlPlQVJXEuBhTv18wKWJnPijPhciqIvKQKd60BTCIbdPaVO4r87LmyWdoe+P1BHJysaSnEVu/Hke++ppaw4aw+rMvaHfpcKTq1c0HF6YAkK6ZCpaGYeBdsoSkfn1BlgkcO0b+lm2cOnGC7Vs207dvf6ieQfXOHf+t87L9p9nM+PIr/vXV5xgWC4qi8sOUR8Hno/fjj+N2OhBEMx1dsVVWVTVOnMoNm2v9uRCA9JRE3E4HRjhlXerzU1hchizLJMd5+PSa6xj/2kv89sXXxCXE88FnU7mqTz+sqUk07NyFYE4262f+xOiP3mfDx1NZN3sW1943mYDLQe7BwzQZfTkb3/mAIzu3k56WRpsH76e41EtJme+iSHwelxO304GqqhSVehFFkyehqCqhsIgTmMGR02HqQAQVJSw5Xy4YdeZxWywy6cmJ2MKZON0w8PmDqLpuBoGGEW3fLDqWhTUlCbfDTnxczHnVMc0shUp+USlevz/aSRXrdmGzWkwCbziYudDk5g+EUAoLEY8dw92hffT1wqXLLlpXI1JmiQTdTocNe3gM/0tENC2cTsdZx3wuPgWUq9JqmqngabHI0cDCMAxTI6NCxuZCHBtBEKKlmIrPpb+rjkWV8mYV/hKwW61YYzwU5efTYfI9eFXNfLjLEsGQgm7oaLpOSZkPWZJwOS5eWjnyoBEEgZjWLdn23se0bNUSgJ8fmUL/W2/G3bAh7oYNo9/JPn6c1Xfdw6X33Isls0Z4O+bPRQCKy7z4gyHsNgvxHTty/JcFOOMT8R0/SkKDhmQMH0rbCmMo3raN2BZn8EIuAs0vHUaNFs14bfIDdGvblkNHj+LSdJ7esIHLY9xRkuGZDz1FNU2U/gowMFf6VosFTdPw+gNmp42uo2kaxV6JZn16M+v1t7ikezdSM6tzQ1ERpVkn2LZzJw2uGMONd9yBBhSOn8i+vXvoP3wE7q6d2Pfp57Qd1B/DMFixYAFHc7KZMHkyZb7ARQUVESiqSqnXF+UhBM6jjaAbBr5AsFIKXNPOvY8Ytwu7zYqlArfBFEizoagaqqZRXOajzGuOU0xMQNV0ir1+gqqGw2o1J+oK5FFdN/dfWFKCPxDCZrOQEh8XDSguRFg8E4IAhstFSc4p3BVel/9AUBAMKuUkWlGgzB9EFAVsZ1rE/5dR8fycGUtFAoWzvmO+iaqqWK2W6HMicm2jwaJgnKVvEy2HUK4LYmYsfn+x83dAVWBRhb8EnHYboiAQ8gfAakVXfIhIGLputsABZV4/IUUl1uO6aOXAcwnrNB51Kcueeoa6zVuyfcMG+vuvP/uLLjdXffrxObcpyxLxMW4MTMIpViuxBjw2+V7q1amDw7aQPr26s2HjFlLT0/ntt6VkFxYSCzRq2pSrP3ivQsni3CvSiuONq12bu994DYC2wAs33gzAt3dMYuy7b0czMhUNksq8f9wD5L+JUq8Pr98fllKukD4GSsp81L7sMhrt2InasjkFukHm+PGcnDmTeF0nb9MWnvvno5z+dSHWhDjm793DnnVrab58FflFRZCQwImlK/ghJ5tv334HZ6P65IZLaRcDs9wWvOhjuViPEatFxma1cOYwhHAmDkAJt3ee+X4gGMIfCFJc5sVhtxHjdiIKAqVeH2U+s102PsZjCq7J0gVX0+dCpEQYPHoMR2Ji5f2f0QGiGwaqEi7niALBkII/EEKWzLKgJEvRMVgkCeNP4ltIkhT2Djl7cj/X76xiwBEJKoxwBiO6GAmXQM4balUwPTOMyl4if6Xf3/8aVYFFFf50SJKIw25j/4wfqFGvLoZhYLVY8PoC5BWWEAiFTH0CVSMh1vOH5Hv3zvmFvct/I97ppOGAgSR3aIc1OZm6zZpwYv9ernx0Cr/NmMngFk0RLJZo6cQTH8/xmT8Q36I57nqVDZ4iqn9QQZkwI41rh4+gzUP3A3Bo3kJGvvYyhmHQZdLt3Nq7L+06dSLRasN79AjOzEyTGMa5H3oRWeBI8FLxM/d/8B43HDrE8GvG0XPmT2z7dSGNL78ce8tWWCwW7DYr3sDFK0v+L2Bavld+TQx7Sei6gaqqSKpmdl6EPU3SRlxGxuWX4wsEcQgCGe3acOyzz2iGgNNi5dC+vfww/Tv63TOJnJ3b6Wax8ssrr9LnpRcrEfkuFgIQOHQY/dgxtu7YRqc77vy3tQhE0fS7scgSmm4KS0VXtpitjIXFpdHMiNViiUqwu5127HYr/kAInz9Amc8f1d4wDFMALSUxziRWcm6p6wvBMMzWV39IQQ8paHkFFC5eYt5nsXFoFe4dwzAo8/ooKfPhdjoIBEN4/cGoG64kSaQnx5efQ0Ewt2uALIUF7sTKE/Pv/XYrch9+7zMVESkB/Tvl/ch3osGAECZzhvlZESOzivsy/z73WAzDJOfarBefWf1/CVWBRRX+dDjtNqwWmeT4OOI7dUQJSw+7nDaKSsswDAO7zUpSXCwOe7kfAfz+Q8qlBBj+9JMgy6x8/BmU0zkoioqiG6TWqkXJpi10H3sVB7+fSd0rr4h+r8GVoxAQOPz5lzSodwHnyPAY4lu3pvTAQY5+O53qgwdSZ1A/9KIids34gSNHjjKmT19s1avR8aYbOTTtG+pm1iRw4AD2+pVNzKJsc8OoZMFdMbgQBAFPZiYtgNO5p6k3aAhxyUkEBCgsLsHldPxHDMb+WxAEAavFQlJ8DD/ccBO5hw+x1DA4DYx1x9CsXVt2n8wis0NnGg0bCoQnuGCIzIkT6Od2kz9vPjM//phEYNE/H8Wdno4iCtjj4/D/jsSzKAjRiUMSBSRZxj93HnsWLaV1966UZJ2gZVICcXv3kH3qNNmnsqnRuw+2tJTftVoXBQG3y4nLYcfpsEVT6LphEFQUtLBxVkmZLzo5C6JIrNtJYWkZqqqhqBox4WyHy2nH5w8SCimEQmbmTpalsK+FjlzBfKtip0Jlx08qfcYfNAMWt9NBfJsWCG3NsqCSk0PRlu3YEhKin9V1nZIyP75ACF/g7PMqQCUuiMNmwSJLKJpGIKQQVNToZyK8FZtFPicZMjpGfp92HClTRMSrdMMwy6bhluDIFiIamgLlZFSzvHGGtLkgoGl6mLsVKYlolbgqwhlZ0opdJaY1vGpmOBDwBUN/Be70n4aqwKIKfyoEQeD0mrXY0tJIaN6cwk2bievSmVKvP9zNYa4KYtxOHHZrNH0ZYdqfq8e+JCsLt83GvnnzadCmDYRTu10ee5iCdevIuOQSdn0zHaehU5CXR+K27eiigJ6Xh5iUhBgIIGgaWT/P5YtPPqXRhg1c/fab502nRlCzfz+KV69h17Rv8Wka8QkJNJ0wnsaGgaqp+I8c4dAPP1Fr6GA2vfkOd3z7DSvnz0OIiQHKH1DGGevkc4oxBYJsBlrffCO6YbBv1s8Y+/ZjTUvH0arl77ZX/lmwyBLxHjdFvy5i16ksUlNT6XndNdR94VWSOneipKCALvdMIu6Lacz8YirbFv7CjZ98QkmZD1XTKCnzkXn55XgPHKC5LBAMKPy8ZDG5wEGg9r79513NRhj7HrcDp82OruuEFBW71YK3dk0ad+nED599Qq+mzTgVH0/LAX1J8vuJ/XkeGW2aE1JUCotL8QeDlbYrieakGQop6IaBPxBA001vjehkZpgBhaKoZ6XIbRYLLqcDXyAYzrSUB81Wi0nK9QuCmdEwIBhSCISzAnabJUqWvFBQEXkvGFLILyoh1uOO8jIiCOUXYZSVEjOgb7QkUFzmPS/fBMyJu2KGJFLmscgS2KDUFzD/LUnRybfE58ftsFfinlTExXiZmFnDcqEvDLNsIYUzYJHzHukIMwwdw4gEBkYlhVBN1ynzBdANA5tFRjaEs1Q2L6SBAeAPKviDQWRFBcMsg3mcjt89jv9XURVYVOFPhUWWaTKoP/6Vq3l9wkS6dOpEu65dcDvt+MMrJEEQz1L+8/qDyJKIx+U8K3tRuHErrz/7NH2HjyC/VYtKFusJl1wCQJMrRwPgt9mRLTKxgsCyTz5DD4XYsnEjxd4yho4dy+PLlrDn2+/ZO/VzGoy8DDEcBJwTcXEUlpbS/OYbKr0sAhZJRqhdm8PTf0Tx+iguLWXeQw/xxGWjaN+tB4On/AM9PH5JEBHFcsfOc8lJ+7fv4Mr69c0JE6g/bDBr33mXTgP7U/AXIW2eC5IkkfXzz9Rq2ZrMHl05uGwFzzz2OEMGD0ZOSSUpPRU9NpbGk25nyl13MO+hR1j4+OMMeOJxCotK0XQdb24eB8vKmPDZVEJHj+Gomcmv9z/A7lM5DLt8JF5FxQjrnJgTkEiMy4X36CESGzVEEkXT0lu04Aqz/p3t2+EpLiFJsNJi5Ci05UspXLKMoKpQo3tXREli16xZNBk+3OT86AaqriEKUpQ8G+FEqKqGPxDA+ztcA6tFxmGzhQ3jDBx2G15/wOSh6AagYxgmQbK4zBftOpFlU2hLFAW8/iCqpuOy2yp1P0VgGKbEudcfwB8IEggqCIIZkFQKPgIBvHt2o9jCXiI+H6d37Mabln4WR6QidN2gzB9EkiRk6ewSpSAIKIqKRRKjAYccVk11/0GX1TO3Gzk+ohwIs2QRCAaRws+LiLCVeQgaYliXQhDMV1RNJxhScYRJsoYePvfh7UaOPRKYndlxohsGZb4guqHjcdjD11K4YEbm74CqdtMq/KmI87hJToilZOMWUEPoDge527bR4NprMAyD4lIv+UUlOB12UhLjkEQRXdfJzi3A6bAR53GjalqlUsHOL6bRbNzYi9q/YRjsnv0zNmD5jBnUTEmh5wvPARWY34aBsmsP21eupt3NEy+4vZJ9+zmxahVNxl931n7A5E4cX7aSzB5do2P2HTjAL2++Q7POHak7elR0n5H3z3xAqarKUxNu5LHPPjmL8a7rBidP5/1uOeDPgCxLFCxbxqGdOxj91BPsW7qcI7Nm0fmhB3CKIr6CQk6vXsfuI4fpcu1VuDIzUfYfYtvcn2kz6Q4KS8ooKfVFZZVlWcIiWwAzLR5SFFzFxWj5BQTq1MZht+Gw27CEO4tOzZ2DpmjUH305yDKSIGLs2E3JySziEhMQGjVk+/OvUBj0kahqVOvRHavVijO9GvkFeUz/9DNuvPM2io9mo7rtxKalotWvj9Vuxx8MEutxo2la+I9OUFEJhhRC4XKA1SpHvTkA0pISTMM9AwIhM4V/Kq8QwzCIjXFht1pRVPP7Pl85r0EURVKT4nE77CZfI2AGF4JhIO/ajatDOyBcPvL5KSwpIxgKmaUfSSIxzkOs24UgCBxd+Cv+vfvwZNZE9LhI79WTk6vXkd6iKeqhI+SmpuH1B8+7YhfAlPy2RIKdyhOvFj5ewwCP0x69X/1BU3reabdiOU9b7cWi4tjM4CmEKEnm6MJiZOH/mYF4uBSGYQbuAkZUDtwM6szA3OcPYLVYkGUJIfJbpHIHii8QxABcdms0O1KxZFnVblqFKvyPIQoCrvDDpuTEcWqMGA5A1o6dUFKCEBODx+0Mp35NiWib1RJVO7SHnSIVRQWLBV3XODBrNvHVUv/QOBoPGwJArSGDOT33l3M+5NZv3kRtSYg+PM6HmAb1qeuwc+TLb6g1agTYTfJW5IEqSxK1e3WPvgbgrFePy157mW2ffcG2j6YSKC2h3e23gO1sJ0p19x4O79rD/P37uG3efBwN6+OpWzf6vqarKP8GcfG/DavFQkpCHF8vXMA/XnuFkN+PcfwYne+6g9M791CnZzfciYns3ryNDStXgiQy6OEH+W36dPo+9CCqIOBy2PH6zBW9putoITO1XxHe2BgKNm+iUZMGOBPjAFB0UzgpddAQ3AEfh9//hNrt2iDbbISqVyOpVfPo95PTUmg16fazxp8K9DhyGGudOpSdzKZ6396IgSArPviQLvfcZfIMMDNwkigiWAWcjnKzMjDvd0XV2PHuhzQYNTKskIo5/4UnJLvNgs9vTo5OmxWr1YogiGiaYfIHDD3Me/ChaTpupx2H1YpuGCiKgi1cGtQ0jaJSL0UlZdGAxGKRSYqLiU6iAMcPHMLi89Nw2ODoa+70FISQgiCLJMXFIFBK6QVKa1aLDIJ4zsyGJIrYrVa8/kCUOyEIAg6bFUlS8fmD2CyWszMofwAVv2e1WlBV1dxehTZzASrtP9JBZRjmeY2oZpqlV/HsQMqgkrutYRiUhQm1LruNiMhWJJj5W0YTFfD3lQarwp8Oq0WOBgdCBaJig7Zt2T1rDoEwycxcmcrkFhRRUFRKQXGpSZAKBPH6g/iDpjfF8V/mo/v8ZPTte9FjiDzQIzV4T1oa/sNHznq//ZgrmL9wEUufev6C2zMMA0tGBtX69+bAd99jlJZGMxAV93WulHGL666l1Y3X07Bvb7Z/8hn+fQej2wT49YOPmP7hRzz70osAeIN+dEflOq4annT/arBaZErXrcd2OpcVTzzNxmdfoP4VowiVeanT0RRn0g2DNqNGcNPDD9F98CBAoMedt/PGuPGIhoFVlnHaz8+ylyQRl9PJtHfe5vOJE6IlJFkUsXjLsG7ZTNHS5ew5dABrl07Qrg229HQAgkVFAHzw9bTzrs5j4pMwkpNZuWkzBRs3gsdN07Zto7bhEefSqEhZUREFq9cjHjyMsmsPW77/gZdGj2H93NkUfPcd3pMnKS7zUlRaRkFRCSFFIdZtmqqFggqKYhqaOexW4mJcuJ12EuJisNtMhdVASCG3yPQyiXQRmUGHl+zcAgqKSzCAhLgY0pITSE82Rcoqchi63HA9+WVlnNi8OXrcMbVqgW6AKGOxyCTGx+DdsP7sexYzWBEBTVPx+vznJLdKomgqmp4huW2VTR6ComlmOeE/cN9GylyapkftRc3ftilzHyF9msRMzTSKC/NJdEMvV+g8k9xZAYZhRImsHqfdVP0Ml1DO7ID5u6IqsKjCnwa302GqFhYUElcjEwgTGGvVJM/p4uTpfLJzC6JeD4qq4Q8GURTNrO36ApR6vRiGqTSZ0rARyemp/1a7WQSONi1Z98VXlWS4NV1Hx6DWJe3Yt2nDWd8xDAPF68VfXIxu6IQ0FRISqHP1lez9cRa6cbYq47kQCTjiWzSn9a03sX/9WvZ+8SWf3nAT86Y8zs7ffmP16tU8/8KL3NixI7VGjCA2Lo5v7n+w0lj+apBEEaGkiIT2bSguKqZG+3acOHKEaXdMIiGjGkI4OBIFAUkUSevelaLiQo5NnwnBINffdy+/vfx6OI0fg620lKOLFpdvX5JY8dlUUhPjSY5106xhI77IzeeJrt3Z/unnrHn1LcTTubi7dSX1ytH0ufFG8n77zZwodZ39X35F0eo1ADx0250AHJgzl2m33M7pDeb1zl6+iuQG9fnhpVfwBBUcThczbr+T555/gYOz5rDgpVeY/sTTrProU9a99wGb3nibp4aOwL9tM/7Dhzm5eSvWo0fo1r07vpISdu7cQVJ6WlTxMzE+BsPA1KgId5H4AkEkQUAwzPS93WHyMTxuJ5IooGsamqrh8wfIPp3P6YJiCotLyckrjJYfbBYLMS7T8lwWRcp8pjiZGpa/Vk9kMWjKw1Rv3Zpds34uL9kF/Chh1VZZEomXBNwVROksskRSQizVU5OIifHgcTkJKSqKcna7Z2R+Fs9ozYzwXzxOO5IkUuz1R8f1f4HFIqNVUOg1dDNwMMI5C0E0yZnn7JqJdpFUGHj4HQhLsQdM5dSK58PQjah+xrkWDn83VHEsqvCnQJYkMlKTsFpkvrr1Dq557WV0q43iMi8FxSW/29Z3JsSwrLXTbsPlsGMLr+r+6A/cMAz8u/egnsohpndPwAwsVE1DN3Tm3HArXcePJ75RvehqN5qRCEs7q5oeTrNCwdqNZO/dTYvx487rEnmhsYS8XiRJQrLbIRhkz48/8trrb7INWDV/Hj8+8TTD7rwNKdMMzIIhhROncv8y4jw2UaB4zRqmffEFA3r2oCznNNOXL2NYt+54LDIDnnrinB0MIVVB1TR2v/8JbW+5gdztO8ndu4+GV45m+VvvUHzyJDv3H6D31WNpOqgfz/TtT2x6Bvm6yv1XXc34114lDbj6uvFccvkIlKNH8Z3KJXPYIACOT/+BxDYtyd+8hfT+/dDsNgQEvIsWs2XuPHq+8CyCJDH/8WcoysshPz+f4RMnsGvBYqo3qMP8OfP4riCPF7v3Iq51S/Zu3cb2NWt4+L23wW4na+069ixdRu3mTdl26DA+TeXq225jyLXX0hAY3LwFtZo3p/EdtyIIAofm/EztIYPRNJ3fnnuRZpdeCulpBBUFR9j23FRSFbDbrGFxKoNAMFQeAIRC2I8cpqx+gyih0ex0sOB02AkqSlQILDHOQ3yMpxIJ0qjQLaHn5KKWlCDVqYUgCByZ8QNpQ4dyuqAIQRBITYyLKoIa5jKfQEjB7w8SF1uZa6EbBsVhxVy3w3beNtiQquEPBPG4HP82qRPMMlBZmc80NBQiRRAqZTDM/wiTWxXV7KQJt4pGxhMMhrDZrFFjRAQBfyCEqptEzYiUu6pqSNK5+VB/V45FVWBRhT8FLoed9OQERFFkx8dTaTrhOkrKfOQWFv+fU6KiIOCw24h1u3BU0BK4WOi6zqEZM6ndvx9SbKz5Wrhl9PRvy/jokUep3aIF3UZfQWaYL4FhQEkJ6uk8Tu7ZQyikEJsYj6qoxNSvi6NmJnJIoWznHnz5uaT264twnkDj0G+/UadHDwDmvfUOOYcOM/7ZpzixaxczX3udNF3g6wP7aFGnLm6blXs+eD+8uBLwBQLkhlPjfzZsFgsLpzyC2+ejZtfOvPfVNK7p2Jn0rp2YMfVz7nv4H2z9fiadn3oc7PZKk5ym66i6xoq33mHKd9MZUa06yQKM+3YaIVVBADTDYPFzL5KRnsYdUz/jtpQUrvnuG7zrN6BLEqH8QrTkZCbffRf/uvseUrp1xlOtGgDawcNs/+ZbWj78IMVlPgqLS/C4nCTGxfDj2HHEJydz8uRJGrRuTf2RlzFl/PU4gTuffArZYWfrwsVs2b6VfJ+fpmmpFObm8k1+Htci0KJ9J4osAnX69aVardoUrlvPkW1byc/OZuqhgzzYth0ZvXsSCASok1mT7GPHSaxVk5iwn8zSJ56lRpNG+JwOFnw9nW6D+lPq9dNo+NBwyj1c7jLAZrVGyZPHZ83m6+++566PPzK7S3SdYOjcJF5JEkmOjyXG7Yq+FuEZIBiUbt7K0dVria9dm1iXE0eTRogJiYRUFSkcxEevl64TLC1DslopLfXiiPXgsFkr7U/XdYrKfMR5XBcsMfiDIXTDiPIW/h0YhoHX58fQDaw2SzSgAANFUZHDXTyRIEJRIpbyFd1Lwe/3Y7fbsVpN4bwIGdcTybSGSyiRMuq5xlsVWPzNUBVY/HkQBEhJiCfG7eSHeyfTY+y1uJo34VRewX9U2EkURWJcDuJiPGfJHl8IhmGgKSob3v2ADpNuq9wdoqlR86LDP84ipKg0vmIUy197nWqZNXElJpPcoA5iWjqhEyc4PG8+dRs1RLVaMRCQ01MJlnnJ37IVLBb8ukbLa8dWGps/O5tt8+bTYcJ4ALwHD3HNNddyw5grKS0q4Lf5C3h75QoQQNd0jq9fR2DPfnLycsk6eoxe48ZhqV+PopKy/2hpRJLEC2aSTLa9uUKUJQll/34+f+E5BnbvwZpVq/k+9zQADQA3kAOkAIk1a9MoPZ2rnnsKIcy50XWdk+s28c7zz7M0J5tfn3+eBx98kDuuGUftmyZErcojhNj5L71G0datVI+LY/muPbRp3ICTR47TuEsn2ky6nScGDubJaV+xf9Zcmt51GwCB5auxd+tEIBjiwMwfyT9xnJTUNBZ9/z0TX3yeec88R+B4FtV69+Khn2cz99uvia1eHQP44h8Pc/zECQZ26crJvXuISU0jNy+fXleMxh0XR+7Bg1gwyM/Opnq37oiKwsI332Tdnj24lBBN0qtTZpFYdOwoN3brTv22bSkydJLT0vAeOsivi5aw69BBkl0eujRvxraDRxh6/Ti2bt1Czbp1iYlPwGmzcnzvfmzJSdRKT+OrV17lQM4pXli1Ap8/SHFhEUHdiHZNybJEKKSAIOB0mIG32ZUSXcoTaZ/IXboMxWrH1qQxFlnG43IQEaM6s51VC5MfdUVBNSAkisS5nZU+p+sGhaVe4j3OCxqj6bpOiS+Ay249q8X8YhDhUKiqSigUwul0Qpj7Uq5KKiDLcrTsoYQUJElEFCUEUYgGPoFAEFmWMBAIKgqqpkf1NyoqnJ7ZDl4RVYHF3wxVgcWfB6tFplpKElYlxItjrua+WT+QV1hMUUnZf2V/DruNhFgPzj+wCjIMgxO/LsLpchPf8ZJoaUEQzJZRA7OuenLufHyCQKCwgObXXFW+Oop0tEGUNFbRH0TQDQIHDrBz3gJqdOpAtTPcTw/9OJugt5S4ho1YvXQpwydO4NiWbdzw8EP4gY9uuZnG116Dpum8fced3P3+u9Hvnpq7gB1bN5NcqzZCTCxSUhKW1D/WKXMmJFEkxmPW0VU17N9S4dkhSxK2Y0d5afJ9pLVuzaRXXiG0fz/rvprGd78tJRfIB/okJrE3P497ho+g9Q3jkRIT0XWdGU88w949uzDcbqyCSFZ2NpNuuZm6QwZFJ6KQqrDm6RfYevggt7z0AkZcbJgwJyIBn915NzUFsDVsQJ2mzcgrKSV/43rk+ES+mDmDzq1a07x1K9reONG8D3Lz0AoK8AoCv736BtO2bEIACoF6wL3/eAhXKEh8vz7kr15LXN9eiIKALJkT3q6pn7Pi+++47LEnSGjamE2ff84lo0ZiJCZW0FYw76V9X08ntUljZn/wPou2bKFt69Yc33+AQ2WlDG7alE07d9K/YVPyHVYadOvOnl9/ZdgDD/DlhBu58tFHWL5yJX3vvZudX32NoOs0GjKIk4eOENi1i2DHrqQmxVPw6SfUatGMtFGXATDrjkn0fupJvJoOhoDLaUNRVQwwVUHDXSmRqyiLIpIoYWCQt2I1iU0bo8fEmFyICh0WFWHoOorPjxTOUPhCGpquEXtGYGEYBkVlfhxWswPkfIhkBkKKGm1P/SOIEDMNw8DvD+B0OpAkCcPAlFYPly6s1vKMiqIoJslXlsLXzTwrgUCQkKphhLtYLGH1UHM/erh998L2An/XwKKq3bQK/3O4HHZkWSJ/yy5aNm+Boet/yATqj8IfCJKjqsR73MSEU7G/98ASBIGMPr05+v1MYvR20QerpuuIgmjKbQsgJiVzfM0qet91R/iL5dswon+Xd4SYk7GBIEu4GjeiXcMGrH/5ddKbNwW3OzquOiOGsX3q5zhtFi6ffK/5Wq/udE5JZdHpHH56730ObdxEv388QOP6DSqNPW1wf1IH9aNs83bWzZ7Fhu3bKfP6GH7//cTWqfNvnUMDk5zmtNvCrY0aXp9pCmeRJeJjPfz0yAeoFjvbN2/mn0OHU79ObbyHDvPa9G8pmTWXVdu3Uat7NxqtXUfh6VOseOFlWlxzDQktmjLysX8C5gNbFMpFwSqWRyyyTMeHH8A35V/89P5HrF63nvuf+BcJTRsjShI7tm6hOCaWSc8+w7Rnn6NT9x5kJaUw6J5JNOzeja+ff4GEuHgASvbvJ2/fARZ/NY2PDx9iZFIKR4CF079j+XfTGTDpTkRZAl3no8tGMWay6QGjGwaariGLEjM++5zUxATs6SkUbNlM9sHDkJR0ln+Hbhh4Yj3M/uYbrnz8MVzPvEDTNq35/nQODwwZSoPrxxN85S2OnTrFtC3rYctmbk1IZe0PP1EgW8g+fZqsAweY/dpb7NmzA6nEy6zZcxk7biwFJ7PIWbaMQgneWbSAK44epunBg6TUr8/mvHya/DKfUp+PFuPHVQokFE1FLylFjPGUX+PwDSsKIh6rBdHhAOFsgbZK94VhYGhmecYXVCCcJTzz87phYJFFfMEQFot0Xg6FIAjYLDIhRSWoqNgs55YmPx/MTlLz86IkoSiqGVhgRI/dLCVpSGEnUnORoIMgm5wJXcfrD4KuIUkSLocNSZJMoa1wRkTTdCx/cGx/J1R1hVThfwarxUJCXAyL3niDfe+8hzstlVXLl0OZ9/9E1roYqKpGXlEJ+YUlF80/EAQBV7U0Pho/AQMzqIhMdpJgPmzTO7Sl912mWVUk3XpmQ78AWCQJOfxHFMRo9kIURVqNu5rpjz7O4scexygujn4vJi4OzmgnffCl5xlTqzazgWfWr2f1Bx8z4O47o+97i4qjY/e0aUHvR//JA9O/YfKH7/LhPx+i5MiRP3jmTJgrQTM7YLdYEHKySU9OpFpKIqlJCSx69jkO79tLv26dGHfVVdw+cTwjR1xKrNvFU6PHUOB2M/iaqyncuIm6tWqRXVzCrBXLKc3PjwoXgSnLHPVmOIvUaa4QM5s3pUOTxtx1wwTef+llTm/ciG7odB82jIlPPsmKhx5m9bJllCkhfD4vum6Q1K4tt3/zFb9+9RUDOnfFv3IV6776mq8OH8IDVG/RgitSU7HJMk2aNUWIeHCIIh1bt+bkkSOo+832Xy3McXh0ya/cMmM6sTVqsG3JMkb8a8q5OwIMmD9rFlJpCSUbN9O6TWs8SYnUTEmlboN65C9dhqe0kEs6d6Qm0NMRi9K8CVuXLGWL4mX5z3PYc+Qg/gXz4dhRGtkdZJcVILRtj6tmLZokJ9GhZXOe7taLJJcLLeDnt7Vr2Hj8GMGQwrr16/ni4UfwnThR7topmF0lgdOny8dZYdhKUAlfD/GCRmwR/YZSrx9RkvA4zw4qVE2jNOxMfDH8qYjOhSmiVd5lEv19XcT3BcHkgSiKUqnTRBBFZIsM4W0Fg0FTbdMwMML3uNcfwG41ZdbDquEYenkpRdd1ROkcWhdhRMb5d60GQFXGogr/Q9gsMlZZpv9tt6GvXMnXz73I3R+8x9zXXsdbUsqMVSuZ/OjjJDRu9G+7Sl4IhmFQVFpGSFFITYr/3RquIAgIMbF0bX8JaFq06wNMPoFuCBiCgdcbwG6zEFK0sFeDFF7NVBTjqazIV/FvW2oqo195keCpU2z9chotb7kJQZJQ/QFiKxigGYaBu149evXtx5qPPuAo0PP+e6NeKACuuNizjgEgJiOD6yfdwa6ZM+l4773/1vkrLfNhs1o4+vM85s+Zgyc+gfhq6TSuUxfJ52d4925o+QVsOnSYx44c4eHmLXDUqoWq6zQeM5Ktb75Dia4RKi7hsgcmo7zwEod37WLL2rU4ExLodcN48wEumg94wygP5LSwKBoI1L9yDN/edz9jn3ycK07nsfXnX0hr147dBw/SplkzHtqyBYC3nn8eP9C2S1cyunTi1K+L8RbkUQpc+/4H3NO9G+9fMYrYhHicrVvzza238dnkBxk44lL8WVk4MjIASG7TmpRhQ8hZ8hveXbvJuHQoalidMRIQN2vbGtzuc99HIoy8/35++fwL4vr1JS5c3b+qf1+T7+AL0N5hJ5B1ghdff50Da9fR5ZYb2Tf7Z/wvvsiApk05eOwIQ++/l9zTeRAIMPfbaSTs340YH4sjKQlX8yb88t67TBw5kkJNY1yPrqSkptJgyCAaDBnErhk/sG/WXAqPHqbRtWNJy8xESkhAPXoMiySXa5+czDZX9YoKwSCC3X7B36IBBAUBi9WK+xylC8Mw8PqD2K2WKAnyYrxAZEnE47BTFgjiDyoIhknWjbznsFmiXVZnB3Jmd4skSwghAU3TQBCRwwRLWZIIhUKoqoYgSlFxsZDiR9U13A4Hdptpdx8MBMxshiRE+UWCWLnEU1lWnCgHSxD+vuv2qsCiCv8zlPr8UQU/sU07urZpRy7QZMJEJFGk8+TJ2KxWvD7/f7WrwRcIUlTqJTEu5qy09ZlIat6M+Dp1OPL1t6T06Yk9Nc3UpQhPeoZuZl5LynzYbVYcDitGBa+BM3GufUUDjLQ0Go28jO9uupkrPvoQr88XFVyquPppMWEcb6Ylc/9TTzOkb3/mrl75u8cs+P0E9x9E93k5tmIFmV27XsSZqoyQoqKpOoI/wJ0ffYCiKNzSszcfAyMvuYQ9x49x/MQJZLudOKDFyMvI7N+Pxh9+hGC10uq+u2lVYXsTP/4g3BKpR7MAAqaGg4BuPpzDD3FJFJEQo6nszGrp6C4n+UqIH39dyDe/LiQEnDp6jPenPErezh3s2n+ANdu3cevDD3FLk6aU5OZRmphM25xT9G9/CQ1jE6h96TCKtm7nq/ETqd+kMUZKMtVGDOPIzB+pNXokuz75FItsJQVI7dWDooMHKV64mNg+PVHDY5cliWNHjpF+vnOPgLNWTZb8upCuPbuR1qtX2NXCTM7vmfkDW9esoXXXLlRLTWbN7l3s/vpbijdvpmF8IsUJcfQeOpT0fn0pnDqVY/4yrEBci6akZWSw8ZvpvPnEk5xWQ8z7+Wfa9+0HaenoBYUUbthAidPJ+uUrGDxsCEXHj/P4zbdy96RJeFxOPCEdsaCIUp8Xj9PJhuPHsash9q9eg2X9Olo3boxutVJjYL9z3rshRcUQRFznaSM1W7V1nDaxArn39xHRuIh1OVC1iEW7OVErqoY3EEIAk/sgVw4wIhN7RNFUVTVCagiHzYooRLpqDFTdQFc0RFHAarVES3ARx9jIUE03VLMEGvktRrQwIlfY0M1gUYyQP8/4zf7dUBVYVOFPQUWdBU0zoquBCzkp/idRUmqWXzwuRyXb5zMhCAKSy0nNK0ax/9vvqDv2qiibPKLQ53DYsFhkFNUU5RHlM1cqlTUCzgdBELAmJnJ4127mTLoXX8CHy+WkzuiRIIr4T51Cyc0jpnkzaNCAt3/6kQcvHYGWm4uUnHzObRqGwcGFizi2eze9Jt9HN7uNU7kFeMNyxH8ENqsFm82CIy6Wk3N/ITcnBwloCbRo2oSP1q1jC7Bq8a8c+Owr1ixbSWb/fmQ2bsKShx6hbsdLWLR4Kde//op5vOWnJ3o/GBjh1bMQZd9X5KfounmOu0y+DwODDjdeT/uJ12EEgqCqfDflMXS/j+633kL7Y8dYO/EGXp80iUMnT+LRVJooKnEns9myfh0bgY5uJ/1uv5Uu/fuxavkyOtesgV5Swo6VK1k7fz4dLrscl0VGLShETognrm5dtGrpHP3+RzIuH44uyxz8/gesFcis51JVNYJBrIBLrMwvMAyDVtdeze5161DLypjx0SekJafgTkvjZEIiA564Ft+Rwxw6nsW2Dz9i46rVDBl7Fbs3bOT12++mQctm1GvdmusnjEcWZfavWMHin+cQNDROFBTQQFFxBYI44uJweGJwxsRw67BhxFerRlr3rhz4djoxbVoRH1aMbNeuDQBNRo6Mli0uxK9QfocHEQgq2KyWqHjUH0Fkm2e6oJqZTyksmBciqIi4ws7HYGYTDcH822Kx4PcHkCURVVWxyLKpWWEYhAJBYtwO83cpUKmEGRHYslqthEIhXC5XuWMqArqmI0qRLGR5xqIiJ+jvzL+oCiyq8LeEpuvkFRbjDwRJio+NOlSeC4IgINls1O3Xj8Mzf6LmZcPPel+WJVRNRwmpWKyRPvkwMYzyIORCMAyDdyfeyF3vvAUuFwQVSvfv59O77uHa117BkpxM6OBhDs/8kTojL8MwDG4afRVTho9g6IQJdL7xbIO0Q2vWs3vLdlqPu4YSTceXXxQ1wfojkCSRmDDT//jipUxetYJ7uvdk4sDBTPllLos/ncq/uvdmmCzy20uvEmO3oRYXohsGCZ070sLpYvfy34jBIH/DJmLbtAyLMp2tFmpyLkzPhrNOmWBmNEwiHeHskYHVZeoxNK2RSaOWLdj+zbc0v/pKRg8azKI1a7jmhok4mzSGvHz0QIC37rqHHlddyYrZsyk9ncOrixaz4MMPuO/Gm6g5+2datWxBmstJRqcOSA4HJ6fPoPq1V5v3gsOJrVo6Res2EteuNYUHDtBi3Fg0XT+LKxRJlc9/+126dutCXK+eZxyOQOj4Ceo0aUyriRNoVVaGXlaGUlTMiVgP21cuw5+dTWF+ITFNGtFjyECOrFhF/Zq16H/dOFa8/hp7Vywns30HOl09hviURJY+8STVV6zAYbOTGJ9AfFIifdu2IS7WTUZ6OgnV0rE3aYSh69hEGelUDmSkVxpzhOcSuUbngwEYSggVA9lRuRQS8Un5owTMi4EgmJbyFlnCGwhSFgjidtgpzyFECJxmlksLS3WrIRVB1DAwcDvtlYncFYKCyN+mFbtUWaci+n550qJiB1AVqgKLKvzNEVm5pybGX3BVJQgClvQ0qjVrStGyFcR173rW+zarhWAwhKjryKJUTkI0P3DO7X7/wD9ISUig24P349u9m3oNG2Nr2ZJpk+9n7MsvYatdE2HWbLp368H9AwahySJ7Vq+h6aw56BaJU4WFbAD+1acXAEYoxLJPPqXE50P1+dly4ABX3nUPvkAQf9iJ8WIhCOCw2zF08yG87uNPkUSRujUyeG74peTk51NgkfAAtYB/LVtMc2DS9RMw4mKYOm0awpTHcAYCxKekYI2NZdiLz1O4bh0HvptJUsN6eJo3I5SXR/bKNdTs3AGSkytMQgZf33UvV7/xWvQcm+UQgy1ffU3TS4eBw44oiuiGjoiA125DrJVJg9692T3nF4b8435OrNvIw7feTvUGDXDLEo0aNWZ6zil2vvYa4666mvbjrmHlosXce+NN7ABqFBVRr159guh8fMvttB84AG9pKQfeeoeyk9l0vX4c6T26seaZZ0k/cIAWd9wKdjuaoSOF+fCGYaAHgyz/+FPKSsvoe/ll5z3PWb+toONtt5g+FR4PgtuFkZhAi8zrcTlMa3FdVflk3HVc+ugUCkvKqO52Y2vaiFY3TKTkwCGycnL44tY70K1WXMDAK6/k3VdfZd+yZWiAG4nE+vUQPG62bN5Mx769zY4PmwWjWlqYE1CZ+xO9D857fwiIAgQVDdsZJGPzHJiBnyj+91bugiDgstvw+k3fIKfNCmGDMd0wCAQVsyNFEKJdHIYBFosULm0QDVQrjlsIB1WyJKOElLMyEKJUOeiNBGARi3bDMExuxt8UVYFFFf728PkDlHp9xMW4L7iyEgQBV6OGlB09jnriJHL1ame8D1abBU3VCGkGVotcyc79TNzRqQuTJk/GQOCBzl3p07o1PV9/BUVTGfOiaXYmut2M/eA9Gn72BR0njscwDHx79zH96af4bt8RIj0kOzdtpWVaGrNfeJVeN08EUSQ/O5dWSYlRyec/ElRIoojDbiM5PhYE2DHtGxo2akBml84UrFlPwbx5LFqzmjRg8vBhtL3nHvZ98inNb72Zaf+cQmxaGguWLeWzceNJjo1l3/bt9B93HaIkEd+xI3GGQdYv85n/0VT6DR9CYqMGrP1sGqmZ1dFUjbpXXA6SjDPs8GoYBpSVkbNlG6vmzmXe0qXY3nmHV3+ejRgXF3a8Bbsom22EmRkULfqVzTN+oNXoUfTv0YMWl7Tn6MpVrN24kQxgSM1aTPl6GsrX0wB44oor6HDsGGMm38dv07/HW1hEUcBHq6GDERITKdmwAQWBE5u2sePbmaQ3bkS1EcPKT1pEOdowyN21m9yNm+l8zdXInhgEAbzbd1K6cTOetq0rnWtVipB7zUlN08LkVcIcDkGErBOMfexRPnr8Ka647lo2LFmK8eoblOTm0rh7d6a9+w7PP/scAZ+XrsOHsXDuPOqkpVFqQLP0VIqKCrG0akGGy4V90RKEg4fAacduscDJkxghBZwOEEXQdQKlZcjJSQhu9wXvYYfDjqYbBFUNp6XydKLpeiUzsP8WBEHAabfh9QfwB0PYbVYwwB805bftNiu6rkW5EyBULksakWIlRLpVjYpvAsFgCLu93G34TG5WJEMZ+YoeLqX8XVEVWFThbw8DKC7z4XY5LqpTJKV/H7yLlyJn1kDTtXJNLEFAEgRES7mHgCXM3zjzITPjzrtokJ5B/ctHADDq8BGade4QHU/FB58kS1gFES0nB0t6Ou7Gjbh+6lSGLlnKqqXLeH7JYn59710WfP4lksNGZ5vdtNWOiwX1wkqmJUeOkXfkIHV69oq+JooCKYlxOGw2JElELSxi36o1pMTGcGL/AbYuXkq1OrXYBliB4weP8G2v3jiBlF27OLZ9B1eOHs2LV1zJ3W+8xk/PPEfnnj3Rw6JEoiCAP0BGuzbUPHwET++eGLpOu3tMLZDQ6Vx2Tv2S1Ixq1Muozol588kY2J9l732APT6eQY8/Sn/fZA7/8COf3XkXbfv2w+60EywrQ/B52fDWO7S/5Sa6TJzA0V+XkLtmLZnp6WxdvoJSTeWet15H8MTwZreeKEAvYNSNN6FjsDmvgPy1G2iQkUGtCdez5s13WPjFl5Tl5JB74gQ3ffEZsqIg5+VSqCrUREQnwkUwz5+qaqz8fiaXTnm4ksqku0UzFjz0CE38Qap3DQuilZSQkJpS6ZqIgoDNZsEWXgVruo4/v4iSgwdp1qo11uRk4m0O1m7ZwlV338mJ7bsZ0aULzzzxBM1qZNL7qiuZt3oVg7t3J7NtG7Zv2czu3XtIOn6ClEYN2bX/IGkhBauoE1/i4/T+gwT9fmwOBzanA19QwX/kCJl9eqJVcEM910QpiSJ2m/Wc3ChZErHKUlTr5L8FXdfJLSimoKgUV1huu9TrN6XBHTaS4mLIyS8BMO9ru2njfjq/CKtFJikhluJSHwmxbtNRORAkEFTCKqUQ43JgtVjIOl2AVZZJTorD0HWKS32kJsXhD4QIhBTiPK7weTLLeP/NTM1fHVWBRRWqAIQUBZ8/QIzb9btZC1EUKXY6yZs+k2ojLz3nZ8z/ML0PXA77WanUouJimna8JPrv9Eva8/KUR3ngl58Rwp4FEK7zItBwQD9mPvkMV7z9BoIgcHTOHF584SXeXLUC6c1Unvn6a/B6AeixaiVJrdtelH26Q9f45f33aLjsN4Y982zUFRMqqAp63Ay99lqys09Qb9RIvp89B9/q1QCcADbs30dcXBzNOnTgsltvRkxKwjAMco4cZtXX37B6yxa6DB1CyZEj6HVrsejjqWguJxkpKbQZe2UFLooZUllSkmhy3VgW3P8QHceMJhRS2fzhJ6SmpNJw3FhUTUOxWKgxehR1rxyDrutIBQVILhdCTCyCqrLn82mkdGxLjT49+e3pZ0msUYP+D07m4SuuptPS5WTlnmYHOg927ETdZs1xiBIns44R73KQMXwwysmTrPr8C05kZzHm1Vf4+dnnCIkiH952J7Vq1qLfA/ex9d0PWPfe+1wy9mp0JUSPEZfTLzGJ5q1b07hzp7Okq33r1xOTmVkeVADExFBWWkpShc9JooREuZiTYRiIqcnEJcaj79vLr1M/o+OVV+Bd62HfwsU0aNCIX48cpW+LFvy0dg1fPP4vGgJZ2Tlk7NpFk6ZN8J/KoWzPPsrWbSTn8CG633ojALkLFpLas3slbkAskGeVIZw1UTQVi3R+noQsSabLaiBYSd3WJD+aYlf/TTJjqdfP+m37qJ6WhKJqxLid5OQVoigqNaunsnHHftO4TZY4np1Lg9oZ7D5wnOTEWIpKVEDg4NGTNKidwaHjp6hdIw3DMNh/JIuEOA+GAVmnjpMYH4PPH+BkbgEZqYmsWL+DLu2aYRgG+cWlxDWqXUGf5sLdZv+voyqwqEIVwijx+vC4nBf1QMjo1IGtBw7gnfED9UeeXT+PtMuZUsKVSX37p32DRZLpevddqKqGomkkXdKO5i1bQyCAYbejaeZ3IqJctrRUWl52OXMffZzBTzzGsy+8xJh+fREEgaF33k77Ht257JZbAWg9cCAncnIv6pjt9erSqWMnqiUn8cn4CYx8+mkcKclnCBkJnM7P5dTBQ+RNnUqmw05QEmlbXMxGwBUK8vmiBVFTNUVTkSWJ4S8+j6br1GzSmO8//Ahd0ai9YT29Jt+LlJaKRZJNYSKM6CQc8XIQLDLOtFRS2rdDt1lJ69mtkjusHiZFKhFTroQELLKMqGuIskSD8dey7pXXad+oMfUGDGDjt9M5fOgoz/4wHcHppAYC+zZtYveuPfS8+SaOr1zJt3N+ZlC3HqDryOnpdLn5JgLHjjH3/gfZm5ODx+MmJTUFt8fDb888z/Hdu7jm3beZ9/wLbNy2ncf696X/Y49V6gyI3AsAP3/5NaNffqHS+fdnZaHLFVLsFe+9CElVEHBkVMMwIGQYjHr9VQ7PnoOjoAjVaScv4MXjcpLRsQN9kpMQ5y+i36VDyEyvhlhSgurzU61lC1JSUzhSVkqZLLP8/Q9p3qObubzOykaoSN7MOonFakezVFCmvMA9JBg6bruVopIyrLKMpUJJRJYkfP4Qmm4gS//+RHum3XpFWGQJm9VCSZmP2jXSSE9JwB8M4Q8EiXE5OarkcEnLhmiqxrZ9R9i6+xCpSfE0q18LQRAIhkJs33OI9dv2kZmRQnpyPLpukHUqj4yUBMp8AWLdThrVyUDTDFZu2kWcx/RZORAJPnQ9Wh75u3eEQJXyZhWqEEUwpEb5CBdCJGvR4pqxxNgd520jNT8nhC3Xy5X4Fv48l5jYWAKhEIpuOiYWFpdSt1NHji34FQhLRxtmcBExkKrRtTN7Dh5kythr8QNdJ90Z3WZA0xlcrz53NW7KK9268/qVV17UMWu6TofJk3E6ndgsEs5TWcTFuHHY7RXaDWHRkiU44+PpOHAgLVu0pHGnjry+YhlXxSdQBGx+5VWWvPQqWevXh71RzO0bhkG1AQO46oUXUCQRe0Z1rBnVwoRLUw+k0qRhig8giyK977+Pn59+Fr2w6CzLeTHM1pdlGVESQQBV19AMPRqstLp0KJs+/JhqbVpz+NRJJFFAcpuW3qKqUjs9ncv79cUfCjBvxUrad+iIS4LDvywEAXR09mzcjBIK0KJFczr17E2nQYM4tm8vW3NOkZiWxiODh/Hjb7+RVqsWiXXqcWrnruj1O1NlcvTrr1QSMwNwZGRQZ+jAC9w/YlRfQRQFWlw6HEEUqHPpMLx2K+1uvYUGl4/A7nTSePRIamfW4rY7b8N/9Bhr5s0jze2i5NAhFs2ezdYZMxELC6keDFIzLZWtn32JeugoRQf2U7xrD3nzfyW0fgOFR49ybOECBL+CiIBFlC4oaqUrKug6giiedcymBoRwsfIVF8S5Gi4ik3jTBrVITYpny66DBAIhs9sDsFhkdF0nEFTQDMN0Hfa48PoCeMPcqmBIRdN1UhLjyC8soaCoFEUxlUfFcKnHHwwRCqmU+QJgmPL2CXEeMjNS2H8kC1XTos6zVajKWFShClHouk6ZL4AoihflrCiKAobFwvH5C6g+oF+l9/bN/IkGl4fLJAKomoosyYhA/0uHM2/qVGTJ7Bqx2y2IokDi8KEouafNiRkDTTcQJcFkrwNOu5X42Bj6DB3GrU89yV0jRjKg/wA6jxjOy7ffjiOzBqM+/Yhu3XqAqnBnaSmqx3PWuM8FR/UMGqSlUq17V2weT6XJfvvnX5F/8DCfr1lDmtuNLzuHA3mnOb5wMQOGDiPrq6/Yv2Ub9phYUm69MeqpEFFK1HQNZ2YGE194hqVvvYMkiKiGFtUD0QwdwYgIC4Fh6IRUFVEU6PfPh9j11TdYkxJpdOkwszSAYbpT6gaCYdb5I6PVDQNB17HIEvYG9aiblcWsB/+B6PVx8sA+fnv/I9x2Owt//Im9eae5vGlT1s2ZzRPTvyFvxy6+/egj6vawUbb3AHu3bmX78hVc//ILzH72RbasXE5vzyCO7dlDvSZNUAIKV1x7LXV7dGP/ilW06t+XvE1bOJidRc3evdnw1dd4fT763nrLWW2IZ2Y1LvRaxdJCZquW0fdKAwHWvfI6vhg3msVKzrwFJHhcbN+xE91uY8wjDxE4fIzmA/qT2rARy5csJiExkc1r11F9334km42Udm2Qw9oVNGmEYRjE6gZWpws51o0hXNgrBEB22PH7A6ZDaDiAjnw+EFKwW+WLUtu8EIQLBCeBYIgDR7LQdYOUxDgsFhlbWOUzzuOkRrUUtuw6iCAKxMd5qJtZjb2HjrNh2z4kSaRerQxSE+NpUj+Tk6cLyM4tpEn9TFxOO7IskxAXQ1Gpl827DmFgUK9mNdxOB6VOHzXSkyksLsVqsZjibmFzsggR12o995j/X0eVu2kVqlABgiDgdjqI9bhw2Ky/m9LUdZ0D076h5sjLMMIEtcINm5jx0kskpqazafMmBo25ks6334woCEiixNy776HYgMtfeqESlyLSU19RO0ASRWSxXMBL13UeGjCEwrISnvjiCyzx8QwdOhSA5pichyLKU9eNgX/860mE+vUwzuPHIksSdpuNk/N+IbNVC9wN6qFqOjFuJ4YB8x/9F7Vr1WbrurVs2bmbSf98kLWLltB9yFAObdrIb99/zwkMxg4agj0+hga33hIlsIEpBa5jYLVITLv9LkY8+CD26ulhUSwj3LpnThxRgzdAxDxfoihwes480ocPMS2xde2sMoMezlREvmeRZb66biINGjehzcTryFmzjuK8PESXG5fDyU9ffcF3WVk0AN6b+ikz3nqbK199hV+nPIqqGwiSQJ1OnakzsB+6brD7m+9oPGY0Fllm6v0PoOYVkHcsi3FT/okjLgahrIy831Zwyi7x6Y+z+HDBPAy7HYskR/UgIlbvFam5EVkwoYJ/jGEY0RLYhQzzDMPg5Lz5ZAweGD0fuqry9LARtGzeHMli4eTRo7Tr2pmcPXuRnC52ncwiPTGB0Y9NIW/tBkQgqX/fStvUNJ3A9h24MqtjxCeEr2V4DFnZlTQvIggGQxQVFuOQRDxJCdHPl/nMgMNh++/MsJHjDoYUVFULi3HJqJpqZjgE8PqCWGQJAbDbTWXcQDCIphtgYMp3Y7ouq5pOKBTCIkuEFA1RMFU5DQxKS71IsoTDZo/K+5vf0TB04yxTMsMwsFrtf8uaSFVgUYUqnAM2q4XUxHisVsvvyn4fmjOXmLhYnE0asf3779m5fjNXv/OG2ZEhyzzUvRcngC51ahPn9rB82zbeXLLIDCp+J3ARAItsqbTi0w2DZ8dcRftWLZk6ew6HgUuAR+bOxef1sf2Tj/lt3jxu+/obkCTU3Fz0Q4dx2e0oycmoaWmVVsUWWSa/sAQpEKBw61bqDxloTiY+P6rNzoFPP2HXiSxC3jK2HdhHnw5dWLJ2JUP6DyYlNY0aNonHP/qQp7+dTujbb9lUUkqbm28mOSGWvIJicguKSUtOICnRgxIMseub76k2dEhUAh1ACvf/V5RlNjCQwhPuwQ8/pN646xAcdrO0FH6v4gQd8e8AkMMKl4sfnkKfRx5m79x5GJpO406dOb51G6XFRUx+/z0GxCXQtUc3bJ5YYhLjsHtieOG553nsvXdwN2yAbuiomsZ3jz/JVU/8K7rdwzNmUqNfP05t3oKAQLCslKTYWFydOvDehBto1q4tnW69JdoVdCa0CjV5U/ixspOrFiZtnqkKGygoInfZCqr16oHodrL36+nUHTOKkjIfsizhcto5Mn8RuavX0KhfL7b9soDSUJAaTZrQZNw13NGtBweB92+/A00SqdOgPnLbNtHte7fvwNG0CYEt25C9XvIDIeyhIKV5uciJieilZaTWr4+qhnDY7KiaiqrpiLVqosTEEAqEiIvzRMfs9QdBAOdFBOn/SWhh47NASEE3wOWw4XLYMHSdYDCExWLBYrEQDARQVBWbzRottQgCSOHzrml6NAPj9/uxWq3YwsdyMcdTZZtehSpUIYpgSOFUXgE2q4UYt4viLduIr5aGqip4atasVCuvNXgQm155jV/uf4DNwLSli82VaPgzzy5bwqHpMyk5mU2L669lUGHhGV4D50dUYKvia4JA/YwM+j30D/r+40HGdOlGPczsRlDVaHjd9TQePwFF10HTISERMTGJkCiQvXY94p5d1K9RE00JoesGskUmUORFUEIsX7yYf378HnHAwMbNqZWcgj0hllinm2JJxAkcPniQPUDdrVvZkTOXPGAv8PGEG3HXqk3Ozs1kjhpDbn4RNqsl6i5pkWQMq0Fm3doUHjiE2KAudoclyqsQKBcaEgBN002OCjoxTZox6/En6XfHbdiqpYOuo1ewwhbDq/tI1kIADs34kUZduvD6+In069uXn5csRtMNtixbRmajxpQCWkI8pfkFGEUlWKul4yso4OnPP2XdnLl0bdAADFjy/oeMuOVmiIzPMLDXrI3hcpDeqQNFu/eQ3r1L2C/CgIQEZs78kebduhHfskXYV0asRO6rONbIFY4oVUaue8SiG3QE0dResMe4qdGmBf4TJzi4YQNNLh1GXkkZew+dwGKROblkIekNGpHatg1Fteuzv3g6Qm4+ii/Exo2badigEdn79rBr/z70klIsefnk7tpLYlwcLquV/F27ic06hXHiBIEOnShGoEVKLNaT2ThbtTTt1g0DmySDKCJjTiKGYSCoGgEhZHbphDkxVotMmT+AzSKfxZP5b8LUADFM8zOLDIJAqS+Ay27FHlbo1MLHousGoiRFpb0jRGvdMMwsmigCApqqoUlaNKiIKnRytq7F3x1VgUUVqnAehBSVkKLiD4SIaVCfg3Pnoe7Ziy/WQ+cHJkc/JwjQ/LabsaRXp/mxI3xx971c9+br0ZQ+QJ3RlyP5A+z5fib1r736/Dv1+TDy8pn5+tuMfvHZ86qBtu3RnaNzf6Hm4IHkAtOAiVaLSYrU9Si/IQLDMFA1g+R2bQEooPxhaLXIePNLcNittK9bD2XKP2k7cDAPffcl7IZqwL19BpB7MgutTn1qpKcj5J2ifc+eHDpyiEvHXE2XRx9lQ1khnWplEjh5gsWP/pM6nbtSc+AgQopqPogxV+Ceju3Z+/5H2GpmYgsq2G3W6MNZx0BXdRRFo8znR5IkPG4HCZ06MPiStuyc9h2njx2j1aXDSWjWFDO8AMMwt2/aNpi8lOKCAmpPvJ6We3bjbFCPK5KSqHX5CESXk3oDB8D337Hi0EHu/fRj3h49hiFdu1B77JWIgkj9Nq2Yfe99ZDRtiic5GUc1M/1vYE7+yW1amPV03SCujtlmqAsGhgG3vPQCyz/6hGN79hLfsgWCIKLpWjh8KDepwjDQdA0VM7gQBCHcImyESbtSmHNSQT5aliEzEwfgW7LEFAfLLcQwDI5t3kjWiZMUnTzFgv17SfvxJ9IS4kl7eArS4YNYjmfRtk9vsm64DlmBgyGFuqkZGA0aonhcHCgsIWFYfU75g9h9Ck67DbXMjyFbsdsd6GGTOAhPumeodcqyqTarqFo0sDC1LGSCIRXJfmGuxvlQUWL7YiEKQlRXInr/qxrBsHdJJDiIkDsjxxAZXkWpeSFMoLXZbabBIOUBcEQISzhPmfHviqrAogpV+B2omkZBqZeYvn1JHTOaY99+y+qnnqXlTRNxppjiRrLNhiyJNB49mqZHjjDzrvvof9NEnE0bl9e/HQ5OFRRS9ObbtL/z9rP241u7gefuv58m1TJoMXjA+W2hgbojLmVSpy50WL6cesBOwBYM4HE5KSkrOyeD/kxEHp4hVSU5MRZJEvG4nFz1xWcIAkxtUo9v//UvlgOny0p54+hBQsDtCXEUAvnZWaxeuxpPKIijfRtWLVmE/+efuOqqq0lNT0ctKcYZKCGmUSOcdnt0v5Ik0aB7V7ZM/44mY65EFMXyhz3mCrHMV4bFYgEMvL4AtrBNduNrrqJpMMTOH34ktlnj8tV+JHsRXnEKCOScOGEGTiGVvH0HyTl6BH/Az5L5Czi0cQMAucAL143n2gcfwHfgMKXHTrBn8WKO7DuA5A/Qdtw1iA4Hmlah48TQEAQRWZQR7QKCwx4dQ0QeutuNEzk252cOfT8Th91GtQH9MSyWaMZD13VEUTSJrLq5XYsoIspyWEVUR9CNqEfFuabjhrVqEly3AanES0pxGbM/eIcrRl7JnCW/crwgj19ysrmnYyeK1q6ipt0Oxw6x/d2dWCx2Fi5ZwMAhl3Jg9UoyggF8spUaHgcFB/zEORyU7dvNydISLLEeio8fxFWjBrYIUdbg/OJP4YAjgshkrVWYkP9IcBE5X5qmnyPBd5HbEYiWlYKKik0QzIyhYUSlu3VNR5QrBz5mEGF+zgAsVgsBfyA8FiHamVSFs1EVWFShCheJQDBEYUkZdceORXvvfUpXrMLSrClyehqC24UrOYHDi5eQ0b8f7f/xD+a/8jKXPfEohCdVURDoefedFKxey/Q772L0m69HU6oHf/qZFT/P4aZ77qbOqJEXpYKcFh/H1c8+zRWaRvduPbhy0BBquVw0a9qUDevWoQN3ff3t725H1w2CoQrKiSHzkZ1wySWMvece2mZlE6sbTL91KgueeJKlG9azHWhVkM9+YP/mTTzbvScAClA3I52YXj0xsk9x6w03cu+tt9F87BhkUYpOFHFNm9BWljmxaBFS/35IgoDFKgNCmFin41BDrHvzLeq1aEFemZe0tHRSMtJZNednEhym9kMkXW1CQEJAEsz209i4ODb/MIvFW7cw5Zuvo4fn9wVY9PlnJAB3du5M/4cepOTAYT788nNq/LqAcR+8RztZomzXXrLXbaBaty7RDpZIxwtQiXgbUcg0DAMdAcEQqD54kBkk7d/Puo8/JS4tnXojhpXrUxhmMBQh50YySIIoIiKiaRoVaCPRFH1k8vMZEHtJOxINA/epUyhAy+uvpswiUKtubQ7s2kNqo0bEJ6eQXCeTOgP7opZ6abdsObVGXsrON9+lUacOZIy6DMMASRSorpsTf75TJr51a4T4eIT8PDbM/YV2LZuH92+OxzAPPnoP+wMhVFWDM/iKgiCgqAolXh2Xw3bRJZFIaUjXdGT5/A7EFwtZkjAAf1DB47SBYHrMWCxmuU6SJIxIRil6XwnRQLC8lKUjCOcP+qtQpWNRhSr8IfgCAVRNpdFtt5DauyeCxcLuGT8iIFCtTSsyq6WGU9oanW69jU0fTTUfSJEWUkMnvtMltBo4iLlTHkMSREq372DPqlXc8PGH1B15OQAfj58Y5SacD5Pefosv77wbURBoI8l8+8MMXvx1Ade9/ipvrFpBtbQ0HrxqzMWu6yrBABRV5VRREQMm3cauLZsIGgKtBg7EJQjc2qsPC3ds57YaNakOPLRsKffWrkefTp05dugw619/k30rVvHetK/Ys3YNRl6+OfFiTkSyJBPTqCFx1dI58uVXzH/1zSihUdPMGv2pBQsZ+Phj1L9iFB2vH0dG08aUqQrdHryPj2b+AEVFZ4zZiMprA2Q2bcrx1au5/603wvs1X5dkkVmGzt2t21Lq97Nq6mcsnvYVgy+/nLHPP8uqDz/iwPczObBuLZ++8ZZZhkAId6mIyFI5X8AsMWmmJommouqm4FmEiyAIAjENG9D25huJSUni8Nff4svKQsfsblF0zZyoKJ+kIkGGLEnIYWfNCDlV0yNZE4OSYAjv8lWcmDMPfyDIcz/MwJKQQM9Jt7Ni2TIauNw0atsKrbgQPRhCLCwk+7elWI+fwBYTQ5PLL8UjSeFjEqOibqIo4I5PQHY6kCQRFI3EYIjTq9aiGwZFR47wQv9BHFmxJsoJMX8bQTxuJ1arpdJ1cdisxHlciKJIidd/USWNyGT+nwoqotsFRKG8G0cUxGjrsmkaYlQIHCUkSQy7m0bOj4SqalFF1PON3aiwnb8jqgKLKlThD0DTdALBkPnQiItDrl0Li8VC2eat7J01h52Ll2ITMF0R7XaSuvXgx8n/4M3RV0QnKMMwaDxsMIJqsOjFV3n29jsZ+vwz7P7uex7s2p2HunTDn5fLhO49UXXtvKI7RUeOUi05BV3X6TJoIEJqavQ9QRB4eOb3nCJCPvvj8B44yNbFS3ln0t3sPbCf6a+8zMn8PO7/8itq16tLis3OiDde5el77gHg9cMHWLV6Fe/MnMmqBQtIq1UTe40a9Ll6LBNGXM7emTNQNQ0BwZwwBZFq3TvT6rqrWTfvZ9SQggG4bRaMTZtIcLtBFKN1bUtmdVLbtMYqW4gFrInJyKJEhLcgCSJCeBUKUL1/XwKhENmr1gDlap2nDh0G4MfNG/GkppGXk0uHy0bQ9obrsSYn0e3WW6g3aiStxl/HP778LHo+pPCYI0RRU+7aDCIMQw93sIjlLaIC0aASDOI7tKfGFSPZN/cXdn36eXlHSwUxscjfFScmURCxSBKyJIfvQfOeaDByBM6undCLC4mvVRNbamp0lT/4unGs37UTFJW9e/bgqFEduVFD6k68HmfYBM3WqCFFOacpXLiY0Nr1eFetIbB+I2Wr17H1h1momzaj7N6Dd8dOvp76Kf7c03j9AXbNX8iwK8YQ27B+JdWqyIR9riDAbLU2uywCIcU0WbvAxGx2Y/CfDSoMA0VVscgievgc6rqGIArouhbtAIFycbvIvkVRRJQkrGEysihdmC8SCQD/rqgKLKpQhT8AwzDwBYKV/u2olYkiijQddw0Dnnsah9uFRZZxOezE163FgCefoCTnNP/o3jPafqjpOsOff5r+143lOPBS954cO3iQJ5Yt4fFZP3DzTzN54skn+ey6iZUeUPd26sLax58En4+snbtIjYshuHEzS+fMOe+DTjf+PTVAuUYNhrzyMpdPeZQG9Rtycvs26owcTcBipXa9eoy64w4KDQFPr178OHs2H99wIzdffTV5QPs2bVn/yy8YJ46R2L4NNTMyWD/9B/Y8a7q2CoCgqaz46BPwuBk3diy//eMRtr74Cgdm/Uz2+jUk9uphflYQOPL118x7eAoEggjAA2+/y+JHHmX1m++y48OPkcp82GQLsiBGAwjDMPDUzKR6u7Z8MnoMhMwaz7wliwHYBKz+ZR6DHryf1G5do8TEcs0JA8lmRRTLFTAj5ziishjJwIimOURYIVMslygPt45GjtkAShUF/6lT7HloCpIgRrkZFaHpepjTUX7tzMnZXEETJsMClARDbPl4qvm9cHusp2EDhj3/DC9edTXuosJK27ZYy9slq3frQmyfnsjt2+LoeAnWtq1xdmhHsyH9kS9pj9yoIXKtTGLcHpK7diUUUomLT+KUomIIZtikGwalXj+iIJodGOeBw2Yl1u0kEFIo8fpRtcr3ZTmfwqz/SL8zef87iAT3phqoKaxm6AaSZHJbztxfJHMSCimEgiEz+AhnUi6EiiWzvyOqdCyqUIU/CIssEetxY7dZsFYg5IUUleJSH/5gILqQE8NdFzablYeHDKFpSjKX3X0XaR07IFnMB/zeL75i7ldfMeH553E2a4yum7V3BNjw7oesmjULZ0oy7rg49ECQzXv3cMOVV7Fx82aW7d3D/vC4+icm8vgPMzBkGcMf4LnRoygtKKIQuPciuBYXgizJEPCj26zhFsjKSIyLoXDVap5/8gl8wCGgDeAAHvngfe696WZaALuBdo2bMPyBe1n/0ae4a9Wk5Ogxutx4Azm79yCczGLTgkW4UpIZ9NCDSNUzmDvlMVLr1KXxwH68ffsk7v/yMwy7ndeuHEvvy0bQYvRIdn7xNZ7kRDKHDkY3dMSwONeJhYuY9eKrJMbHULdPHyQBpn7+OYlAHnDNmCtISU6h9pjRUSO0SDAgEjYEE0VCubnsnTefVtdfh67r4SxFmNz3B+e+HW++x7PTv6UDMOCGG0iuW4eUbl2jglgRRKTgxfDqWRTESm2OYAYq/s1bcNavh+5yoWimJL0kiLw36R5Gjh/P6XnzyOjXBzncuqrtP0xxrUyqu1z4Tp4k7lLT+r2ijkbRkt+I69IJw2JFz8ri5MJFuC67DEkUOD17Dnu2bqVaRgYtrh+H5PFQVFyG02HD/jt6FZHfSiAso+122KLHpOtGuFVVvGidiD8CVdMo9QZwO+2AEc0kASiKiq7pOF0OBEEIZzPKVUQjJFRd1/H7A6a6p81W6bydeZxAlUDW3w1VgUUV/q8QRYE4jxuPy4k/ECS/uDS62joTggAOm41fpvyTj3fsBGD5rB/ZsWgJaxf+yvj33orW6yvCIssc+3ku455/kd9m/4Q1JobFzzzDP+cvZFD16jz8zTQW/OtJfv51IceBVCBJklmrqXx/z93Ejx7F8527IsTF0XjgYBpdeum/fbyCIOCwm0JC/gpZG0GApLhYvn7kUfw7d7POX0qqIDC4TRv2bd5Ctfr1WV2QT/XcXFYCdYA4oHmf3giSRNvLL2Pu+x/hsVrQfD66jLyM7J27aX3n7Yi6zpbPv6Ll9eMQEFj08qv0vu4a9Ng4CrZtxzh9muTBA8CA00uXE/SW8a/nnqOhbKNN/XpM3b2TY8CtTZqxZNcO9gE6kAFkAQ2BiUOHU7dNS+Jbt0JITIh2AUQmwYj657Tb7+K69942J0bV9JKwhssTFcW5LupcIrD27Xfpetcd7Pz0cxoNGYSUkhKNUSIZjAghNOoXUlyMERsbDTgM4IcHHuLypx9Hly3RcQgILH3vfaolp2EX4ftXX+Xq++4ltWYtQnv2E0pNQUdHzy3EUycTv9cLLhf+QAi3JJK3dSu1O3eisLgEJSuLYCCEY8RwJFGkcO4c6gzoz4F5C2h03TVmUB1S8AVDxHku7A4cgabplPj8eJympoQeJo1KUmWC6n8SqqYRUlRs4W4jQRAxwhkhXTcoLi7BVcGE0GKRo5mniuNRFIVAIIjL5YwyWc8nWf53FciqCiyqUIX/AyKSv4qqnTeoqAibxcKSe+8mPvc0K/wBeo8aRb+7J0VXRqpmemgYupmOv7Z3P6yYE2H7Fi248r13AFCys+kxcjQPjRpF3uyfcTjtOJo2I6N1G7LyTtNxxGU8O+YKhvfuRe+nnkT3++nXpx9+zAX21H8zgxEpC6hq+bGaZEzRFNvC4MoxV3B7kybk7tpFEZBauzY7Dh/mOGaW4J/NW7Bw+zayMQOMWybeQNPx12BECXEChTt2su67GeihAMPuuA2hZk0O/Dib619+ieqY3Sc5QD1AA1q1bEm3ho146rtvKQA6Af0GD6PXXbeTvWgJmUMHoRrw1aS7aVGtGnfOm4sl/N1/dOpEswGDKDpyEMnppEHf3pCUVCnAkEUJ/7Fj7PhxDp3unURQCZmp/7AIWkhVo6WJi8XmN9+j4z13gqqy7YuvcNrt1LtqjHl9NRVREMPtnQYHf1nAvGlfk5aQQO9hQ0js2wdVUdj64UekJ6eQeNnws6+VILLuy2nM/WkWDz3+OL6DB4gfOhjvitXEdO8avnblnzei/wcb33qbdtdcjR4bi2/tek4dPQq+AJrNiu9kNtWbN8USG0dc4wYYgsCm72dSs0cPkurVOe/xGmfsJBBSCIZUPE57VK/lTElsRdUIKiqqpmG3WrBZzrZvv9gg5EJznWEYeMt8WKwyFovlnAFFBIqi4PcH8Hjc0e+ej8dUFVj8zVAVWFThz4LdZmXmffdSp0YNhj7+GILNhqZpiGGbdC3cJSAKIobfz4p336PHffcy7boJ5BYVsTo/j2u7dGbYiy9wfeeu7AX6An2vGIMoiKSOGAGAQxL54orRjH74IeoNHRLdf+fOXbkDgfZff/MfOR6LLGO1yIiigN1qYfDAQSRj9rJ3ARJbt+H9zZtwA4MtduYqAaoDIzt2YuCzT3Fk2jSycvLoMvlu9Mgq0gAjGOKfI0bw2OuvIykK/7zjTkZeP4HO148jcPAQL103npufeIL9W7aSm51Nw1YtaDJ6FN9PeYzLnn4CJLM7YVK37tSslsF9X3/J9Lvvw1MtnYa9elF4+AivvP0WH3/4Icc3bsbtsLF31WrSOnSkwejL0MLOq3q4LdRusRLMymL7j7Noe/utlSaqSMfL70HALK8AnFy2jNP7DtJy4ng0Q8d34AC+LduJbdIIyelk98KFYLFweM9+atXMpMX4a9EdDrSjR5FO52Fp3ozPb72dq95+A5zOs/YlCgJSSOP0st+I79MLb9ZJ9s79Gf/BI3S89RacdeucN42/4qVXScvIwBbjYcfyVcQmJZKTc4o+I0cSzDtNYv0GqLqZAVBVHZ/NSnLDehf2NiFSNYqUXHRKvH7sNityuDslQpiMlBbL/AFcdhuSJOH1B9F1s0vEFm4RFQTz/pP/DT5G1JMnfB0DgSCiKGK1WS+opKkoKn6/n5iYcrO+8322KrD4m6EqsKjCn4n4WA8Hv/yCNT/N4oDXy5urVkTfiyhn5ixeRuGJ4zQedRmiy8X4rt2ZunQJesDPzH8+yhVvvsZVnbtyZZNmZPbpg3oqm6M5ubS6rXzSs8oyL4weyfVjr6bd7bcBULp0KQMefoTPv/72D66xTUQJhIbpYBrhBlgtMh6nnQf79adWcjJFhkEoL49WmZlIx47zBgY3p6dz6NQpalWvzvrjx9kH+IAbPU5SOnSh/6P/NMWhwkqU3r37mXzjjUhAqwaNuHXqRwiCwBfX30CdZk1pf9ed+PxBHDYrVouMUFzMomdfoEXPHpSWeYmpW5tNX35J95FXkHP6FM+/8AJv/LoAbDZCIYV7+vSlR2ZNrnj2aV67+17u/uA9SErCEMpJlxigGRqSaMo+Zy9ezPefTqV5+/b0mHTHec/T4W+m44uLo+lA0/lWDpM6I51BAHOmPMaQJx8PX3Od4LFjBPMK2LBgAXVbtGTFggVc98ZrECaJqroZdAmFRWR9N53MwQNRa9SgvIGyHKIg4N+8HXusC6N27eixGFu2ciorm1o9uiGEguxbtYYGI4ZDhVV31sJFZPTrY5bnDh5BtEpImZnnPM6IT4nTbvtD95FhGAQVlWBIgTCvQQqfIz3cVeGy26JBg1magkAoREjRsFgkMCCgKLgdtnCJ44/tXwurp5oiXjqaqmGz26KljXMFDKqq4vOZgcXv4e8aWFR1hVShCn8CSst81LrqahJq18YF3Ne5Kzd2NtPToiiSv2kzqt9L43FjEVwujm/ZQhog2axIHg+O1FQWP/8ifuD5XTu4/c3XSR59BT0fnFxJFTGy2j6ybSffPvAPNE3nu+dfIAX+MOkwAlmSycktJK+wBAEBRVE5nVdETl4Rpd4gm4G83FwO5eXRq1Y91h07htakKdci8mN2NtmGQfNrr6dzq9ZUA37+fCpNuvfmUFY2M558npM5hRQUleH1BymMiee2m29mOxAoK4k+6Nv16UvnSXcQCikIQvkE8MigIbS79SaSBvan1sgRrPngI5wuN5ZO7ak+fChPvP8eD116GVr2KSwWC9cNGsKbx45yaN0GOnTsxKGly1n32hsYismhiFi5CwimToWmktSjG7dM/YTc7Tv47q77ol0kEW2D3155FQIBnn3nHZZ9ZrarSoIYDUwiE5pakM/RXbvInjMPsagIAXDUrEVi+7YM+OfD1Bs2hHGvv0pkra/pRlhVFIz4ODInXMfpnbs5PW8BVtkSbUeNIG/hYpzJiVAjE/HIUU7Mnkvo6HFKi4rJHD6EwMbN5B48QnKD+pWCCgCru3w1HvD70ULKOe+FyLFI/wYnQhDMDFes20mM006sy4nVIiOJAhZZwuO0m66kFSZ5URTC3SUOXHbTWCzG6cDrD6Fq59eWuNAYIl08kiiiKIrp+XJBHQqzo6QK50dVxqIKVfgTEVFTtFllNr3/PgfXr2fohBtYu3A+V771hqlaePIk40aP4atZP2JJTgbK68Xzn36aBq3acMfTT1MITH3nPYT4+Oj2LbJMaqybVW+/y/SffiQ1Lp6FRYV8Pu0bDEFAyM/HSEy86PGa4k0Cx06eJtbjwjCIMvmTEmIREPhq5GVYrE5+CXkZZHFyQPFx7Zsf8NOdN7Gswrbu7NCRWWvXMKhtW5rfdhdaUTG/vvEKE95+i8PHTgGQnhzP1H8+hKDrTBx5ORkjTC7Brs++pPG4sdEVekTF8q3LRnL7DzOiK87iTVt4+Y47eGLViigh8smBQ+jetx9FJ7PwecuItdlJbdqMVjeMRxQEvDt2c2L3buqNMrsg9HA5JCK1HT0PgsDbV1yNAngSEhg4ehTVu3XhpX4D2Qk88dgUMvv0Nj+PELbuLp+AXxk1hpuef4aig4c5vHUHHe+9k0i3giSWp/ZNC3VQw7LWoiBGPUVEQUQqKWXfT7Oo3rkzcp2a5v6yszmycg1F6zeQ2r496V07I8bHkb9sBSfXrSexRXMyenbHu30HsT26V7rGhmGQ+8tCkgb0M/dbUIgoS0ixsWfdD4qq4vUHiXE7z0tg/G/DMAzK/EFCqkq823nRui3lJm/lRM6yMq9JyqScSAqVMxeapuP3+3G7XWdv9Az8XTMWVZLeVajCn4hIut0XCNF84o30vn8ym995j06Dh3LypVeo8cBkXrt2HM9MnBANKsB80JWu30CLbj1J796FO09m8cKnU3nqtlt47JvvopOooqqUKSodJ91B/XHj0DSdaxQFRIHsRb/ywYcfkgzc9gfJnGZLrCkspOsGqqYQCqnYrBZ8GPwa8uICflV8aMCMpx8nEP5uM2AHcHjtGqZ8Po26NdOZ896nbJo1m0PeQoo3rMeZWZc7JlxLAvDGcy9Qo3tnTs6eB0Do1ClKDh9i+Vtv0bB2XYyUFJLatsYwoH77DuHauynI5IyNIdNqjUp/l2zfidvuoP7AvqQ1bQIGrHnmebavWknz4UMQUlOwxrrZu+w39m/djBEbz6UPTjZLECKmGQmg6xqGAbd98xUAb1w1llueeJJWwPj77yPp+5nRoAJMLRFNj4h4CZz4bTmjr7sWR+3auOrUYeOiRWYQo5str5quR1fTgmBmniTRNDPT0ctlsQ0DIzaGhuPHcXTOXFzHj1NWWkKoqJTEenWoe8WoSm2sqZ06oAPpHS6hdMMm1IQE8n+ZT0Kf3uRv3oZbFinMzaPwVDZFb76Dp0UzJEHE4nRgq5mJMzWl0n1gBpZh75M/yTcjkvkIKeofLu2Z2b0I5yMs2Q0IkdJShYV3uVhWOQ+kStL73KgKLKpQhb8IFFWlqKSMWp06Mu3ll/kxO5uWP/5IzZhY6k6cUOmzZbt2c2TrVprfMBHDMOg3YQK/zJpDdY+Hn559huadOlOrhykwVVzqxdDNySgYUkAUcR0/xocffsjl7duzaP16smfPJn3YsIsYpbm6EwSBoKJgschYJQFfIMjR7dtZ/800fg1/8ua+g1ixbTOD+/ZDzTrJL6eyAMgHWgKFwOmTp9n+5ZccO3mC5t27cGDeHEJeHzdPuJbL06rjtkpU69oRXdeJadKQlU88Te0G9en4r0fN0RgGp39ZwMGvvyWtTRvccbFhUp6BoIvk799Pjzvv5Ois2dS+dDgxzZoyZOTlHFu2gvSmTdENnQ7334vnm++4atRobu7RE0d8HN7cPK7616OIKWYwZ5EkFA2ISIaHFT51TK+P+777lrTb7mDkM08wYPjl1AHGFxdDTEyUIBhUFGRRpGzrDpw2G/HDhkYnLr/PjxEMocsyYJierQaIhqlAaYQdT2VJiopzyWGhrAhqDh0MQBLl9uwRRCfA+HicooSQmIBUuxZlW7chWSwsuvcB2o24FHuHdqTVzCRVaIuxZSt69WpIHg+GJCHExZ11N1hkCassUer1E+tx/WlZC1kSkSTRlIO/QMYiQtiMqp5S7vKrGwYWiyXaiXMmMbPi+fw9gay/O6pKIVWowl8MHpcDt9OBdOgQ9qZNzikWtOXb72l16dCowZlhGPz00qs8P3MGV3W4hB1r1xED3PTFVyDL5sNTFMyWUFlCWTCfnYcOMfixRyj6fgZfz5rLkGefvajx2azWqPeJKIrRtkzRMJAspu+C9ec5zFm3jt+2buHK9h1YtGkDrdu2Y8a6tVzTdwChoB/Hrt28lZ/LY+Mn0Pq6a/DtP8C9N91EIuAHXlm62PSuwFy1i6IIgQC7v/oGrFYaXjYcnGbq2zAMTi1dxtuPP849r72Mu5m50t7w2pvEpqXiSEigxgCTRHlqxQpWfvgx9fr2o/k1V5qExuJilj7zAmUOB8P/NYX5TzzNwMceISwuWS6GhcFPd95N/3vvwlarVljESidiVnVs3gICp7NpMmFCeceBYdrBG+Eyh0WSEQTzLSmckQgVFbFvxg80Hn+dSV40yiWhKwo5RaTQTe6MUIlfcrEoXLKE+F69zH+oKsUHDuKuXQttw2bTUK92zehnlZWrsHTpHP33mfvSQgpKIIAvpCDbzbZRXVGx223myl78z6tnngu6YVBS5sflsGGRz585iQQM5xpTIKzNYgl7nZxp+lZRar24uBSPx43lAkqj8PcthVQxUKpQhb8YSr1+cvKLyE1MPq+vQqsxo6JBRQSXTr6HL197le/WruP2Sy+lBrDu7bcAc1qKKGaqqsahYIBlixZxc/de3PfGWzgr+Iz8HoKhEIFQkGAohD8QwB8MEggG8YVClHp9+AIBMOCqSXcQK4u0v+oKFE1j27q15ANLfp3PgW3bOFpQQCvgiamfsO7Jp7jmppvYB6wGXv3oA+xWKxZJNpUYI6tQu52GE66j3pCB7Jj6OT8/9AiKtwwdg9Qe3ek3bBh5u/ehHT2OoCjkFhXR6Oorqd6/r8n61zXSunah/YjL+Pz99zj52wpzwo+NpXrL5gTLSggcOECNWjUgEDCls41ynxFREFFVlaxN20wzMlEKt4+aHI+gprF/2040ny/axqhT0YPCvBqRoCFS5xc8HhRDiPIDZFHCIslhEazyjo+Kgln/7nwtiOVqsYYkEdOwAaLVitzpEgpyTxPavis8VgFry5YIW7adM7g1DANfSKHA60c1wFdaRtDnRzMMSkrLCJZ6MdQ/Jhz2b8M40+n2HB8xDPzBEL6g6eRbrqgZKW+ZXCEpTOSMfObM7IUoilitlkocjCpURlXGogpV+AtDEkWcdhvJiXEXZTdtGAbzn32ex2fP5tvJ97Nl+3Yajb/+vNvWdT28Qv7PuTEKwLiw0FNLwPL/sXfW4VEdaBf/XRmPKwkkQYK7uzultEiBGvVCXanL1pZ6S92ol9IWKC3u7u4QnAAhQDwZu/b9cWeGBK/sftt2zj55dpi5fqfznvvKOUC81coCv59h8fF4AZeikZqcyJg9eyqsmwTUALIxVTFfWLGsQkAr7yp5av5CZKuV7AMHqHf9NYgIbPnqOxrdeB0Fs+ey/8ABGvXvhz093cws6DqKriGKArJoPvmrhYUQFYmIgFFURJfLr6AO8K877uToyZPoNhux8bHUHjwIAi6Xa8a8ir1SJRrfNCLUD+FX1ZCvxJ3de9GuZiYjPvmQUP2e09kHq2wqP2paMI9hjlGu/W48vqM5dHvi0ZCZmSkvfjo4G5gTJrL0G825juZA5RQ4lceu2XOpfc0ws1+j3D2XAvbtK7/4kpZ9+2CpVAmAorkLcCQkYGvW+PRxBO9BQTEFxaUARDkdxMdEIltk3F4/fr+fCJsV+SIy338GNN3UxIgKOrKeA4ZhUFBShtUi47LbzvpelZa5cTkd5ih1OZzOHJ0mGmVlbhwOR2gCK6xjURFhyhVGGP/D0HSdMo+X0ku0mxYEgZ6PjmZ0v8s4fuokM2bPuuC2yz8F/1kwgKBc0+UtWqIBit+PAtRp15aq9Rqwt7iQMXv2EJwzCLY5Tl62BEtUFN8uWkCbLl1Y/+6HZ/UKBC2s1egYinNyOHH8OCKmoVRifJypO6HrrFmzBlt6GmA6kwbDuLOtHJAAAQAASURBVK6bRl2ariNGRYUKDWJMDE926co17dqRMnQwLe67i7Z33E71bl05NXceW8Z9wbJPPmXy1F+p1KChaVoVcFY9NG8eInBq5SruGDoMn6LiPnwkkHYnZLkuhZoxTd2K4AUzDIOW115NtebNmHj/w+Tt2BGS7Q6SiKD/iW4Eycil3bMjU6ZyfNly8ucvwn/sOHWuHR68mqFsjBk8ze1l1K6DHnTwBSyJiegHD4GqVthumduLv9wYaonHiz+QoXDarciyRElxCcZ53Hn/TCiKZpIx8cJxPNinUh7BrFFQ3OvM6xpIMp21TvlMUhgVEc5YhBHGXwAWWSYhNpoIp/2iJk8AR9au57X77mMtMO6V15DPI270Z0IUBJZ98SUdbr4RR14eQ+68g9sRWIrBiAED+PzXX6kNTAPaYMp5X//QQ0z6+htWnzzBUaAhEAl0admSrLVr2Q58tnQx39w+isFPPEZEZmaFH/6yw4fJnjiZatdejSUxkZmjH6NSnVpUqlqNlO5dAzbeZqZA03V8qhIKCBZRKqdHYCAGnrPWvfMBUdFRZFzWG3tixSkIURJY8frbtHngPrNPAjPw3NChE3WB6ORkTuYXYIuMoEgSeOrHCYgBozJJkE6bWRlBX5jTep2hMVOfjxnPvUiZqiBpGsOeehIjIQE47UlyqVmLsp27cSUnQdzpEeSQjoauUXLsGJGpqYDZv4FhsH/BIqrWqY2lShXzuA5lg8MOBw5Bm5aA+YSfcyKfsnKeMQAxkS4S46IRBAGvz4/X5yf6Ev1D/gg8Pj+qqhPpsl9wOZ9foczrJybCESo7Be3UFUXFbrOGiGt5nBknS0pKcZbLbpxv+X+qCVl4KiSMMP4CUFSV/KJi7FZLyFcBzvZWCCIiPo61wFN16vDuo6N54A+6m14SBAHR7WbX9Bkc2bUTgGwMGjRoSFHOUVoC44FooFJ0FEeLikmtV5d7P/mQGWNeYdWaNQjAbddej5RehSlr1/LgA/dzY8fOlAGHrr+B6594nGrlpimc6enUeuBe8hYsZMf6jWw6dIjHX3/F/FwATdMqNOuZPQtCOenp04FdR0dEpMWdtzPnnvtYPW4c1S+/nA6PPBQ6RV03WLNwAVt37aJqZg16jn4Iw68wsEsXrnzpeVOpMpABMgINlnqg/0IPSJUTeH2aUARIhSSZ46hOF/1ffgkA5dgxpox5hfRGjWl6w3Wh7Er50tWZUwuCIKBpZqbLVfts8avgdchesIiFn35G404daXTzjWh2OwV797Nvw0aqdWiPIAgUrVyDMzYaS4QTNSWJgkXLSOzSAVXTUc7RP+Hx+UPlNb9fqaDH8Z+CbpieIhdq2gzCapHx+VX8qobNcrrHQg/aoetGhctVwUnWOD2EYxjBZs7Qp6HlwiOo4YxFGGH8ZSAI4HI4iIpwYrdayZryC/WGDAp9XsG7QtPo2LEzacDw4dfQ4A+4mm7++EMWLVrEfd99f84gdS6IgsD1w4fyTlQEWbHxvHfoEPWB7cCoatXYUVBInCQx9Oab2LJgIcfz8zFyjvGT14sC9BZFhj/+OGphIVtXrGTNxg1c8/DDpKalcSori1pXDwuJRQV/4Be99RZyRCQdR94WvCBoQYtzTj+RB+3HNV07K40d9GjR8gvY8M14Cg4dRC0txZeRwbasPbSqVImGXTuTfllfvrv3AdasW0taRBRtOnek7d13IURGYqCj6nq5kUYjUHIIeKCc4SpiCfR7BKdbQsEuIMglIPB2zz70GD6UhrfeHCiFmMdpKZe10HU9ENgNSt0e/IpCalI8Fvns58cg8Vk79l2+//FHKtlduBLjEB1Obv7kQ2RJwiLLbHzvY+r17IZx+DCSzc6y6TPoOuYF3H6FYyfyQg3BofsuCiTFRKGqKkgS0RGu/3iTo8+vUub1EhPhumgpBALaLh4f0S5H6JqHJkIslpBte9Anpnwpx8Asq5WWlGK1WrFYLSZZLUc64HQvxj81YxEmFmGE8ReDIAgkxEYTE+kKPGXp5hN4IC2raxo+nx+/14d3/SaKa9W84PYssoxyRv08CFEUuX7YVQA8XbMOmc8/d97tSKLIkWee4endO+kZHceMovxzLtcYUyCrAWaz5j333U/23r0kNqxPct++PNO5CweBZ+68k1pXDeaurt15+4vPEGrUAGDPxJ9xyhJVBl6BREC/QNdZ8uS/6PjYQ0jR0SH/B1XXzJKDABZRLjc5cFoDM/he6Ik/8D80ldlPPsu0FcsYfsUgatWvQ57HQ70hg0LrCoKAcfQYut1G0dadrFy/loSYGFoMHQIuZ6iHBYBALZ/A/oPTIbIoYpHLTWoEFDWDnhmCIKB5vTzQvSevzZyGNTLS7A8RRUSE0HIIAl6fj7zCErw+P6IoUjkpHnugeTIYKMvDCOhlfDBoCCnp6WS0bEmza682ty0IuHfuYtfOXTQbdCXeVWsQM6tTvGIVrm5dOZpfhK4bSJKIRTZdRx12K5IoYZElnHbrOadJ/mx4/QrFZR5io1zIFyhjCIJAYXEpiqphs1mRJbOcVOb2omo6RSVlJMfH4HTYzOsrCKiajigKocZcWZKQZYmiomIcDgcWi6UCoShPDOGf27wZJhZhhPEXRFSEi1innVNFxSiqhixJuGQJu9NBSUkpxX4FiyDgyMqiMPPCxCIUmM4BAZh74w1s9nmpCvR76hkc9eub6XtNx37yBJMmTcTqV/h6zaoK6wYVNh/IrMkXe/dQWO6zqkBti41IXafvqJF8P24cL3z7DYu//oqTe/fxxo4dvHz5FaycO4ccr4cenTvT4/lnA5LicGT2PA5v306rUbey/fuJuJx2JIuVRFck9kb1sKelYRig6GooSAQNrgzDCIwTCoESxenJC1OXA9Poy2zOoEeHTsRilnCevOVWql8zDMHhqGC1EgzaoiDgyc4mZ8VqiHBR7bI+oad6QQgYXQVVNQVTiRNBYN+06VS7rC8Q1LYQT2c8Atsec1k/HvjgQxxVq2IEGj81XUeWZBRFpdTtIdLlQNV0ck7kmc2ssdFER56WnlY09SxyEcTCMa9RuWYmDYcPrfgdEATQdfJmzSa+X1/w+8mZMAm5fVs8DifxMVE47LZQgC0sKsHpdGCz/jZTsN8Lc4zUJBcRDht2myVg9kagmdQkT1aLzNHcPNweH4kJMRw5dhK3xxsYMZXw+PwIGMTGRFFYVEp0pIsyjwdrwNzMr6g47VZqV0/D4/YgyRL2CxivCYLwjyUW4R6LMML4C6LU7UEpc+MJBAm/ZqbBBbeHYBJeE4UK3hTnw/lIBZgxtv/478kZPJArH3oYa+3afP3cc9RPz6Bd6zYI6ZUZcM+9GAIMsFpxOezkTpnCyQP7GT1rNtFATHwCGQFiURWoUymFWcdzaK74EGPjGPv+e3Rp0ZJvHn+SLXt24xIlbMCiqb9Qq3kzWlWrxpyJk6g1Zx7pPbpjCFC5ZzcSWjZj8ugnSK9WlXo33mtOUIgS2z//ivq33BCSaA6SCVXTQNPM0VLJMPUnBIGSw9lEZaSF+hZ0PeDYCgiGwJSXXuSZJ5/igRdepHKzJmRN+RXR0FFEmXrDzWyOHnhSNQB7WhrVh6ex7+dfAciZORvVZieje5fQSKdhBGzNJQm8XkpP5SOJ0mmCYhgI4uknX1EQeGLaNH54cDRXj30LQ5DM0VvMEovVIqPpOjkn85El2XxyFgUsFjnUYKrp+nlJhfv4cU7u3UNa7VrmfQ+QLVGU0HNPULxqNXHdTVEtrayMlCYNMMpK8Pv9WFNOS80rXh+qpl3SaPSfDTlQBil2exEwS19ev4KumfoUEU67Sfy8PsrKPLg9PjxeP4nx0UiShCgKJMZFc/xUAVaLjN1mDZAWH35FJSYyAo/Xh27o2B12PB4vmqYFlGjNYwje2396m0V43DSMMP6C0HU9RCqCMAQBvTyR+JNycj5FIbpuPW5+43Wuu/5abnjicZrcdCPuenUoi4hEDfQ4RDgdOE/lYXG6eGPWbJ5v3Zr2wIZt2ygObOsgMOt4Dr+MeYVJQCW/yq0jRtCxX1+a9u7JayuXs0LXqArYgfbdu9P1wQcYs3wpB1evRT90GHwKul9FtFgZ9Nbr+GQBNaAjARBfuxa7J/4cULrEVAYt10xJgAAEswZKznHy5i9CFk9PbZTvj4jo1ImTwNaJkyg5dpTVmzZxvKAQd2kJu77+FuV4TsALREPVNTOIHzzMT99+x6EfJkJkJK5IF4d+msSO8RNQTpzEIkmng6+q4vV6EAMkSAqMTZZ39RQAUZKJio4x38PMrsjiaWOzSJcTTdNxe72IoojL4aCopIziUncoSyOdw5XTMAyK9xwg/+gxag6+EgiOwxpmhsNmwRofixBp2oQbO3dDg/rQsAGCKJI3fTZKmRvN70f1eBEFEY/fb+p0/Acz4sF7quk6Xr+fyAgnLoeNmAgnEQ7Tbj020klslAtrQCEzwuXA6bAjigKpyfHUyEghOT6GSJeD1OR4oiNdpKcmkVE5mdTkOCIjHKSlJBLpciLLEtXSKiFLEpIkYrdb8Xp9Ab8cvUJm6p+OcMYijDD+ptANgwFPP4kD+Cgg7R2chhAEAePwIU7mnmDP2jWsW7SQ3UBz4MYJP57RDW/Q47rrmPTkE3QDVIsVMFP2kS4nGydPJiMqkt3HjvLVjxM5gEEBoPn8FIgylrISDpxxbB+88RoA75UVM87jI6VZE2wnTvLitSPoDNz48MN8+/rrDHv1Na6cPpOT2dmUFhcRV7UqDS/rgxAXC1YZw+dn7ax52FNSaTp4EKquUal9W3K++iaUfTAI9FAExj6DEt2ariGIMnGtW3Jo+gyyv/yGpjdeHxKmChERIMXh4sfNG6mfXwC5uXR4+aWApLbA0o8/Iyo2hnqDrzT7KAyDXatW8dinH0JcvFlu0XXiW7UEVWXjF1/TfOQtIeIw5+136HTF5ea/A4+7Z/YJBHsket56Mzu/G0+tq00tCtPW3TSDs1lkFr3zNi0GDiapViZJ8TF4vL5Q/4MQ0MQQDVMyXPP6EKwWyvYfZPGsmXQeNozdn35OvdtvNe9vgIQUHzyEKzrO/C4oCvmFRcRrGrqiIqRVxpaVhbB2HVLrllhdTiwY+HUocXtx2CxYLfJv7rM4c+Il+F6wh0E3jACJ8oMAVosFa8BiXQBEWSaotm2IBl6/gsenoGoalZJicdpspmy6pqEoKnExUSFC4HTYQpMtlZMT0HUdl9OOzWqpkImRZRnDMKXAg02fhhGY8fmHk4swsQgjjL8pBFEgCigGbrj+Wm5PTuaT3NwKy9gh5DoKsADYMHwo73z/QyjhIQoC6YrK919+jd92uqZst1qRJBHVYqVS3dqUHcvlgfvu50BWFs/MnM5zmzZW2JcM9AXmAXXqNaSBTaZ6QiL3fD8e308/UB+BD5YvYcsbb+HxeHhkxTLuOnCIZR9/TO9PP+KJHr1QyspY8PFnCFYLXe8ahWGz8+CUSTzTqw9NL78cXRBQRYlG1wzHUFQz6Bqm86YkCGiGjoQUsj+XRZN4pPfrizRjNsb+A2gZaaYduSSaniiGwb9nTCXn+ZdIa9eOg0uWcXD6TKr3vwyADrffQv7OXaz4+DNS09Op3q8P29ZtJLZaNVJaxYZGEgUAWcbjP639YBgGqBq2hg3NZS4SkaQqlRElC+s//JgWd4w0J0wCJRFRFIj1K1jyTiJJtTEMcDnsFbYrCAJHZ82lIPsIO9esplnHdsxatZrbxr6FcvIkh2fNYfk775PZqAGp3bpyYMpUju7aTatrh7Hhq+9o3KEdgS0iyjKiRSaicipCk0awfiNCSiWEpCScdhlV0yjz+lE07Syly3MhWK4y3XJNnQ2bxYIcMBfzKSqqpuO0WTEw8PpVbBYZu/U0cTofXA4bfkXF5wdNMyj1eHHarIHmU6nCNInH62Pn3sPUzUwnv6iUopIyMjNS8fkUsJmS+MGm1dxTBUS6HBiKiqAJOOwiiqIgCKbtusVy/h6MvzPCxCKMMP6mcNisWMv9+0xSARVJRRCFwMxHRtPn1dcQBIHogwcpSUqqQCoAyrxeyrxe6vbojhQXQ7OGDdF27WbfogXMfOUVXnr0UXKAfYHlVWAqYAXGLllIayDz2muZMX8unbr3RMWgX/uOJAJ3XT6ATI+HopJipi9ZwnPtOjDty8+5+8abSU9L46V33ubXF8fgjI2j+NRJ9gC5q1aT3L4dmqEhGRK6qiLKMoKimnoSPj+izYrmcyPb7RiK3ywd6TrIMql9e7Hth59IzskhsV2bgEdLgIBYZGbu3YvjuhEkN2nMj2++Tde9e2l1/70gQFTtmnSoXRvl2DF2/TiR9MqVefuBh+g+4HJik5KIjorCp2rs3buHQ7uzSP9hIraoKCp1bE9ZWekl31PDMKh+1UCWvjGWPT//Qu3BA9Exx1h1XSe5cmVqX2a6nJYvp5RHet9epBkGSnER+9euJzU+0fQFSUqi5ojrqCvJTLn/IaqtXEN0wwbU6tyeTRN+IMLuRKxSmciSEghkB7a99gYNevQwx5BbNkdbvxEdsFepjCxJRDntlHp8FJV6iHTZL+g86ldVyjy+kPaFVZbxqyrFpX4UVcNpt+Ky27HIEoIAtnITGYZ5cc55voIgIAmmtbrdakHXdYrLvAG9Dw1b4HsdzJIoqkZuXiF2m438ohJEQSD3VAHZx06SGB/DyfxCLLKMzWaloLCYSolxlJS50TSd+NgoCgKNn06HjWpprrOO55+A8FRIGGH8DSEAie5S+t5yC9cBvwAl5T53YAZ65VwrB/DI5VfQtkdPdE2jNKXSOZcRRZHYqIjQdIXVYqHk4AHyt2yjRq8eqHYHnkOH+Pett+IFtgA3Z9Zk/N499AYy0zPIFUVqVk4lqXYddm3axK4N61ExHU4vHzaM9nfeQafOXagMHAUmvv4aU7+bwM2jbsfSsD7oOmM7dCIbeHTGdCyyhGyRkELiVKenPwhMOEiiZLqxShKGpqOpKlhkZIsFNWsvhbt3Y69fF1tGOoZhYJMtKIrKe1170XrgAOJr1WTn0qUMvPVmhDp1UDTVnCQJlFt82dlMfP4lrnt3rKlaaUa+Cs19oq4z89En6TxsCM5WLS/piV4P2KhLosinN93CbV+MC32uGwZHfv6F9EFXXnBbWlERP9x2J8uzD3LTiOtpdNstgR2ArirIkozq8WJx2DEMg6O/TiW1Q3u8+w6we8NGasTFElO/PnkFhWwYP56mzZoT26kDPk1DKy7BlpqKtXoGELAj1w3cPh+qphPldFRodCx/7CVlHmxWC7YzHEN9fsXsJ5Gkc65b3gr9UkouiqqRX1yKzSIjGgYuV0UVzlK3l6wDRygt8xAV4ULTdSyyRHGpG4fDhqKoZGakcuhILqIoEhMdwf7DOURFOJFlGUkUqZKSwNHjp2jRqO4/sigSbt4MI4z/UdhtNmwWK1aLxbQqFwRsVis2ixWLLCOKYuhzURSxW60BSWKBjW+8zm23mAHjW+D7d8YCMAKZaDD9Oy6y/1en/oLV68VbpTKOwLGY+7CZx2G1YLNa0HVTCyMqwoksSeRs2cqyb8Yz5aUxFB04iDUuFgN4+uVXaCrLfL93D15MsjP28CEsh7MpycsjpUkjkpKSGDrydhrWroMPOLJyFcve/4jrnS6qAEuWLuaHb77lljEv8Mprr/P56EdBFLl3+VIy69UzU9qhHgojOGkY+hMEsFisSJKEYJExRBHRakG0yEgGoGlYameScHk/cpev4NDcBQiAGqi5WyOcpCTEU6v/ZUiyBb1mLXRDp2z3HvB4MDBQt2zh57fGcsNbryM6naedSIPp+mCokWVaXX4ZJUUlnFy/gV0/TGT751/y/X0P8sODD1N28iQA+2fPDd0TURA5tMoc6+11/Qg+u+Z6yo4eCzmeZueeuKjk+9IXxyCJBoMHXE6z228zz9vnR9Q0RB1EScIWGYFosSBZrcQ2akj+lm1EdmhHw8svA5cLmjQivmsnen76ERGNGyI3qIercUMczZtiVEoMKJ6a+xNFAZfdtDMvKCmj1ONDK+fYaxgGHq/PvL6yFJrmCZ6HzWoJZSnUgJLqmbhUUgEgiQIOmxVFNZsuy8rclJW5Q74nFlkmJSmeFg1rUataZVIS44iLiSQ+Nork+FgqJycQ4bSTkhRHpcRYJFEkMyOV6EgXNaum4rBbKS5xExsdeUnH83dEuBQSRhj/g7BaZE7lF3IyrwhJkqicHI/LZaeo2M3BI8dpVLc6oiiSffQEkiRRPb0SR3PzeOfWG0gFFga2k4bpFPrkvfdhAb7m3EJY58OBuARS7Xb2HjyKX1EBgxrplTl2Io+0lERycvMpLC5BEATq16qKrutsnTaHyYWnqL/qFLs3bMJpdbAWuPWxRxnz2dekpSSQu2Y1Y597jq3ANF2lya5dnHz9TYzD2Xg6daR2i2ZExsbx7qoVFB4+xI3A6sAxVY+JZeaY13jk80/58fkXeW3UHYz+6EPqZ9Zg+0cfU3/kSDTNnI+xWswnSAQQAuxCFAWWjH2P2h07kdy0kSlFLltQFR+CoiOoGpLVQuY1V/Pr0//CdyqPBtddDQi0u+F65n//A7cMH4bb5yNn+Uo2r16FIUDe8VzSk5I5eOok9WrXwYiKCgRD/XSgFExDsiAiq6Yz/+33iatTiza33AiyTP0zygUb582neu+eCILA3OdepHY7U267SpeOJC9ZhNNqCQVVv9tzzvtYPohXSkygwZCrcFVLRw8EU9luetDI5yhVuDIz2TPxZyJcEaBrxF7Wt8LogyJJOAKvJasFIxD8DUMn6MUiCAJOmxWrLKFqOiVuDy67DVEU8Ad6JyID2YxzpZKDzas+RcUwwBkg0MHPfgtEUcRps+LzeBCtVhwOG7pu4PP78Xq96JpOjMtujuoaOolxUQiCQFJctDkxJJi6LwmxkYiiFLqufr8fu81CrWqV//Gy3mFiEUYY/4MQBJFT+cVEupxkVE4OqEtqnCoowm6zkpdfTEpyHF6/QmFxAWvffI3v9+0GYDdmH4MfCGpfbgZ+z0+doqgcyTmJLEtUT09BUTWssozX60PTNAqKSoiNiiAtNRGX086SWQuxR9gZ3bU7Ly6cTxO/h0qpaVCaTxHw3ag7GXDHbdTq1Z2jwHCbkwk+N2VA1copTD18iH5Vq5HtLaVaq+b8+uoYFt57P88GGkFHdezMh7Nn4j14iFMLFjD02adY9e0ECjdtot0jo3n9uhHUC8h2W6wScFrLQ4RQNkPRNFKaNwmVSARRQJBkRIuI4fdjaBoYBle+/BKbvv4W7/793DriRiIwRb/Enn04KMLy1at4Z/FCkGW8p06xa+kybhz9IEUrVpC9eh0pNauhR0ebCpnlEsRBWXFbtWrU6dSO6oNNafb89RvYungJHYZdhVS5MgAxyaYRmjfnOCWF+VTp0RlN1zg8fSa624OQmBgKZG0GXcHub7+n9nVXA6cnKbxHjrHtl2lExEaiVK1OXPPG5giq5cIiVsFxztr334tugNVqwbDIFb5L/jJ36LXqNyXFJZv1bLl0QcAiy8iSOZ5c4vaaJSFRJNJpP00Uzlin/GuHzUppmZeCkjIskkSE0w7CaWfSiyGooFlW5kbTDVQDVM2gzOPFZrXgdNhR/Ap+RUH3+czpEEkKTQoFMyN6wA9GFE9nUDRNx+dTkM8hof5PQ/gKhBHG/yAMQ6duZjpHck6xZfd+qlauhCSJ+HwKlSvFc/BILmmpSciSRGZGKm/s200dTInsQiAK2AC4gDJMFcwcIC+w/eD7Fz2Oo0dxJyYTHxuJoipmejsQMkRRpE5mOseOn2Tjjr3UyEhFTEii8+23c3DxItoH9rlP8zEoOpodRUU0qVuTT999iw4zpvHq6EfZtWwJrFzJCmDFylW0AUZ+/SWv3XgztYcPQwBimjWDTRuZ8uSTLJk+nTd696Vr9+4UISDMmUf94ddwcNceHLv30LJJEzyHsrFUTkU3dGRRQrQKoekOWTJ9OZKiY8xRTUAINP1JgQBi2OwIGGheH4au0+S6a7ipQycA+nfuzLbFi1mjq1TPqE6Ez4tosZjCWPHxNB14JWs/+oT9mzaTUTOToxs3cmTbNuSoSFoOHERis0YAWERCzpjZ23awY9cexOISmnfrQud772biQ6OxWe20bt+apPSq5nEWFNL9+usDNuswZ+qvjPzk4woB1Vm9Gp55802pd1VD1zWyps9A9io0u+0mRIuM8BuNwSRRwm4X8Xr9lJR5iIlyVTAXU0pPd+9IVitop83JzjU2ahIEs5Ey2HdyoeUrHouI02GluMyLT1FQSk3BM7vNgiMgXX4+BElSSUkZXr+C3W7Dr+r4SkrRdQOnw4YkSchOGatuQ9e0kMBa4KBCmiim5bwpo27owWyQbkrp+/1YrRc+lr87wsQijDD+ByEKIifzi0iIi8bnVzhVUGQ+YUoixaVudN2goMj8QY+OigDMTMUezP6JKMAd+HMCdRApQw8Ri0shFQD7582l2d13c+hYLlUrJ+PzK8REmbVjVdMoKikjKSGW4lIPpWVeoiOd7DfgwKkCWlevTUmUi6yTpzhUVERtwcrerZuJB07s20PRunU0atUK+8qVXAYgykzSzVLNO19+zpA9u9m9axe78vJoBHz/0kv0bNOatD59OFDm5p2lS+goCMzbvZvMtHSyN23kmelTmfjMcyRUrUaDG67HkAwsVun00ybm+GlMZGQovS4IomlOJop49uyhRNWRKqXgtFmR8ws4Mnc+DVJSsUe4SKlXj2d9KnNXLad1nXpEOh3Me+Z54hvW53DWHho1aMC+rD0s2boNYesWamfWolndOlSqUxO1tPj0hQ1OM5SUUL1xI9KuHIDm8yEFJhSa9uqD5/Ah1i5agmGxUMVu4cDW7biqZhDdrCkiEGG1h4KXYTY0oPkVqnbswKznXqLng/dyfMt2EpOTSWzf7ncFOpNwmeu5nHZkWUJRNSSrGWwPTPmVhBqnJeM1nx/dCGQsdB1dEEPrn7ndoOn82d4eFxaZkiWJ2CgXiqLi8SvYLDJFJW6zETfQu+FXTfntoLW8YRgoiorP50OWJaKsViRZQvf4iHBFYEBIuhvM2yOVWzfkehrQyUAQ0FXjdHZFAFGUcDgceDweQMD6X5I0/19EeCokjDD+B2G1WPB6/eQXlSCJIpUS4yguLSMmKiIw76/j9fkRAKfTzmuDB7IeqAmcBFpg6kUA1OD0yCeAhEk+zgcZQp0YD3XuQfuH7qOgqJSCohJsViuVk+PJKywhJsplKjuWuJEkkdTkeAzgxKlCvD4f0ZERbP1yHJnNWqJUz2TsXbcy5pXXOThjGv68U8zbto18zB4QAxhVJY03jmTz7pCr+HrmDKpGRlC3eiYdrh7G4nFf8NKmjdQEHrjpZhrcdAPXdOrMEWDFimVsnvIr0REuTu3YQfN77uaLq68j60QuoydPMmvoARVOq2xBQKBw4xYSY2Mgs3qFZsA5L75E+tUjOLJqDVruMQxVpf5VV2Gzykx5620c8fF0TE9j09YdVOvSBe+xHIqyD7Dp0BFuf/sNCkvKMHSdya+8TJyqYnG5KCsuIsLpRFE1qtSrT4ebR2BzmPLShXPnE92pA3qFkoRZyln+2lt0eORBsqfNQiopwpaexvSvv2HExx+yb/oM7H4/lfr3RwAUjwfJZsPQNCSbjUPLlzPpo09Iq1+foU88+qc9PZe/VmW7syjM2kOVAf1D72mKGhAeO/2UHwzuZ24ntK1g5qjc5+c63mAZ40wrc8MwcPv8qKppNudXtIBSqYjLZkXAXE/TdBx2G1abNTCF4g2ZpZ25zwr7CPxbPOOY1PLGfYHMhhgok3i9PnNUOzrmH5m2CBOLMML4H4VpjmSaYgW9KDRNM58IA2l7MH/0dv/yM89/911o3eqY46UngUqB1+fLUpxJNGxAUMJpZP0GtH/6aXM8M+C5YaoSCiEJY0mSTntxQCiQ6LqOr6AAe1wcoihyYu4cIgsKWb56FccPHuDaUSN5+KOPaQ5cc++9TPjoY3oMHc6Kqb/Spk1r4mSJX7Ztw1tUTKNuXcCArO3b4eBhSkXwIJLtdfPtyuWh6/DLw4/S74F7MJIrMf3xJ2n58GiiIp2IgadmWZRC0tbq6nXY2rWuEER8eXmsGP8TeX6VelcMQFU18otKiPR5ydm+jePr1tB94BUUV83k69tvonrdhlg9biKq1ya2QV3i6tZDliWObdvCgrHv0n/oMI4eOcRPK5ZSFajmMp1PO952I4IgsPWzcdS/+Sb82ukgJRBwnD16jNVffoOg6zTs3pWjh7NJqJpBwcFDZNauyexfp9HrkYdNrQ5JDnmLGIbB1489wfUvPo8gn1v1svw5/17Soasq7nXrsaelI1dOATClvTHMkkgApgBVxabQS4k7iqqakxqBbBKYWTIC3/8LHrdw2r9WURR03cAVkOUWBAGfouL1KUS57Bc9/6B1uliu/GMYBpqmAcI59UIMA/x+H5GR0f9IYhEeNw0jjP9RaJqOX1HxqyqqpqGop50ptcC/lcBnzYcNoxHQB+gMdEKiHmZJ5DhQ+xzbT8IkIBpmz4Uz8L4PM/MBcHT7NkxxSA2/oqCopluoomohp87g+8GnUEVV8SumfLIUFYWiqvj8fuK7dUdJT6NOi+bUSkrlk48+ZkTdelROSWH8O++Q2bETacOvIj09DZemM33NWvoPH47dYmH+5J9RDmeTERVN7X69qdmwET17dCcW+ODmW/n5kcfZ8sU39Bh5K0u/+wEwaH7lFUz/17MhkzUBQk+uBpCVteu0NgRmgC3YspW4mpmk9eiJEVCA9GzexMGli2naqAHtH32cLavXMOHJx1gJJEZHkdqpM9UHDWTXgnlY80+RGBdD657dqdGuDVsO7CEmNoHeTZtz3yfj6PfAfRw/cVqoLCIm7qz7Egy51sqVaTlkIFHx8US1aU3RyTz8uSfJWrUaoUYNqqSlIzsciBYLomQGvcIVK8zvhyGcl1QEoQfO/fdClGUi2rTm4JIl4PeD14t7x26Kc3JCy5iTMOcuhZT/C0LTNPx+hbIyN4pfCY1SW21W7HYbTocDl8uF0+nA4bCf9Wez28zXdjv2gNrnmaQCMNU8dQ1Vu/j5mw2bp3UugpACniFnnovZlyGEhLf+iQgTizDC+BtAR6AmYAHWALvRsAO1Ap9vOMc60ZwmHGVU/DHYE/j/hKjoP82pUtU0bM2aU+mqYTS+/24y69QhIimRTTk5KAmJ1B9yFSVuD/UGDuSWeXPoe+MIbnjlFfrddAOvLl3M/PXr6X7d1cyc8gs5R4/w9rSprANuf/N1Bv7raeylZTx2w03YAoJJya1bUrVOHZZ98EngCISQxLeiqlSuVQstv8Cs6QeWOLJvP4369CDl0B4iN6/HsnYF66f9zJUP3cPRPbuIcxfQ++nHeWLsm3x+5524PG5a1K/N2tdfonn9eqwc/y2VK8WTEBuF0ypy13NPs3TFYtLSKnNwwgQOL13MwEcfAsz+BEdKpcCYp4QUsEoXDNA1Hc3nw1KtOoYgomsarUfeSpUB/Rnwxqtk/TiZarGx5E+bia+comrBtp0IikKbnj3InjbjgpkBodxT/R9BetMmzH78SXw7dyFKIjEJiYHgKpmZBU6XPs78C303VI2SkjKzsdLrM8eFAxk6VdPw+/z4fH4URcHv9+P3K6iqFpDXNsmBrhuhRkoAv99cx5TWrkiyJFHEZpHx+RV8fuW8rq/lUX6R8xGj8vgnN2+GiUUYYfwNoOkaEYgkYqEl0Fx20NIRFdIXCKJ5udfB0ckgygtLB7MXu4qLcCn+P/lYdYqKSul89z00GP0IJ4Brx7yMHBuDrhvIaRk806YN0996l+aA+1gO/tJSXv3lZ568/0GuGTaUZceOMbJ5c+6tXoP9U6cz69nnqDpsEM++9SZt7rgtFC673jWKKJvMgcmmhbkpVAWqoeFq3pTizVvN8gFmoIt0uji+dh3HsrKoPOAy6l13NXeNeZHXrhhI/rw5LPr2ewwM5NRKRFevzqbNG3nl0Udp374D7e6+gyvvGsXcDz9CEATS0jN4+toRjJn4A5eNfhhfUjzRiYkIosjqb79jx9JlVGrfFgBJMGWnUVQMRUFxu9Ex+wTSa9dEsliQbFYEUQBZpu5tNxE16AriWjbD5jntPVKlZXPQdWp368LqrdtZ+uFnoc+yl60IvTbNuoQKjQ1GWRkn11X0d7kY/PsPsnPePBKTKmFt0hhng7pILpfZbyAGywYETMNMIqBpp8mA2VRpkgVJEomIcBIZGYHVZkWWZaxWCxaLjP3MzITNisUiY7HIobKIKJ6e4FAUFRCwO2xnkZggbFYLmm7g9il4fef/jp/RChLGJSBMLMII428ATTcoQ2cjCkuAE6qHXZ5ilp6x3Ppyrzdi9lcEUf51MEG8Clj73rvY/yQPdgGI8rrZMmE8n999F2/dfRcJgoD9xHEWvTyGfRN+wJWShK16DWS7neNAUnoG+36cSNn+feQC61aspH3Vqny/fj3v7N/H2sVL6HD3ncgJCcS3bokYGUXwWVwURNrdfReSIHB84RJ03Qg9nRqiSOHJk2AQsvgu8HnZu3Q5rR96wJww0DSi6tRh9A/jmbD/ID1vM11JLZJMctvWtB02jGgEEjPSOLVsOQkplTi5dQe6x0O3kbfRsXs3JIcDSRLpc89dOKtVZfqrbxIbEUHDDu3R/H50VcVfUmoKSwFYZAS7DcEiI0gSxw4dpjQr69wXVNcxygU8TVVNyXJJZNBjD1N6IgdDUcjbuAl3zvGK90IQEAMp/qLN29n1/Y/Yy9zs+/5Hjk+fxaHJUzg+bSYHvptgljoALec42RMnk/3rNHZP+JENn39B3eHD2LNnD68PGsrzA4dwat9+/H4Fn8+Hx+PF6/Wi+P2B7IJJLDTNzBq53Z6Q9oPdbsNiMb08Dh87yYYd+zhwJBdV1VFVDa/Pj6KoZnNk4LWimttSy424BhU0rVZLoA/p3IxAliSiXKb3yIUs3oPVnIsZnYVxGuFx0zDC+BtA03R8mP0SLYEfgX5AY0xxrCDOdDM9WH4b5V63w3Q6BZi9ciUtH3oIr3KhWZJLhCBgS02lbuPG5J3I5f43XmPeJ59RuVsXrnc68aWkULp+PR1G3cbC2bM4WgpHsnajqyrPPPAQ4z4bx/233sLYV17mvTGvcF3btjw3cwY9TpzAXqVKKBUuCCAKUmg0sOZVg/hu1F2kbdpIixHXIscnICJQUFhENVHA0M2sRZTDAYEJDdlhR1cUVK8PyRnB51MmYyQkhCzVDcMgKSkJHYNNX3yLPzGW9KrVuPq5Zxj/6OPE16rFke3bQ8FIBOpfcTn1NB1dVdk4/geSDmcjp6chOR2IsowsSWjlekIAGtx8Axs//ISmtc/ulNE0A3X7DvwHD2F1OPDvP4C9fj1zf4JARGQknn37OLBuHS1uu/Wct8Rz4AB527ZQ99abACgvRG0YBkpBAXmLlqJ7vZwqLkSKiyPBZif/8BGOFRSQsnINNWpk0qBHdzat38DJQ4eIr1nDdF01giqcIAgGum5mrHTNH8gEGMiybEqAY4RKG7FRLvIKi4lwOti25xDJ8bGUlLnRdZ3oSBeFJWVER7rwKyouhw2b1UJ0pBMMs+lZLmcVfyFCECQ4kgClbg8RTsdZy/4eMvFPHYoIIpyxCCOMvwF0Q2cBpsnX2sB7M6hIKuDcbqbAWSWTBeVerwO8ZeeWiv6tMAyDopIy5m7eQv+hQ5j88aesXbiY0k2bOXT0CBFpldm7aSPbf/mV0S+/THtg18pVTJgyhc516jLjxRe49aabmT57Di1q16HkyBGaAo/ce3+gEdPA51cQMCdqgiOAAgJXjRqJ/1Q+UnQ0QZkvV3wMm8Z9ERI9mjdtBtV7dg81c4oWCxaHA13xY8TEmvoGoZS7Qf3hQ3FUqcLenGyade3KseIShMQEYqqkk3vkKHWbN+fQ6rVmVqK0FF1V0RQ/gizTeOAAhl4/giPLVyEF1BolUcQqy1hlGUksl0OyWjknFBWqVSOqSyfsrVsiZaRX+LhZ2zY469QhyuE89/pA2aFsqvfuedb7um5weOVqDi9egmSzISUlkdiwEWkNGxHZqSMN77ydK999m/T+fWn+2EPYNJVh/36BjHbtMHQDi8WCw2EPNVrabDbsdhsup4OICBeRkS4iIyNCn1ktZtnDZrPidNoD/zbJoc1mweP1k1dQzLET+cTHRJEQG4XX6+PwsZNERTixWixYrZYQqbgU6AGBLrvNdkHn1TB+G8JXMoww/g4woE50NFV/5+oXow0v3HA9b189jNwfJ4bS4r8XfkXhuief5OvJv+AoK+PJjz9g7vsfkNG4sTn7n1KFL954kyG33UaluEQ+PnqEbt27MezzT8ns3ZtV309g04IFtLj2GmLSMxg9ejRZwMyHH8Wzdz+7p/yK1+czXTW9flRNQxDA2qAeTXr3NEczBQGtrAwpIoKcffvNPotjx6jXpBHWpMRQRkIQBARRwOJyAYY5Tun1owdq8gbw6A/fE1WzNpvmLaRmg3rc1b4jhtXC1U8/Qds+vZg+/ntT9dNuR7JasTidSBaZSa+/wbO33MymJYtN63bObgoMBkj7ecSWJKsFa6RpzW0cPUbuytUUr91A2ao1HJ4xE1m2YBgG9qhojICp2Zk4sX8/JCRUeM8wDPKysig9fJiM/v2J7NCWmFbNiW/UAHuVVCwWOdBHcXoqwhIdhaEoWEQBn89n6kqUQ8WpCfGMv4rvS6JEXEwkNquFpPhYHHYbdruV5MQ4qlZOpqikjDKPD7vdRoTTHjDfEyuMhF4KDMPM7FhkCUdgiuTPwD+9bBImFmGE8TeAYRg0b9+eg8D9XbqwePGiS1ovDcgA2gLdMUdVUwKfJQAdgUerVqcq0AwJLfvwn5LmFWJjueuN11m3dy//vulmlmQfYdInn6KsWUuj4UP49zdfUQLYEuJYvHgRmfXq4z+VT7PrruHuTz8MGKvdw6JZs4muWxeAfq++zJE1a4l0OTkyew75RcUBrYFAALFYOJ6Ta/YkGLDw9bc4uWo1LTq2B2DL7Ll0u+eu0DGGSh6Bf0tWK7bICKRAUNX9aqizr/u1w/ho+xY+ee897ho2nNatWoEkIaSlUSk2GlGWkSyWCgEnPSOdJjffRGxUDJ49e0LiT+e6vvp5g5QOew/Azl0YhUVYM6tjbdcKqXkTJM1g1uTJ4PWSVjWNY4uXAbBv2kyOTJvOyVVrKZjwE2VeX+AaGWh+P8VbtnFoylQKd2dRd8igUINkeRJxLhzNykK0yFhtNmw2Gz6fL+ByeuHvS/lrHIQoQFpKAg6blZTEGKJcDhrUTKdeZjqVK8XToFYGcdERCEBm1coX3P5Fdm5OkxhBS/tzT62E8dsQJhZhhPE3gAFcee+9pAE9H3sMSa44IipiEoczB0ddQGLgrxQoxvT3ADiFmclo//57XNWtO7GuSJJuuAHhT5jP13UNV3o6z02eyNMrlvHWrOlc8/K/yVqzjvVff8vrzzxPQ6Bh586cXLiI6pf15YYBA3iqRy8+ff0N/Jgjss3q1yVr7nyuS6/Kwtffou51V5MZsCKf/9yLRDjt/HD/Q4F9GiQkJZAzex6SKCFHRRKfkEBM3boc3bgFWQAj0F8h6HrAGuJ0gAk9bcsyoiyDrmEoKrqikNSqNZelpNKtY2fq3HUHe7duRrTI5GzcTLQr4pzBOMJlqqgqElhr1uTAsuX8+My/yNm9+6yg5vecx7VUMyCtClSrChlpWDPSyJ42A4Dkvr2xuCKY9MRT6BY7XlFgzr9fRss+jOD2cXLNOjbu2MH6FSvZ9dFnPNmuI7OefBrRbift8n5kDuiP8BtGjVsMG0bRqtXoioIsS8iyjNvtuSRycU6qYhAgW3o5gmgSAUEQsFkt1K5eBZfjwpmGCyUOrBYZWRLx+BXTrM2vUFLmpbDEHSJcvxf/ZGISJhZhhPE3QFDm2wmM6dOHrFlzK3xeDzMQJ5V7LxJohimIde+I6yjBFMwqj2jAeyIX59130/SyXubUwZ8AXTfILywmr6gk9KTuKymh7ohreeezz5h9YB/Dr72OJl06smjSJD67eSSXNWxIl5Yt6dauAy2AA0Derp289P13tBlwORt374ZjOYzufwV+SWLfutUMbt+RI/tMVQ5BEEjp2YPcw9lIosiUn39m1oIF7FmxklPLllFQ5iZ3zTqWvvU2x9esCYxJ6qeDnqpSvG4jqCq6ALLDgaHrIApYIl0MfuQR0jMzyV+/gZTkSmz5Zjwb589nxrx5JkEpKiJrwo+cWrUaQ1Hw6Tqrv/iK3HUbeHXgEJZOnMyQ556lUq1aZ12vyimVznkdRVFEjHCB3Q4uJ0fXb8BdWETZyrWIgeNq3rsPR5cu55nXXuPVqVM5JQgkDRxAnbtH0vnZp7j+tVfYtnsXj33wPjVr1MRXVIhUrvnxUlG8azerfppE0S7TZTfY7+B2e1EDAmrnwvkbLIMGZQHJb1FEEKgwWRJc//ciSFD8iorPr+LxKWZfhyic2789jEtCeCokjDD+JvD7FS5Lq4Knag1WTpoEwOJfptD5iisr6FUAJAO5wHhM0nHl199Symn30yBcFjuaquP3+WHgYP5MLUHdMI3UdF0nPiYKW3Q0umEwaNhw3IpK21tvxm6zcvm99/HrG6+TlFqZ5bNnMWfZMh5s1Zp7dJW169bz+HUjePe9d+lYtx53XzWUzIwMol0OarXvSN+keGZMmswHQ6+mba9eeD1ujq1bB9dfS9XoaOLjEylzl5GQFE+DZk0pLiiiSp36VGrTJuAPYab/p73wb6LiYvAWFNIuKR5XWhUgMDli6Bi6wcmcoxSezIXVbh6d8D3jXn+dptdfi9vnN2NUaSkrJ06m29AhTJoxkzVz5yOhI9hsVM+sQW7ucVZ99gXtb7+lwnUyDINTBYWUfvMd8zdu4LY33wh9tv3Hn6g1oD+WSslggC0ymloDL2fXV98RkVGF9374kaqYsu5XZqSz8NBh9mXtpV1ZKdmbtpDWpROulGSGvPU6AFFNG7Pn62+IiI/HVr3aJd/LfZMmY1hsdL72WuxVzQZSQRACI6QyPp8fXdfP6fp5PnnxUI+LYE56CIHvzOl1DP7os3HQ2M9pt+Hx+VE0DYtmNv66HH/s234polt/V4SJRRhh/E3g8/vpPno0P/88hR433cCnox/Bf4ZkcTtgSOvWnNp/kNUnc8nGVN/snVaV5dkH8QMPD7iS0b9O4dXbR5JevQZKZGRF2cE/GUUlZei6TkJMNLIs0fGmGwOEw9znlok/4TBgw+xZuIF0oGRnFkUOCw8/9TSfv/Umn0z7lT79B1AF+OnQITLmzKNxvz7M/uwzmqZnsAODliPNccuX23VgxfMvklKjBpLVhuBXWbNyPoMv749vxy6qD7icWe99gFTmJj4+jvyT+bTs1YukVs05Pn9BiFQEMxpgcGL1ehKKS3h32jRkzJLSpE8+5dbKqUyZM5vo+BhObd3BR0ezWfPWW/iBBmkZyLLIvqNHKdR0qletTrvL+lS4Nt4TJ8jbvovZM2eQd+QoJYLA/mUrqN6hHQBJDesjJSaEBKdS2rTgq1tHcWjfXnquWYcVyAd6N25CcnoGmV278uPkXyjcmcWJnbtI69LprPtR87pr2fzRpzS+c+Ql3b/c+QuRdYGMAZfhPngIAr0kYBIFWTZ7UrxeU9fCbred7R2CUUEFVBSFcmUoISTN/R8pLxgGVllCluxY/Ap+v0rkJXiInAu6YVDm9uKwW1EUFbvtzHmrfwbCxCKM/zoEQUASRTT9/KI0YVwcoqnJHArAumEg1KrN9uUr6N65IwD7Z5j19vcfuJ+V335HveYt+GbWTK7p2Yvnn3gUwWYz/TN0nSt0nVu7dKNKzZo81KEj8TVr4quS9h8lFUGUlHnQdYP42CgM3TQ6yysqoczjZXtBAc1atqSS3UZMi5Z8OO4zhv00HmXxUjYuXEBWWRmTXn6NZEyb+Hvr1mX1lk28vmUTrQFnrMaeggJmP/cilapm4I6MxJqZSe706SzOz6fKqpXUT0igW6++VAOOv/Y6JcBDjZrQMT2dnzZvYd3rr1MnLY2Wffowql1H3vjmayJqVA/4bUBijarM/HkSFiAtMZktJ3OZkLWbOVdfQz5Qsm4j0TazfyPNGcmQkbdz/Vtv0Fe2ccvAK1EVlYenTKZWXCxaWSlpbdtSVlTCNe+8TUugS526bFQUMgQJ96rVbNi0iaLso3yxZBEf/HsMc6ZMIcnpIjYmmmVZu9kFPP7EIzwydz5TJ0zgZJmbVIedvOPHadeoIVmrVtPs+qtD13/v1BlsWbaUQaMfYs/0mdQINLReDLnzFqIIIhlXDQTAmpJidl6eAVEUcTjs+Hx+3G4PdrutgpHYmdLierkpGQLGd2dCECtmN0LL/0YE15HEwIhy0Pzvd0BRFE4VFhMV4cTr9RMVGfW7tvNXR5hYhPFfhSAI2K1WHHYrXp8f9x9skPqnwiLLAUVCFafdDpgaDqIostLvI/q1N7glPZ0Du3chAIvnLaTrVcPwKAqdu3dHTUvjtq7dOQq0kmROWCwM6NyF+oKI1Wah+913Ubj/EMp/8ZzKPF78qhoSuTJHRnWqplRh0/Zt2EWROppKht3KkfHfkdSrD9u//ZbPxn/LT+++T5+OHbnm3y8yduh1tGnbji0rV1A/Pp6o2rXof+Qom5YsgYJG5JSU0OaOkaAo7J0wgR6NGjNly2Z++fpLtKPH+PKpp7FrGoM+fBeAa68eiq5rZM9dwLTvviMWePb6EUh2J6LXjQrc3aM3S5YvZzOw62Qu7YEY4KEF83mr72V8tCeL1MB51u7TE7FyCgMbNubusWZZY+fM2WjApPnz0UpLePapJ4gyYMTcOVzWtStLpvxMCnDtlVcwf9kKNuUe4/lnn6HOjh3MWr6MOo0aknPoCLEpldgFjLDY2PDTz2ydPROv24MSGUF07doUr17NsdxcLn/t5dB1X/DMCzTt2hm7zc7xjZtJ69oZe3pFPYxzYfUXXxJtsVLnumvKvWtQQQq0HARBwGazIkkSXq8PS0B34tzuq+VIQmBao3wWpOKyxlkZj3J7veA5nEsMy9DNKZWLURTDMNB0HVXTkUTRbAL1+HFYLVhkCcF27hHhfwLCtulh/L9AFAQM/tmd038EdquNA9k5pCTFk19YQmpyPGUeLzaLhTduvgGlrJQrevRh3fJl7PGUIgFXdO7BlMXzGDPlV8o8XvKOnyI20sWifz9Pzv593DpmDA88/jiPdOtGSvcefPH6Gwz/4IP/1/OUJYmYqAimvPAiI155iWlP/YvCrZvZmpdPjzq1ySsqZlNODssDy791880c378Pn18le/t2JhUVkoI56ZIODIuM5bWSggr7SAVuateeDrfcQkTtTPKmTkOJT6RKR7PcoOt6oORRLsAFvreiKJpOqb/8SnqzphzcvpOPXniBWJeLnLIy7rnpFj76YhylQCHQMiGRmOQk1mzfzueLF/Dt/Q/RqH17dh84gLrvAG379Cb30AEyGjQgpUN7cLqQJJEjCxZTuUZ1vKXFfD/mNQ7v30tClXT2HznM/Y8/hqrrTP7oEzxFRbTs2wery0XlKml4VIWJ347nmu5dmTl7NnUbN8VVWkxGv35ERUagKho7166hbsdOJHe6tCwFgHrqFMs//YLOj4+u+L7XhyCKSOfR3YDgZIeO1+sLuYCeSRpURQ05tpYnFb8Vmqbj9XqJiHBd0vK6blBY6ibSaQpmna+BNVimySsspszrR5IkolwOyjw+HDYLMQFtEavV/o8UswgTizDC+AvCbrVx+NgJalevQs6JfBDMH9H8whK0PTt546P3uOvam/EePcxbi+YBcFXlNO4a/w3FpW4OHz2BX1WpkpzAib0H+P7RB9gO1Mf0B7neGckqdwmPf//D/+dpAmbjXmxkBDHREQiY7qSLn3iGjo+NZtvEySRnZjL48ccB6BoVxa7iYqpb7Sz3V9QZfbRePVKbteDbb7/myu7d+W7+fD5bsYzDCxbhUxTk4iKqDhmMZuiMv3YERw4d4pa33iKpVQuTBGO6Z4qBiQE98KQMpieJGAhCX977AG3ateOrd8bStGlT+j/yMJvmzOP7L76gbkYGmw4dogTo1KABPfv0IbJTZ3x+Bf/q1aQ0bUxR1l6kRo3IX7yQuOh48t0lzJs2jRqRkaS3bsWqOfNIjokmRpJYsXIFtVq0oFLDhmxasoRbPvqQnZN+ZuncOfTo14/ql1/Gvq/H8/O3X7MBqAx0qJJOn3vuwmq3U6oqJLRrS8GChbiLSynx+7GLUOpVqNywHvnZR1DcZbjsTlS/D8lioaigEG9eHi3vuB2cFRU9VV+AWFgu/LQejDs+nx9VVU3TsUBpRBAEVFUNCV5dbBvBwF8+lgUzGJqm4XF7iYh0XZCcBNd1e/2UebzYA9kGp82GfMbotmEYeLw+VE1HUTVsVgsGUFJahl/RiI+JJMJp9mhYLLZ/JLEIl0LCCOMvjKPHT6FqOpEuBwXuUqwWC0mdOiJ89B5bvvuSpPoNQ8ueOJrN9H+/RtNbb8Fut+IUbCiahjU5kas+HMfLDWsiAUM7dGKeu4SHe/b9/zuxctA0naJSt6m+aLMiIJDSoD6G38/i2XNpWljIqNatmbp6Ne1q1qatLJJ/9CgD27dnx6pVSKLETwf2E5ORTrTNQhFQUlDIgLZt+fnOe+h47XDslVOZ8+lnZAzoj2CxklAphREvPIce6KMIjT4KgjkeW/4ADdDQ0Q2TYNRo1ZL8Eyd4csZ0bPv245YkPv3iCxpUq8Y1zz/HbRnprPhkHHU7tCWmbl3yC0tAwPTAcDjxSBaK162nzhUD2HvoGKIg0t1qY/3sOUh5xezKPUFsdAxTV65gO/DLunU0X7eOUf9+nR2Hcoir14B6VhenZIEZ9z1EjSrpiEBzZKwREVRKSiCqUwfA9I4BiO3WlUPvfUBmi2ZEtGkDwOF5CxAMqDPgcnOcNYjiYog6d++AoRsIlzCnGQzyZmnEbOzUJAmL1YL0G7QzzrVNwzhdFtE1HZ/fj8twXjTroes6FlkkyuVANww8PgW/pJ1FLMo8XjxeP3arjNNuxWE3p0ecNtMtVZal351h+bsgrGMRRhh/QSiaSnpqIjHRESQnxOB02EhJjqNaWjKpiXGkA+n2CGo1NonFgh8nEB8TR1HWTsTlS6gW46JGRgqxURGoqk7VKpWQRJGsufMY3rwFR4Cv5s78n/FPUFSV3LxCStymUNQer4cJL43h8lG3E5OYxM7Vq7muRUvmrl9LWpMmxGZkUL9jRxp36IBSVsptjRrz08xZTB03jvapqcgOO2kZ1UiuXJkPnn2OpNq1uPyO25n07PPouk6Ppx5n1vgfzEyEKBKsuJ/plhm0Hj8tAQ7trx1O9ZYtcK9dx8GFi1ny5bc0TK1Mhz59MDwe8taspVqtWrw26k7w+YiLiSI1MZ78k/nIkoRRowZSSRlle/bh8fiw26zklHhJqdcQWbZQyWZjxtpVLAPigE6BI5rz9ees/G48373/Aet+mczUL7/ixIFs1q9fgwC4Uek29CoiGjc+5zV2uSIwXKcJQ3qPblS/vF9FUgHnJRVZEyex/tNxFGTtueT7aj7VW3A6HWiGjs/nR1HVUEPyxdY9VwCvIB0uiVgscqjseiFFTdNKHmRZQtE0bBb5nFLqil/B5bQTGeEKkQoASZKwWuTAd+Sfjf+NX40wwgjjN0HTNLx+P35FwePz4fH58Pn9eP0+EKBurVp4qyTx8/hvAeg2dDgnCvM5IQqkXzkA9+o15C9aRHSkk7qZaSTGmcGidp/eDHr3bRbMm8tG4LphV11QufC/Cb+icKqgCJ9fod9NNzLgtlspWrGalAYNuOOd92jXty8O0Yr3wAEO7dvPT6MfISE9g5sn/URyrVqcACYBB48dI7NJU+oM6I8zOYkOrVqy+bNxqIeOsGrJEnbvOoAeGUmtZk2Z98rrlG7bfjogCZyuvSOc9rgIjESqmo6iaSS2bsGy2XOo0roVvR++n1tfe5mxH35IwbbtlJaVItusuIG3HniYh7r1RD11kvia1YkuyCN2/z7cPh+7f5lOQvYBEg/uR967m8nfjMN/JJsrxo6lddt2ZAJ3DxpEw/oNaNO+IxkJ8fQbdRvXj3kJQdO459prqNqgDj2792TQa28iAGXHcmjaokXFAOv3s3/8D7iqVyeyYb3ffX+inQ6a33YzMbUyf/O6oijidDgQBQFPmQe/ouDzn19U61IhCAKSJKFr2gUVQINERJIks/9UNwKlGVBVDb9y+lgsVmu4N+wiCPdYhBHG3wiSKJKaFM8rXbsxO/BeDGbj4Ct9+nCktIT0xk1o0qoVK997n6N+P3pZMbs8Pnq3akO3++/GkGUeaN+RTcC3k3/G4/tjpmN/NuJjotBzjrL862+o2bIVJXmFHDqagzvnCEVePwfzTtD/zvvYMfZtfBaZA3m55AGZmK6tj7Zpj2q1ciI3l5TKaQg2GWu1TKq0bMnGz8cRV7cBPa4ZiCSZz12bP/yUqh3aE9uoPiEVyMDTrSAI6IaBpmsVBJFEQWD+2+/R4bprsB4/ToGqcywrC1eEk3lTfuXKO0dyeMFi4ho3ZPnEyeS73dx3770cVVUiatUkIioKiyyBYG4rf+NmZL+XLQuXklApGXt0JFbdIOnKAWz/YSINhw9FcJex7NU3aX33KFZPnU77Pr3YsXodh5Yuo9eYFzj81XfUuOFaCleuJqpLx5D41/4ffqT6wCvP76B6iVj1yKNkdO5Ecu/epuT574BhGLjdXtxuDzaHnUjX2TbmF1q3PATB7LHwerw4nI5QQ2j5Usv5xLo0XafU48MiSaiahl/RSIiJwO3x4vEpOO1WnI4zMjnnwD+1xyJMLMII4y8EMRDIzvu5KJAzeyZNmjSh17334cKU8g7iqY6dmL10CUXARz9PomD5SjYsXUrfN19n/48T2bZ6LV+sWsFJYPp77/PVq68y4JVX0c69O8Cc3NDPozXwn4BFlklJjMdmlTEwOHz0JMdP5hMTFUFBUSnv33Urycmp7M09RhnQHqjVqStTlyxEBG5/ZSyVKldi3YfvU+hXaHf7SKIiXZzMLyKjUgIf3HMvT4//GovFDCqGYbDi5ddpcfMIbEnJiAHb9PLjjbphaoEEYRhQtm0r7vxCtm7ZSo977uLNG27m4W++5MiceWyYPoOJ69YSD9z1yCPM+fFHeg25iu27dxNnt9OicwcimjcPbMvg+Np1xFdOZefCxRTt349VlNidnc1lVw+j4HgutqRK7Jw7m+zjOVwxbBjFJ05RkHOc1Hq1cek6RkIiNgS0wkLWzplN5U6d2LN5M0peHom1a9L+3nv/8H2Zfvsd5CsqV3/4HrL9t6lWBn06FNWU6rZbZTTV7G+w2c5W6zzfNsqjPLFwupzmdI+mI1vkCsucb1uGYVDi9uL1+VEVFafTgaKqREc4sFrOPSZ7Jv6pxCJcCgkjjL8AJEnCZrHi86vYLBasFgsW2XSdlCUJSRKxWS3YLFaaDRjAS/feRyYmqege2Ma4+x4io3lzXlkwnzSbg29H3UXW8pU0yaiKsnUb1QYPDJGKKGDOzOn8dPgQUx56CG9ODrIkYZVlc7+iiEWWA82UIjarFYtFRpakkAFVcBn5dzbjnQ+KquL2mhMfAgKRLgcZVZLJqJxEpcRY/vXt97Rp0ZI3P/+KjkBMahoTliwkBrjz5tt5/9H7KJo3m0XLl5C/diXs2EZcTCRpKYnkl5ThdDnZ+vlXCAhYJBlREGk/+gFyFy8P9VMEVSBNQqEhCiIWScYimed7fO16Ihs14tiRo0TYbOwd9yWH9++jYMUq8txuHBj0rVmLN956E6OklCq161D9iv5c/shDdLr/HvzInJw1J3TOOXv28MyQoeSsXYsrJpZV06dzbMtmFv74E5+NHcvP771LlYxq9Oh3GQm9e1H9+msQrBZS+/Yh+ooBxLRvi6N9G1z9etP66qupOehK+j73DJc/Opokv8bRFav/sKOn1enCdiwHY/+BS15H13VUTcPrVyh1exGAqAgHdpsVp9OOYei43Z6Qn8xvwZlS4WJA/CpoaHYhBEsjLrsNu0XGJpk+JU67Fcslkop/MsLEIoww/gKQRZGcE3l4AjPzqqpTWFyGRTKFspw2O5pmcPDIcY7k5rEY6NyjH8Nq16VXh/Y8etkAju7Yxftvv0WZ18/wt9/lq9zjjF25nHXbd7Li3Q/4sFMXTgb2FwfMmD6DjsCyY0cQ45OwWa0Ul3ooKfXgdDgoLfPi92uomgYGFBe7kSUZv0/D4/FhtVgpKfXiVzRsfzDNfiZK3V5TaVQQiIuJpFJCLHaLTNX8XKrnHsN2Mpep99/HLCBS9THm7rvp37IlTm8pA7t1Jb5eHWpmVKVrr978/NnHHJ/6KyVzZiGvW0WKVeaLr75AP34cMOv/yDIx6WmUrFqDgZmhMA3KzGZOtVz9XkCgcuuW6LpOk2uGIxaWcvOXX7ABiM+sTt6SJby+bh2tLu8PLZrzzYwZ9H/wPoRA2UMQBGKbNcISH0/e7Lmsf/NtomQrfXr0IDkugcr16lKzaTN6DriCpr170655c7r17UNMzRpEVakSCopNbr+FgnkLzrp2hqKEjlNMS6P6g/eSvW79H8449XzzVSJbtUa4RI8RwzAodns5VViCx6cQG+UiwmkPNQybXiN2ZFmmrMyNql7YJbV8M2cFI/ZyGhnBRlxNu7RzNRQFpyxij3AiyzJOu/2iwllhhEshYYTxl4DdakU34PiJfNN3wecjo3IyR46fRJYkkuJjKS4tw+P1EZ+Xy4inn6QbUEm0Iek+dgAtmrbk441reWXkXcxdtIg0q5WDp07SqkNHDu/JonH9ujz2ndns2Q5YgalrcfnIO3HVrEulxDh8PjMoKapmTqIkxXPk+EkcNhvHT+UTFx2Jx+unWloyR3JOmSWGvEJSK8Xj8/95vRqyLFElORFrIK094d4HaNahPTmHDvPD5EkM6NOH2bNmEQ3UDJzLO5N+4s277qF6g4ZMnDeXF55/ji3LVzDoX8+Etnuu30MtIJBlGAbZU2cQKYm4mjXFmlIpJE+v66YKoxwQdQrKpCMI5MyZjx/Y/t4HbMWgXnpVpLhout1yMzM+HUe7bt2o3L0LYijwnT6W3IWLmT5uHPmHj9KtYzsa3Hs3mtXKh7feTquWrZALC7HFxdPo4fuQxLPHHH1HjnBiy3bS+vUG4Mjc+ThL3cQNvDy0D8MwWPT2WKIiIlFVhVY33oB4hj5FYVYW89//mILSEhwWG9e+/drZ0yKApqgmQbqEHgvdMCgqceNy2EylyjMMyMqraWqaFlDrlM9pZFYe5e9hUIjL5XJW+FzTtBDROJ8AlurxIsoyokU2PUA8PnTdwGKRcNislzT98U8thYR1LMII4y+AoLmRxSIhCiKS5CCvsJjY6Eg8Hh+5eQVEuhxEuBz4ss2RzO7DhjPjhwkkAL36X0FCh06wcS2Pfvw+Y+56gOjGjVHeeo2iTRvIzTnOibISAAYCAhKfPvscMSmVOGoI+BUVWZKxRZod8Yqq4fZ4yS8qwSLLWC0yLocdXTeQJZETeYU4HTaKS91YLPKfnjrWdd3s8g8EpOT0dGoNHULQcLzt/feQtXcfa/fuYSuQCLw1/DoUxUffD97D5vFw8uixCqQCzt/MZximl2b6gMswfH4K5i8g68e9tLnvbnTdMMmFYU6ECOUaPA0DUrt0ZPVHn9N5zItkLl5KjdatmDprFs6MdIaNeeE8UtTmvvev38ANX3/B/im/Mnf6DDK272D/xo1sz8kh59dfSAIq16nL0TGv0nnwIKLq1qmwDVuVKhTNnU+VQHbHX1DE/iOHyZy3gNQe3ULn2/WB+819er1s/HwcDQcPwZKczL5fp6J4/XiKChk85gVmvjGWRm3b8M0DD3L9h2ershqqiiEKl0QsFEUFQQgJY515H8pfF0mScDodFYzMLtXW3dDP7r2QJCk0JXKue675/SbxCHy/JEEg0mlHUTWKyzzYLRaQ/pGc4ZIQzliEEcZfAGJg3t8I+IEImPLDoiiYad9y3gri+g0889LzfLhkMYqmIqsa0+57gJk7thMXl0j3RvX516JFfHrLbViiI1k0cxabdu4gEtCtNvL9Pl575x0UQURNSwuljc0nc/O1GDCRC+1TMMsBkiSaQdgwj81cXkBRlD/dRjo5PpaoCFP4aP6YV2g56EqiatdmzJChjJ4wHrWklC+vvYH5BacYXLUqg++9l7kzZxKXkEhJcTGbDh/m7mefwlG58gX3Y/ZSGIFeCgFBENHdbub86wU63nITjpqZpxUjNTWUhBcwyYgkiORn7WPP9BnU7N2bK0fexoSXXya1fVs2ff4VRzdsoO+Tj2FLS6uwX90wWPDSy7QdcS3W1FR+vONuUqqk0qJPXwqzD5M2eBAcy6Fs925cXbucN8j6jxzh8IqVZA69CnXdBuQWzTg8YxZxTRoTkZpy1vK638/id97HarOSkpFO9QGXn7XMjBdewigppeWVV5LUrnXofc2vmCO5F1HeBHB7/BgYOO2X1pwJgSZPrw9N07BaraHJHRPBbQRHgwV0TcNd5iEyKsJcony5xDBQNc0cFQ405GIY6JqG4vFiPUMG3DAMPD4/mqbjsJk9RcH3g9s+E/9USe9wxiKMMP4C0A3jkksJNquMD7O0LEkihdt3MGHHdoZ37sKA559FB6I6L2LyuE+57577EXfu4iRmEEzw+9gJ/PLOO3gEkyT0euGFSz/Q/6JrmcfnIzLCiQDU796dBR9+TI3GjTl89Cj/7tKdoXeM4quCU6QBtsgo1MzquCIiaH77Lfz6yOMoubmMHDKUr5YvRbiAEJipUwGCKEFgzNRwOOj58ovs+vYH1NVraXDdcEQEJFFC1c3mwKJDh4jOyMDAIKF2JjbHQL6570E6A6nt2yIIAi1uGkGjdm1QFY0z5ygEoOtjo9n88ac0HHkbgtfPqrUb6PbsMxBI5VM5FcPjZuHzL9Ht2afOefyWypXxlpahFxdDA1OnIr1fn3MuCyBYLHR56P4LBvt+Tz8JwLFZc9n97be4VZ3E6Bh03SCyUT1ia9Y877pBGJiCYr8lm2X2XdhCLqmapoUC/NnS3gKGYTaHlpW6QQCLxRJY3qR9AuDxeBBEEbvdhu73mxoWDkfFTEfgOGVJwq9qlLhN2W+zBGZ2dNitslkKC/qwGX94gvcvi3DGIoww/mbY+uknLFwwn7eXLeHB/leQVVhAGiBYbUTZrLw6azq+ohK69bsMgIbA1jO20SImljS7jSFPPMWBnTtJ69Tpv30aF0V0hIuk+JizavMLX3+Tf0+ejAsY3bI149aupnZEJL+UltArOYWqNTNZs2wpV3XtRp3rrmHRl18y8PHHcMTGXnSfwd9LVdNCUt/HFizkyM7dtL77DiRRCmlaHJ46k/ziIppeezWS38cTPXpTJSmZhMQkBjz/DM6UFAj0EVxo7HHjuC+JtNv49tvx/GvmVARBwFfmxlaub6Bkzx42/fgzHZ985NzH7PWy5rNxtLr7rv/oRIPq85uE9hIiqk9RkUThd00N6brZJ+F2e5BlKVQaOROaplFa5iY6KjLwjnCW4Juum1kKQ1EQZcnMtpxhihZEMHsVLIlYZIlIpwNfYFQ2KsJRobD1T81YhKdCwgjjb4a2t93CJuCLG26ksLCA6XNn89Hc2Xy4cC6PvfcuHz84mnfuuz+0fCHQJSGBFGD8448B8PAbrzL8nnsp27GNsk0bkfLysV5Cevu/CUVVK8g0K8UlbHr7PX6dPJlJn39Bv9RUCvw+ejZqQvUqaTxUrTqPvPYy1415kXeWLia+ZiYJlVMpOJnHnLffu6RxxlDpRxRCzZap3bqR3rghaz745HS5BEi/vC/unFxEnw/dZuPfy5Zw+08/UDk6irlvvhWYJ7m4y2/TW25k+/oNJCTGn/bYKEcqXujTl6nPP09GjYzzH7PdTq1Ondnx06RLvr6/D5f+vGaVpd8tGS+KAhaLTGRkBKIk4vF4Q/0SQfMyURRD49in3zst9x2S/RYFDE1DB0TZgnABV9Ngs64siRiGgd1qQZZELLKEX1VDYnKX2v/xd0WYWIQRxt8IkigSk1yJL++8i8/37efpO+/i1OFsBJcTURCJqVGN4vx8rmzTlgULzVFED/DsxB9JBRZNmsIVwMqPPyWldQsajLiOy994lYwm9f/nPBC0wORF3pat5M6ai7E7i+qdO3Nlj16U7NzBZbfczNbNm+g36lZsLgcFukHxpi0mCSkpwQB+fvhRRr73NvW7dWHP5CmXrJUgCqKpHyKISKJIpQ7tKS01pcj0QB8MQLt772DhK68jiWYgssgSGW3a4JJPP9GbWfNza0gEJ0x2HTzI3V9/ec5jefLXXzCiY3FregWideb2ohvWRzl06JLO74/gUpPgf0bwFUUBu82G1WrF4/GiKGfLgJ/PITV4jXRVBVVFtllD0z8XgySKxEdHhLxELLKEy2GjzOP7Q+fzd0GYWIQRxt8IsiwhiFD5qkG0Fi1Uu2YYiXVql5tUEHno88/4YtIkunXtRg1Aw/yRb9+4MYquIgKb16xhTI9e3NTOdMEUBYEIl+NPF7v6vZB0g68feYS3Rt6Jz+MlsVd3LC2aEd2sEV1eeJYq/ftx8uBB6rRuzcpfpvP1+vUkNmrAuHHjuL9TF7Z99Q0ff/IJB7ZtZeWYV0lv1wbR6SJ3yfKLBpbyAVEPmY8JuKLNdLuAgBSwUcdqpdGVA1j25tjQOprNTrO0aqFtAec13TIMg5/vvZ/U1NTzBmHRaqXb9SMQLRYUVUPVdNxeX0VtjcAxWxxOjv469Tde7UuHIJiNkP9NmEZmMg6HHb/fj6Iol0wQNZ8fzefHGhmBFJhOuRQxrmC/RfCeCIKAw2pavwczUH92s/JfCWFiEUYYfyMIgQbCma++Tv1mjc9K+0qB9PDzU6fwfJu2fDp7FgXAA5270qx/f4olidZDh7EImAlUr1sHXdcp8/iIdDpIio857xPgfxqiIODIziZ+z16iDh7guudf4Krnnsdau/bZegRWK03vvIOBb71Br0cewAMIPj+jf/mZhx56mJzCIkYNG0ZKzZq43B4oLSWtexfKytwcWrjoooHFKEcozLKIyKGdOzG83tCxBDMasY0akFK9GtnTZpjKknXrkF+UT+HmzaHtCULFIoIRkEif9sDD2KJjuP69sRc8npTWLVg7azbLPv2M/KISjp/Kp9TtrbCMIAhE1qyJpEPprDls/mY8/Mky7IauY/yXpN3LIzhCapILpQK5OF9SRHV7EEQBS6CsFCyjlFdW/W3HYP6Vur24vX6KSt1/6Jz+yggTizDC+BtBEAR6dupMzSZNuXnsWxAQGjoTuiRTqXMXHurdhzTgnaWLqda7J3e/+QZjf/yBu+rWpwswYshQSt0ecvMKAsHK81/zBDHPB2ylJUTt2klMVhZGbAwFtWpSUL06imiWIaTA6Ov5sGDCT/yyYB47snaz/ecpJLZrw6ezZ1FUUsJxVaPI4UA/cswU3erRBU9ePjlr1l302AwIPN2a6XarJCE6TjfvCZjkQpZkqg7oz/Y1axE0jciMKuhp6WydOCUkBHVaL8MkFLnr1rPig4+p0q4t/V96/uIlA10nLz+PWnXqYLdZsVlN0akzkd67B0V+P9mnTlG3TUtWvvsBvz76+EXP9VIhSBKi+P+X1SpPLvz+4IjS2Q2YqteLIMuIckWNlZAb6u+QEBcEgUin6dCaX1yKX1X/6On8ZREeNw0jjL8JBEHAO38uiUB6nZpmKv48AUnXDSJbtiAK2IgZJEVRRLBauKdxE57YvIln+vbl4Ree5yjQv0kzrnr00f+a06mk67j27kUWBFSXi7K69dCCP/TlXUQlgZhI1wWzKN1vHIGWl4daXMrUn36if34+ecDevfvo0KAxJS4bB7duZd2nnxFntZGUmsKyuXPpVVxIRs+e592uAAiigKEb7PhpIj1GjQwIZRlI5SY9RMAQRLrfcydrPv6MlneNYsmKZXiKiugIgVSFgOfIEbbOnkvllEo4KyXT7s6Rl96HIIr0HDgItaCQ6AgnsiTh9vlx2AxEseJ0Q+2hg1k39j12r9tE2/vuJuvHiWz8ZBwx0VHsydpL+6uH4sqscfF9ngOGqmEIIFr+/0JLkFx4vb4KxM0ULDN7KgxNR3aee5LEJBciuqb/5j4QSRRwe/1YZJmIS3A//bsiTCzCCOMvDgHYO2MGNftfxvffjeeG/v3Z9NMk9u3ezU3vv4sQGXlWrd1usxITGcGoiZMpHDKEGQ88RJFuUKtWLdq9OobnnnuRZ2fOBGAAsHvTBsZedx33ffvtf+w8REHAeewYttJSdFGiuHoNdItsHvv5nh4Nzp/r5vT5CqJIWuVUrhw4gBkLFlEF+DRrN582aED7++4BoLikhJa338qBH34iqaSE6e99yC2NG2NNTAxtqzxCNXRVZePPv1CUtYf4Ro3JvKwPKz8dR3zlytTu3zdUghJUFbxe1n78GU5ZxkMg0OXns3vpcvQTJ2l58w0h1UpBECjctIljO7Ood/XQi16/ujdcx/THnqLq4Ctx2Kz4/Aq5BUW47FaiXM4Kxx9bOZUaA/oDUGvoEPD7wWqlmq6z6M2x6D4/3R59CH6j/fn/J6EoD0mScNjteLxe02PEHrBD9/owdB3ZeWE7dkEQECURVVWR5UtXjjWF1HQkyZwc+acirGMRRhh/YQiCQITTwbFJE3n3q69Ixpzy6NW7L9bSYmYsX85bSxahSyKiULEPQdN18guL8Xl9PDV4EO+P/57cAwdY99235BYUUKNqNV5YuYIrgbSMqiw7dJAH3n4HIzn5Tz0H9fhx7MePE+1y4U5OxhcdfcmNbxFOOymJ8RdfsLSUA79M5dX330cF7rrlJrI2bmbPhg10GXwVURlp+E+cpMVdo9B1nQmPPUmNpAQkzaDJfXcj2So+3QZ7LFRNY9f3P5BYpQpERJN/cD8+v5/Eho0Qjh6huLAQZ2QEnpIyEuNjefxf/yITGPHUU7z5xhuoHg+9Gjeh06hROBs3qLgPn49DE39mz+7dZHZoT7VWLVDdbuTU1Eu6Nrquk1dUgs0iE3kGsTg2fQapbdtAXBwAC595nqSEeGp06YK9UX38x4+Ts3I165atYMATj2CJv4RrDCge06FU/h95Wtd1ndLSMnNE1DCQrBaki3iNBBEsSxmGEWrsvJR1cvOLAYOoCAfREVH/W6NU/yWEiUUYYfyFIQoCsTGRRDjtTB9xA/vLvEiKihgTSbVKKXy3ahXfTfuFGe9+RP9nnjhL0lhRNXJPFWBBZ8qIG/GXFuMFrvnkY3LWrqPw+HFyDx0mMyqCp5Ytpwx4pnVbPl69kkY1a7FkTxaff/UNTk3h4KbNxLdrf8m1aVlV+fHNN7lm8GCUzBpov+O/yOgIF4lx0RQUl+JXVATAHpBb9nj9eHxeZEkiPiYa5eAhnr/vfrw+H3HuMrp36IggirR94V+UHTrCzx9/REpiIsUHDjJr8yY+mjuLRWPfpygvj4Gvv3KWOqdhGBTv2MmRbTupPeQKNE1n3Q+TSElOIL17V/yqhqqqWGQZj09BEEDPPsLKTz6l+5DB3Dp6NB89+Tin/Co2i4WywiISWzQnpm5tDE1jy2fjSL3iSiRBoGTVakQBDm7aTMdnnrykaxOUoC4p8xDhcuC0mSOugiBQuH0HviM5JPfufnoFt5spDzyEx9C5+pOPzfe8XjZ/9jk+h4P6XTrh3XeQ+E7tz2lABpijm1yaCdl/A0HDsZLCYiwWC86LlM3OtX55GftLIRc+v0Kx20uUy06EMyJMLP5JCBOLMP4uiImKICrCyZDOXXl4yCCqt2jNvpUrqdK4MevmzCZr1Squf3g01QZdAXDWk7fH56ektIy1n3/O2z//zPSF8yk7cJBV43+g5zNPoBYUMuWZ5ziweSMbASfQOSaB3JIicjWF1YFtjaxenY4vv4qmaRc9ZtmA2K1bONWwAYbw+1PGEU4HMVERnMgrxB+0Aw/U0oOwW62kJMWhHD7KJ08+xYGD+0kGjgOjn3iCElEiqmpVji9dDrrKuvHfs1NTuGrQENJ7dEFA5NS6DTS59cbQ9qe/8CIJcQk4o6OoPfyqwDSOGGqUFQUxMIqqh8YP3V4Fn6JiOXSIiHp1mHDHXTRp1YZGI28OHeu+8RPwSSLH9h4gc/AgxOhoRFEkJjICl8NG8foN7FmyjKgqqdQaNPCipYogeSxxm8Z0uydNxurzoRQX0eqqq5CqVw0tu/HTcayZNp3lJ3JJAN5cuTz02amVq9k2dx6JlVM5kX2EtAYNyBwy8Kz9qR4vCCCfh3j8t2HoOrqmofoVgq2UDof9N5MLTdMRhEsjF4ZhUFTqRhAEEmJjw8Tin4QwsQjj74L46Cgi809x4lgOSW1bhQzJlr36BmpJCQVOO1c99eQ5fxCNQE24zONB03R+ePxJlmzcwCM330ytLp2YNvZdmtStR9Vrh3Nq925y123EfWAfjy5fQV1gUFo6G7IPsxb4afJETggybu+FRYIkUSR22zbya9ZC/4M1eVmSkCQRn/9skxLTat4gLjoSp8OGv7CI724fRa+rr2bRlCmkp6Vx9OBBlh88wANDh7F8zx4O79uLWlxK3bQ0rv7hOw7OmsXa9RtJsFiYM28B1wy7imr16vPLZ58R5XBQ/7J+pPfugUAg6ASaNoOkgkAfRdA8TlFU3F4/eVu2UpC1i4Z16+Jo1yZ0L7J++AkQiOzWDUGAhNhoCKiQSNLpoObZuZsNP00ktkoVDIcdR1Q01S87v/+Hrht4vD4KS91m7X/VSpIv61thmZ1ff8tnH35IEuBKTKZa7Zpc9tor59zerh8nsWzGDEa8+RrWQDkFQFMUBIT/iV4LwzDQfH50TcPqcobKIqIo4nQ6EX+D3salWK1XWFbXyS8uo3JSYphY/JMQJhZh/B0gCgIJsdG4tu9AbtMyNHYZnE4g6IZ6nh/CvJWriWraGC3wtK36Vb674Wb6DhvCkvkL6DzsKnSLjdQ2rcwAqWnMefQJJq5dQ0NAiY0lPSmZrN27OAh8MHcO37/2Jj1vvx1FVc0fb4PQcYmCQEzWHkpTU/C7XOc8pt9zDcr3ZIiCgM1mJSbCRVGpG0VViXQ5cGIw7t77qBwRQYMmTckrK6NSlXRm/DCBrceOUEuSadG/PxN/mcLDL7xAYs2aFBUV46pRDatFRjl6lAVvv8u+nGMsy87muRE3oNms1L/h+kCJiRCxCKlfYk4jBAXKFL+ff3fphqVOXR768ANO/vILJwsKiUtJ4dDqVeQh0vLee/ArKvExUURHOC8YxHaNn4Df42HRL1O5d/zXEBFx3mWDT94bxk8ga/58BKuFaz76AKGc6Jl7/36c1atf0nU3Fi5k2cYtdHzwvtB7aoBUyvYzLdX++/CXliFZLYgWSzkhMh1v4BjtdvvvIhfB/54uhVw47M4wsfgnIUwswvg7QBQEopYu5uH33+frlRVVI031Px1JPH/jmVZYROHa9UR364zH68OvqCz74QdYuZpur76MNSbKNL3yK9htVkr2H2DP1OlE2O2IwIY1q8nNymLwAw/y9ltvsgqoA9zWuClvbd7IVQMHs3vtamrUrI0d2LJqNXVqZtJi5EikpKSA/bqGql68fHI+CASUEGUJSZaRRJEol2kMVeL2oKkaNquFuJhIpj31LHG6xslSN026dcVTWoIlOppf3v+YbF8ZLkHk1jtGUZi1h5UbNnPz55/gEUSTmDjsppCVYbBz4mS+e+ttbrz7bmr26wPR0eiGflaDrG4YISn0IwsWs3fGdHZs3c7Nv/6MqusYWftQS4vxKj5OFJYQ0bwF1kCzZaTTgXwOLYpzQcnOZsrb79KiXVuqDTZLFEpuLnJEBMIZBE7VNBa98G/aPzr6vOZdlwLPvn2Mf/Y5bvnsk1DPhRbIHEnW/z9fGUPXUb0+xKBOxRnkIWi9bhgGDof9N52/YRioqoYkiRctpxiGETYhCyOMMP560A0DtWcvru1qNuGdZbB0kf4FKSYaSdPwev2s37qHA9nHaXHlQA5ERnDbFVeQk52Dz6ewYu12suYtZuabY0muXYcaN44gP7MuEcmVsMbE8c5bb3IE6AEMbtWOPZLMoFZtSKndgL1HjvDuwvksXjgfITaWTi+8wN4ly9mxaBnZR0+AIfwhHxIDU8rc5XSgaTo+n5+iUg9+RcPlsONw2JEkCUmUGPDMU+SrGh7ZQnq3zqyZt4BNM2ZTt1F9ZGDUA/fz6gcfkHXsGPUyqzFjzMvIsowSID4HZsxi78w5fPX5F9z2+BOs+GUaRfv2B6796Wsduv6Bvo8JI+/gm9ffpMMLz9H/jpFIsoSuQ2Tj+og+LyldulC7b28SYqKIj4kkJtKF9BvGFS1paVz1xqvsOnCAQ79OA2D1N9+heL1nLStLEvXatGLNd99fsq/HueCoUYOu3bow5cUxofcMQ790s5D/AAxdR1c1EMxyzLnkxYPW64IghMzLLhVBjQutnFx6hf2XmyQJm5CFEUYYf1n4FJWCcwSQS6kHAxSePMWKV14P+CQYOO12+t33IIMHDyP/43H4FRXv/n1sXbWWzFtuR27Rgq2Tf+HgvLlEDRpOlWbNWAEMadyUzt17ceLkCfZvWEvv0Q+zYvkisgL7WQPknDiF2+Mjvlt3XHknSEmK50Re4SU/mZ8Pqqbj9vhQVRVFVfH5fThsVhAELBYLNpvVPA9RovsLz3PqxHEevmIgt3z6IR2v6E/z3r3ZCOxcvIRbO3fCcHuYvmY1y1evYsO4z7i3Tx/WfjKOgv0HeOjFF3nppx+YNnsmtZo0YuKYlylavtx0NS03cWMYBjunz+DKdh04tnUHj077GYvTSVrLFni2bAUMfH6VwqKSkLZIdKQLR6CM8FsDk7p/P3bd4NCq1YwdfBXVWrbmyOKl5142Jo7i/QdBPbs35bdAiIunatzpUVSB/79gahgGmt+PpijIF8nE/HFyIZ2TXPzTPUKCCBOLMML4i0MQwOv/ba6KwXq7YRjYKqdgM3TSUhLRdYPd+7M5dPwU0yb9wJtL5zPn9pFw/BgtbhrB4ZOFlB44iDsvn9rXjyDuxDG8isYHb7zD/M0bcdudFBvgQGDbO++yZ+liAGoAyYBL9TD35X/j8/lRVZXisjIcNutvlk8+E7quB6ZRTDNyVdXIKyzC5/XhtFuwWiQQTKvumEgXNp+PTAQK16wnpXtXvn/xBQY3aEjT+vU4cSSH9EpJtG7WDAHYv2kTr/3rX6yaO5dt69cD8MGDD3PtyDvYkZ1NvsXKysVL2Tvx59DDugH4vT6++OIrXn3wQWLr12bpK68z87kX2TtnHoW5J3A5bLh9Pjy+05bfwSzT73na3bdyFYt+nsy+rL14jh1jxaSJ7Fm67JzLprVuQYPO7bm/c1f8xSW/+/pXG3A5C1etRCspMd8QOFNB+z+OIIlTSstMInkR8avyCJILd0Cq/lKuQ/mM4JnkIiiG9k9HuMcijDD+4pBEEce2LaT2M6cCzvyhOxcMw8CvqKiaBhj8eP/DtLzjLhSLlYS4aBRFJSEuGrfHy30DLmfMl9/iXbuKPXv2k1QtnWZDBrFn/WaOzJgKzkhqX3kFJ7KzeeKlF3BjPrHoQENgwOCr+HDST4waeQ9rJv1I5cgIFFcEyDJdH3iQpPgYSsrcF/T7uBQIgoBFlvErKmAgCCIWWSQxPhop0KAoCgIWv8K4u+5h9q5dtExPJ+/wYeKjk3Cmp6BoGs0aNqJ4z16wyyxZsYKOA4ewYcE87nr5ZW67YxQ6kAYMvn4E7a6/DremU7B6DWumTaVml2406N8Hq0XmuvYd6dmxI9feezfHduymaq/u6IbO8rHv0+G+uwHw+BVOLF1OSu1MbGlpf+j83SdP4oyOBlkmd/FSkrt2JnvqDBKqVcXRoN5ZyxuGQfb4H/jXe+9y0w030mHkrb8vfZ+fz7x33qfHv55G9QWaN23/veZNQ9dRPV5Eq+Us749LWt8w8Pl8aJoe6rn4LQJacP4xVIvF9o+sh4SpVRhh/MUhiiLHDmefnkQIdKSfD6fHHwUMTILRcegQ3CuWUr92BpWS4khLTcQwDCIjnDx86+08f+N1xNSqTd+nHqH5tcM5ungZrrwTdH/pBbo+PpobR93OOwFSAXB7rVqMbNCIQVWrc2LzZqYsWkjh5nXkFBfSonUrPILB9c8+SbpNZPvMacTHRP2hPovgeem6jiSetrLWdQO/Xz0taY7A5kk/s3XXLvpWSadRWgZ7gQVFJ8j2esnNOc6iqdOYvGENyT360a5jV4y8fHqPupun7xhFZaBj5TQ2AFNnzGR/bh7bsg5yPL4S+Yh88fqrFB7PRdN1vMAN/34Ra5UqVO3VPbT/ShnplO3ZgyAI2CwyUXXqcGzDpj907gDOxESwWkEUSe7aGYC03j1Y+O34cy4vCAJp1wwjIzEJd1EJuvI7yyJxcUSnpHBkyVIEUTxLSOw/CbOnQgVR+F2kAszrYLPZkCQxVBa51MyFGDDA+z2mZX9nhIlFGGH8xSEW5LN9+kxKtu4sZ+V9af9py7KE3W6lSsd2WCMiKN29B103GxWtVvPpv97VQ7mzz2Us/PVnwPxBzdu/l7QrLscwDL586hlGN2tJr3ZtmfXjBO6oXoPlWVms2baF5w7u59O9WWxZtJSTpaW888vPyLGxjHrzDb559TXuHH41H7//IS6HHbvNdsnSyeeDqmnYbTZEUUTXNVRNo6C4FJ/PDJqiKJCakUEOYItwsXnrVqo4XHRPq0olj5s2zVuw1V1Ms7SqvPP8UyS2b4cmipxauZzalaqQA7iiYkgGalvtrHh3LCdnTOWZe24nJiWFq996n23TZ7D162/JSEpGkKQKhA8g88oBHFu30byWABER2P5T9QOrFVt8HF+OuvucH392w40UnzxBgz69OPDLr787OLYceSvF+w9gaKYg1X8DhmGgKQq6oiLbf9t0x5k4TS4k3J5LL4tAYNw5sHyYXJgIE4swwvgLQwCKt2zh8qcfR1N9fHrDTRc27eL0k1awFiwIpgtqnauvwnssB/fa9WiGaaRks1rw+lUaPHgP+5atRCsrQwCsdieGovDmVcPJ3rwFLcLBtS//m88efoSk2rXYiuma+tS11zKmYycymzelTNf54r4HWPbLr7w+dDhTVq7kq2VL8AKePXtIiI2iUkIsSXExJMbFnOVvcanQDR1rOYEmVdUo83gRApclb9Nm8oBFu3bSb/hQqigKp7IPcvtLLzJ93ixGXXkFJceO0rVOfdx79hIVG0tG9Wq07NWDm9t3oP/991EIlOZkk3f4MB4RGiLQrn49hCMHqN66LXd9+in3PfYoeiCLopULVIIgkFitKnsn/2KOyVpkFJ8P4+RJ8pYuP+c5/RF0H/0gN37wzjk/U4tLaVW3LskN6lJQ4uHgr1N/d3AUBQFRNx1BFY/njxzyRWEYBkqZ27Sm/w09FReCENA/EREpLSm75OsgSZJpta6FyUUQYWIRRhh/ZQgCPsVPTIvmRDZqSHLlKhWC2IVwriXiunREiommbOUa0/5bNIWfVEGkWfu2vP/EU6in8tizaQOCRWZu7nHmFxfy05IlrH3hZdrVrs3+lasYkJJCKpDmctHiySdQVq3iqc8+pmnXzlgiI1BjorizTx8eGzCQ4d17oFVJw2a14LTbiIpwEhPpIikuBufvEFryKyoOm63CqG3hziwOvP8JX4+8i19nz+HmNm1oX7cOda6/lvtnTmXgoIEcmjcfHSg6mUfVZk1x2ixU0xS+/PknFs2fS9WUZHx5+ZTMnctLQ4eyCzhVWsz0mdNp1bULlevVZsHXX2HbsZ13R43i1/feA8xSlSnipYcsvGPbtiZz0BUIgoDTbqVQUVj1/Q8c272LRc+/yI5vx+Pfv5+NX33LO1cMpHDpMrZN+JHPR476zdcjcBDnfLv78GF0GDwEWZJoOuIaJFcEWRMm/q7gWGvwQDZ89TWiLGPoxn8sc2HoOqrbg2SzIlotfwqpCEIQBBxOO1arBY/HG+qhuBhEUUQMjKGGEbZNDyOMvzYMg/iatSlctIT847m07X9ZKANxMQiCgIiAfgbFsNbMBPaSP38B0V26YBgGBcWleGULqzZupN/sOTRo2xbf8VyiADdwRXo6C+bOJr1+A47pOs/88D05S5fzwpNPcv2x46R178rzHbpg1zVyMejasBExSUncOHIUlTp1xHVOoaLfN7qnaRpujxfdMJ+eT039lX3bd9Lx7rvpNmwonjWrWTV1Kq3bdjAFr2SZSJuTN7/5moGduzBn8SLemD4VzeXinT792AdcGZ9ATGYNVu/aQe9bb2bNrFk8c/8DLFy1khZFRcQkJjJsxA1UB9atXUOvu+9AKysL9Y2Y11pE1w1TodPjQXQ6AbP5tlLVqhj16pDcpLF5zCtXsmPhEppe1oemfXux6ONPmTZjBo+89eZvvh7nQ+6KNbw/dixjA54gkiRSpXtXDi5bxZGZ80jr1/M3bU+MiMBr6OybOoPq/fqguD1IFhlBFBEtltB1+CMwdB1NUREk6Xf3VFwMgiBgd9jx+fx4PN4LeouU339wDPW3Wq3/HRGeCgkjjL84YiMjOPrFV2StWMFVkyaEZumDT8rnQ1CZU9W0c2YvlCPH2LtgIbWvGY6i6RSVlPHuoIGIwIiRo1j06/+xd9bxUZzr2/+OrMRdIAFCggR3dy3u0FIBSpXSUqNO3YW6US+0lOJS3N0dgkOABIh7Vmfm/WNmNwl2aM85v9O+7HU+NMnszDOzM3v2uZ/7vu7rWsiYLz9j5OChjG3dhn4fvANAztHj/P72u3QfMZzEW3rwzQPjSYytxJvr1wDw44MPsGLXLqpViqPro48Q4O/nZRi43QouRdFLPCU2ikpKb3jVWB66CZgKO3YQqSjktm+vj6NpiJKMSZYIsJWweebvRKRfoM6QQUx59wMa1qxF7batyL6UQfW2bRj72ON8OukFivfsZc2SJZwHujVtRrOuXcjKLyA34xIHt+3gZFYGPfv2o/fzz3Bp2TICExNZM3c+A557xvveFFX1KnGmb96G/cQJat8zxiCdamz6/CvaPfwgsvTvaXr8Gax68126v/CM9289lQ+bv/uB2o0bEt2yxZ8e8/Dvs7BIEklDB6O6XLpapc2BZDGjulyIsgQaf6qE4ZmnPN4ff6al9K9C7xZxoijKDRuXeQWyVA1JlnzKmz744MM/E25Vxb9qHNEJVXAcO+ntpS//jVaeQFi+1g/CVYMKAL+q8dQbNICsFauwWkxIosjj8xeQCSTfdTtVa9bkxcFDyQIqN6hvfPEKhNeuRYc+fZCcTiRJ4oEpX/Lb+jW0AGoCz3w9hU27dhMdH4csyyiKTrJ0ufXuDbMsU1hcQoDVTFSY3ir6ZzwdwOBZ2Gwc2byZ7DZtvKRWSZKwmCSsZhNB8XEMeOZp3t+1i2W/z6JajSTE8FBq3HYrrR+bwMldu2lXOY4fv/+Rzdt3MgtIB5r16MnURYvYtmUbrR68n8ySYkbdfQ+lR44gCAKVOnVi58zZyAic+n2W95okUUQ2yKnx7dvgKmdjLooCpW43uQcOXfGc/pto3qkjZ5cu9/7t8TxpMWYUmUePoxYXX3+A3NwrNtW7dTiSLHFg2q+IJhOS2YwlJAjZYsbk74dksRiT740FjJ774CrRe47+L4IKKMe5kETs9hsri3j4Szd7WcQXWPjgwz8cJTY7lfr2ocXgwai5uVz6Ywm43d7Xy7egXt6GKl5H0EdRVcTQUCRFwSybCA0ORNU07uzbH9u6DfR+6zXaNGoMQJO+vdE0jdOG0mP9EUPJz84iZ+duVr/2OoM7d6EQqAskAOeBAEHEbJLRjOvwOJWW2B2Qk8Oz3XtwYf16woIDCQsO+lOTiSgInPvpR+o//AgmWcZsMhESFEhsZBjBAf4oikJWbj4ut5u+HToQWiuZvq+/Qc+XJgH6BBEZH89zP3xL/Tq1kSLCGGIN4NaqVTm+YhmPffA+9Vs3RwoMYtAdI6nTvQs7T5/iobbtmfXsC0h2B+mnTiNZrWhZWd4xPfdbEkXq33m793oFQaDHYw+zY8FCDs+aR7HN/n+i4Hj84EHiGzeusE0QBMyyTOU+fdj46ZfXPPbEzNms++BDtnzyOalz5kG5z1b1QQNRcrIRXK4yQSlR9JYvREn8U9LfrpJSZKsFyWL+Py0x6IqoFgRBxG53oKp/TkDrZoUvsPDBh384VFWlsLgUsWVzSvNz8KuRxPo33kZ1OfWVIXpWw60ouNWrKQVKyKKESZIrZDo8Tp3WuMqcXb4Ss0nG32ohuV8/Bk6axDPtO7Fx/z4AXhg0lO/GPcyhTZv4YsJjPNT9Fj76eSqnFy+mx8svMvD1V/hq7RpOAmZj/ODwMDRVQxZ1QydPqjlz82aGjhlDJHBy7ToEQSAowL9Cp8f1IADpq1aRHxiA6G8lOiKUoAA/3IpCcYmNvMIiikttOFxu7E4XfZ58kppDhpBVWEhGdh52hxNN06g9oB9iSAhN27TF5XTSuFsX2tw1mhYvvsD8J5/GmVvI8506k3Y4hf533Ekm0DYmliIB2jz/DNUiwrHGVEKN0CWvr5Y1Kg9JFOnz0iS++GgyqtOF3TD0+m9mMDJOn0aqFHPlPRRAtFhQ0M3MrkBpKY6iIjq/9QZtH30YS6U41rzxFmlLlnl3SW7egiOz51w5tigiiJLXsOx60FQVxamXT4R/sxX5r6JM/hscDsc1n0P55/RnWr7/f8TN+8598OH/I5TaHRSVlBLYvTukppKdnsaXnbqy6dXXUc6n6V+GZRFDBXhW0aIg6AGGbMIsyciShCgIRLRsQeqBgwiCQO7mrWz69RemzpnLFmAnMO/td3hny0aqV0ugaauWjPvkI9749BNub9AAR1gIayZ/hCM1FUkSeemD9zkIvNW9Jx++8Qb2S5dwuRXcih74FJXaUAqLuDc0ignLltFm0guG0JVKRGgw/n7WCtcuSbrzaKCRHhcFAevxk1SrWZt6Y8YSFhyEv9WCv8WMSZJQNQ2TLGMxm5ElibyCIlwut1GiELE7nGTlFVJcavNOIIEBAdRt2ZKE5FrsXbcWc3AIW48fZdL8OQhAlYTq3FqrNhNHj2ZdxiWqiSIv9h+An8lM2v69Xh6tp/5+rUyEpyTy8AP3MePhCaCBzeGkqNROQXEpJTaHzof5DwYZbUbdyY4vv77qaxazTJMHH+DcH2XBwqnfZ7J64rPs/+VXkocP9W6v1LYlXV+aRPrpU2QcOgSAf7s2iNfQ59DJnBradTIAmqqiutxobjeS5a+7sP4n4NG58PAurhlcXLOweHPBR970wYf/TyAIAuEhQVjNJjIPpfDFCy/QLKk6uUePE52UxICvP9dlr6U/z1hf/c77dB53P1u++paA2Ggq9e2L263yx6TnOZmSwshx41BVlYSatcjOySGpd08uzvidLEXD5HaRdfIMhSVF2J0O+j35OPeOvpuaQHJ4FLfPmo4im7DZHciyzIHfZ4KiUGfEcCxmE3mFxSiKQnhIEGaTzMWsXBxOFwF+VkKDAvGzmlE1jZzsPJxbtqAlJuEIDSU0OJDwkCAURaGwuBRNQ99X1XC6XDicLuwOJ4qqYpJ1QmdQgL8+caMRFOBfgUh54o/FhMXE8syECXz4zRT2LllGtfBw5mzdyvYjKdQLD6dRi1a0qFeX1LQ0tu7ayajnniUiubZXUvzy5wVQfOECgZUre7drmsaaxyfS/LVXkUwyZllGUNzknzmLKb4KCCCJAlazGVn6a74i5fHpwMFUr1Wb/u+/U2G7pmm43ArnN27h3JZNJCQn8/Hkybw963f84+NvaOytn35OmwlXinNpqorb4QRVRZCkq5Y4nMUliLL8f17+uB5UVcVusyNKIpYbCHZ8kt4++ODDPxqapuFWFHILinBFx3D/t9/R/LlJ9Pt1Op2HDOH8nPnk7tjzp8dN+e03ggL9aN+rDxdPn6Th0MFEhIZgMsn0feNNJjz9FKEB/pzavZuHJj6JYrOjFRdz6HQqxzZvQZRFGo0ayYB33yIsPh5HfgGv3jmKY8C+3CxGdOtB506d0UpLyT14gLMnTtD0rjuQRBG3262vajUwyTKSKGE2mTCbZEKDAvD301U20eCnIUPJDgrGHhKCpmmU2uxkZOdyITOH3IIi8ouKyMjJp6ikFBAICvQnJDgQsyyjaeBwuiguteFWFN11tLAYp9PlXZ1W7dKFgtJSxt86gikTnqD9qDuIuW0EfVq1YVTHjkya9jO1WzZn78njTJ/5OxlnUtn0y68VWn81yvRDPOOW7NhV4X4rBQUc2LGDRRMeJXfVakyyxP6vvyVn/TrcJ08RYGh7lNiudLS9UZzdsIncPxYz64mnKHI4adKvP5n791fYR/dekajUtjWNJjzKidOnSYiJveGgAsBiMlXg+5Qb3OBMWNA0FVe5DJGmqjiLS5As5r9VUAG6XoXVz4qqatjt1y6L3OzwZSx88OH/I0iiiHqVVLlJlokKD2Hn5A9pOmQIIfXqXHMMz7FZu3Zz5mAK03/4Dv/ISEIyMnh643o8XHeHy01GVi5+VgumrVsI69SBmW+/Q9MGDXntiy94ecIEAivHEtO+nZen99uD4+kz+i6CW7cibdkq3n7rDc4BhUB1wAKcAlavXU1mQTFuRUFRVCRRpFK0zlVIy8hC06ByVDhmswlN1dj19rtEN2sKDRoZxmo3cK8kkbDgICRR9AZlhcWlgN5yKUoiMRFh+HkmN1XVhabcbsjNZd3vs2jeqyfFJaUMHvcQ62fOQKxUie/HPcLmQwcoAr6c8hXR9eohiAKeapSG5uWvCILA6VlzSCxXVgD4cey9RISFYTVbCYmKoHJyHc7s34f9zBl6fvO1kVUxzET/wsR7dvYcFv74M4/MmsHuOfOoFh9PpOEvcjk0TcPmcGJzuAgJ9NN5ODd4Tuexk+xdvoJWEx665j4ebQrN7UayWlDdbgSE/7j41X8KnlKU3e5AFEUs1wl+btaMhS+w8MGHmwQBflaiAvy4uGQZVYcPAa6clDRNQ3O5mPfCS7To2oUqvXritNkZ1K079yUmEl4ljg5vvWW4o7ooLrVTancQHhhA/vLlxAzqj6ppnF+5lhNHjhCMQJu77+LY5q2kHTxE5ZhoZJOJGneMRFMUnu7clR1cqQIqAF907ER4XBW2pRwmKCKCElspA156gYxSB4qqYTGbMMkSK955j96j7iK4Ti0uZeVSar8xC3kBsFosuBUFSRIJCfSnsLhUb3sFZEmmcnR4hXJI+fvldiv88fGnpKSkcOpICg2BwU89xT3vv0/HoCC69+5L8369ERKrI16lS8CRl8dP4ycQYDJz+0cfIIaHgaax7qNPWDJ7NhPmzmPbCy8QHRVFus1GYUEB/W4bwflTp8jPK0BzuandohmJfXvrWRFNu/rPq2DH519hsphoct+9AOya8j0hsdHUHNj/mver1O7E6VYIDfS7+v28yrlOzpmHxWqlSt/e1xwXjLJLqQ1REtEU9T8m0/3fgie4KC21YTabMJmuHgT5AoubDL7AwoebDaIgEBMZxoWly/CLjiG+Q9sKAlqapqE5HEwdP4GBTz1BWHKyd/vFPXuoVKsWv058mpFffWGIaunmG3aHE1WFEFUha8dOQrt0wn76LGphIQF1avLJ0Nvoe+dIat0+EgBbSgqrfviJcJOZ05s2Yo6N4UdDxdMfCAU6x1TinOJi6MSJZB4/zqM//ABAEyAmPJIWPXqCoLF4/nyaJFSj3d1jqd2+DZm5+UbW4cZgkmVcRqre3+oJMiQvHyMiJEgvX2iad6XuIWHmF5VQUFSCSZYJL8jjvrvv5oxxjX0GDKTbYxPY+dNU2j1wLx4bd8/91jQNTVVx5eQi+ftz5NsfqfvgvbjsDmRV4cP7HuSOzz9DPpPKriVL6P70k0hmsy6TbbcjmM2oQObWbcz98ivufO1lAhKqY/Kz4iq1Y/K34rY7kCwWFKcTUZbBOKcoS2x84y06Pv+crhJpteK22zk5dx7Ve3THEhHBkd9n4nYr1L1tBKIso7qcYDJRUGwjLCgA1elEMplQFcVwM9XLVQiC9xyKW0GSJTa8/xEdn34S1elENJtQXW5D9lsBwXOsRmlWDn6R4Zj8rh64/B3hVhTsNjtW69UN9G7WwMIn6e2DDzcJVE2jqMRG4qABpM+djzs3Fzk8DAEBd0Ehi954k0D/AEa+/TqW6LIWREEQqNysGZqm0X+kHhx42e9GK54oCIiSTHh8HEpaGnOnfI01KIBByRNp1bwpwULZV83meQtIrt+ABd9/x7gPP2TtTz/y7egx3PHuuwAMCQtnyLdfoYWHs3/aLxRmZJIMdE9IoEatZI6VFCAW5tGsdStKc9qTGB1N7s4dOOrUQvuTtDFPa6BmBEgWi5ngAH8sFhMCAqpBYCxPktQ0yMkvpMSm19jNJglLjSRao5PWGgMNmzbm3NbtNKqTDKqKJggI5XoGNFXFVVKKKSICURKpe/twSvfuJaitLublZzbh0jTEWjVp1+ApBD8rKiBbzAgB/t7rj+/ZnQltWvHFuIeJDg5i+HvvYA4KQBBFTMZEJ8r6T824eEEQMIWG4UpPx1w9Qd/Xz4+6t9/GqlfewBwQQNu770KKiUFTNQRRQBAtIIqIkoRLUTGbTbqstih475/ns6KpIogCmqDg1jSqN2zAuo8+oeMj43Grqi61riqgqoiiHogopaWYg4OQrRW7fv7ukIxSiMPhxO+qsvQ3J3zkTR98uIlgs+sti+HxVVn03geg6indha+8xqC33qDHqy9VCCrKQxAEQuoko548dYWolqppuBQ3QnItxPPp9Bk9hrTzFxBlmc3rN/Dal5+z/K13WffuZGq0bEXNMXfRvE8ftmzfTmRMNLtmzGRMYAjhwKAH7mXLx5+Svn4TDe+8g/zCAj5//XV63HMP0TWTaBQZhV94BMNefoXU7duI0+D32bN5Z8Agijdv/lNf7pLRUgv6gltRFKwWMxaDIOpWVEySdJnMtobd6cLldiNJIiaTiWKbneDayfSMiEBEJLZrFy4dPYo9IpIzK1chCPo9UtxuFKcLV6kNU4A/gqEoKsXE4EeZ22x0TAxWs5niUhuKpuFwudAuk1/3CjEFBzPum6/odNttTOrZi0PTfjVEqCRdlMrzs9zv7R97hAOLFiOC4eUhI5jNtLr3bkJiozFVrowoSUgm2fhpQpIkQgL9sbncKILo3S7Ksv6653ezCVGSMFksCJJI1b69CAsN0YmYDgfzJz7DuC7dwFaKgobidGIOCsISFPiPm5gFQUCWZSRJMkzLfIlw8AUWPvhwU0FRVdxuhcDWzXEVFtCufUcWPfs8XcbchWi+AQZ+TDTpR46Qu3LtFS95SKNSy+b45edw7OgR7uvWg9Eff8Sn61bT87mn6fzMkyT06ArArqUrCMvLR5VMRNeqQVa1KsxetYJd23bx7Zo1LHj/feY9+jiNo2Mxd+5IWOeOhLdpxcmz5zi4YT1O4HhhEW9P/xUJGNirF1X79L5hIS3QMy9+VgsRoSHERoYRERqMLIm4FRWHy43T5aagpJTCklLcSplrrMVkIijAn4jQEEICA3C53Qz84H3kyEjiEqqRt3wlbgHcqCz5/kcubdyM6nRxcsZMclatxeTnpwtFlbvfmTlZUFrK4pdeJSI42Ctx7nS6dB0OkwkNTe+UuYygKwUEENOpA29u3cy5Y0dZ9NQzV7zXCpBlmt03lqPTftHvg0F4DU6sTlSVquye8u01DpPws5godTivO7wn6JFEEUVVqdGpI1OGDmfDR5/QbezdPPvgAygWC4IoIFvMSGaTUVL558Er/S0KOK8joHUz4Z/5JH3wwYe/DJfbTcaatZCdSzOg4x23E9aoEXBjKo8JAwcgSyKOc+crbBcASZQQLBZM0dH0bdWa1i1aEt6ovh50lNt35n3jOKe5WbtiOTVbtqTN888RFxWJZDYz+Pmn6VG3Hq0G9KNe/fo4ZJGFDz9KyZGj5O7dx8BPPqJN9+40BB7s3I1i4ME3X8OckIBJEgn1s3rLAP8KbpeedbDIEprThdPpJiuvkOzcfIoKi3A7HGhuhbzCEgqKS3ROgSAQHhpMSKA/oijoiqaKQqHTzeAPJ5MuS2Tt3EXzHt2YNulFjqWn8dazz4GqEhEfx/6NGxCuoj8RXL8+R3+dQd/XXkb180eS9ACpxGb3GrOZZH2bW1VQVEW3Yr/sWfV7+y06jBzJnCef4sLcuShFRVd971JQEMHVE/nplr7Mfnyid3tcz26IFgvrPvz4qseZZAlFubbQlwe6YJkIAliTqlOnbVs6T3qekMYNqHb7bXqrKeC22dEU5R89IXsEtOwOJyUlpdhsdmz/RjvwPx2+wMIHH24yOF0KoTWSOFVcyJ2NGyGHBHvr5O4b/IL3b9KInF17yN19wLtNQzf/EgUBvzp1aHpLTzbs3FEmygWsevk1Vj4zCb/KsYwcOpT67doS2b0rGlBUUIggCNh37WXEJx9SdOESW3fvYfGy5fiZTXw37hFWzZiBpqp8//NUPlu/llovPMNh4N4XXiK3qAhHUTGBQQHERoVzftFCzqxced33oWoaBUUlXMzJI6ekFFESMJtMBAb4Ex4WQlhYCBHhIVSKDEMSRfIKi8nOL+RSdh45BcVk5xVSUFiEv9VCdEQoRZrAwFdeYfG6jez47AsCgkMYOWgI/Vq0wnXsBJGdO9HtrddJXbYczVVR0jqwegKnT56i4OxZNi5dgp/V7FUdLbU5jHZVXSpaMK7d5Vau2l4c0qQRg998nTPn05kxsWL2Qi0t5fk27fjt4UdZNv03kvv0YvinH1XYp8mYUVSKirrqPdM0DUm6lqZm2T5e3oXBVWnYvSuFu/eAICAJZVOPKSgQt93hdUL9p0IURQID/XG5XEanyM1LYfQFFj74cJNBVVXyTpxmcNeepObmE5SQ4H3N4775r1b71ogIpIgwZKfNu00w/udZyVbp2Z1be/Yk98NPvWPmnE2l/dgxJNWsQeWkGjQZOoKL8xawddovVKpcicL9B7mYlU3+/oM06teHu774FJsGr+/cyS7FSbcxY3iwSzcqBwRwZu58Vkx6ifcGD+PReg3Y/+t0XGfOUHT6DGcWLuTAmtU07d6VAL8bIwSGBAUSHBhAYIAVRdO8LH9BELCYTYQE+hMRFoKfxYzD6cTtduN0OtEEAT+LBYvJRICfBVdgEPOdpXy/Ywc7Tp5Azc/lyPlzZCxZgmazsWryR5w/fETXxDDgmYhlfz9CoqKIDA/3SpVbjBKI3llimJhJMqIo6qURVfF2rpT/p8gyrR95iHbdujL/kce855r32OPUDotk5OefMPabr2j96CNXvR/Z+XkVjMU81+lwua+r+Ok5v1tRUFTV2/Ea3LABJ/fuRwBEUUA0tDwQBGQ/K4rLjWqUef6pkCQJP6sVp9OFKF6ptnqzwNdu6oMPNxkC/f2oFBWOqqp8etsd3D56DBeysggQwFQ5juo9u1bY36uIaHQUeODMyeHEwkXUuOuOK84hGr4dIOA4cZL9P08jx25j87ZtRAWHMOG3XyA4GIBZb7/H5iWL+WjDetJmzqHK4P4cnzmbWnfejv38eTb9+BMbduzEVlDAYaBf3bqcSUkBYPjoUZCTx9nz56nXsiUPfvsNAG/d0ou6PXoS2rIpbpdCUWmpPik6dbdNl1tBVVWvv4jFYsZiNmOSZfysZmwOJ0H+Vu/r5WGzO8jIyUcQBBxOp6FQqR8XFhyIpmp8eett7MrI4JYGDTFLIoWiQNUaNdk4bwHd+vamy9N66UEQBI7NnEOtoYPIPnqME7PnkNC8OWsWLuKOr79AUVWj1fVK63hV01AUBUUrex/eZ6Tp/BHdVE7g0Jx5XDxyhLjKlcjKyqbL44/Cv+jAOLt4GUppSQXxLpdbIaegmKjQICSp4rq0/FziUhRv9koURNyqgikji7Or11H59uE6+VdvU/Ea4akuF4rThWTWrdb/qVBVldJSG1arFT8//38WG/U/BF/GwgcfbjKoxipUFEV6DBtKZJsWNLn7LmqNuYtg1c3ROfOBMtMsxTDOUsuZaKmahhgaSnybNpyaMQslN6/iOTQNt7Fa9atVk4aPjGfHtm2sB2YXFpCyfoN3Iupx+200S0pi8RNPEtW8MSfnziehux7cpMycy5HTZxjYoQNtW7fGAuxKSeEYYAdSN22iabUqJAQG4Dp12nv+zs9MJLJNC2RRREUjJCiQmIgwKkdHUDk6ksjQYIIDA4iJCKVSdATBAQGIooiq6pOhpmoUltgoLr3SvtzD/LeaTYacuD7B63boErJJ5o4pU+hVNYGw5NrsT0vHmZtPZEAAsstBfmoqOz79HOx2NIeD0tNnWPjUM5QcPkxmdg5n9h8g/cwpXBkZXvM4Xe+qYkZCoKyrRdM073NSVBVF0393GxN8g2FD6PniC9Qdezedn30azWL5l5+Tan17sW/zlgrbZEnEz2LCWS6z4LkeVVO9nI/y7aeg82+ObtyEFhQA4L1GQRDxuOJJZjOSyfQvr+vvDkEQMJtNOBw3JtT2/yN8gYUPPtxk8ExAALWbNSXn2HHvaxG9elJw+jQXN2wGu521kz/i5MJF5SYR4z+abtRlrZFI0oihnFqw8KqeEKqqr0gDKsXy/LKldAc+f+BBCrNzubB0BYrDwdzPvuTOH76j+7hxbPx6ChSVYI6N5eDPv5CRm0371m04cy6NrvfdiwacBPKBwV06U6tVGyZ/8SUFaOS7XIxv3oJfnnyKaaPvMeSzweFwoigKoihiNpmQJZHgQH+iw0MJDgzA36p3J2jgNfgKDvQj2F8XaiqxOXC6yiZSURSQJYOUKAoE+/sRFxNJWEgQoqhzIs5s3oI9NIiajZrQvn598ktLuXj8JH0HDqZB1y40GDGMgk2bWfHWu9S77276ffAu8UOH0HjECIpzc3hsytec37yNY9OmIQoCiqriUtze8oKqqmXlkeuwHTTjebsUt/FPJ33eKJr16MGpOfO8fwuCgJ/FTLHNUSG4UFS9FdZltMOaJAnZyEromQuR2kMGsWP5iorXVy4I8QRRivP6HSd/dwiCgOn/gwDp34EvsPDBh5sMnsyDpmloVeJx5eRU+IJv9dQT2ArymPHo47QaPJCTW7fzWdceqBfSKZvOKFvJiyIJvXpxbu6CCuc5Nv13Ts6eq3tjCAJ+IcG8vnY1RefO02rMXRAYQJfuPRl8z90IooC1Vg16vPkGhw4f5LNOnUlZv469e/eSnXGJ+MQExt1zL4WAp/Cyeu06Yuom8/SGdZw7l8bCjetp2rIFecWFJMfHcei5F3C7FaNMYQGbjSUfTAbKLMo9CLCaCfK3Iooi6UeOAPpkabXogUixzYHDpQdOVouZSlHhRIYGE1taQtH2baiZGRz67XcEQcCtqGxfv4HWiTU4t3Qxx/buJSGhGjU6tufFBfOY9OFH5O3czfr5C6mRlIgpPFzvngDi2rSk1UMPkHcmlcQ+t3Bo01YwDLpUIysAGoqhaeEp50iCiCzqyp4eHxLQcwGiIFZo/xSFG//ar9a3Fzlp6Sx/+XUubtkO6F0hwf5WSm1OCoptqJpWQTlcUfXyjChKehZIM65XFIivWw8uCxy8OiKqistmRzL/62zKPwHmf3A559+Fj2Phgw83GQRBICYijAA/C4qqcnr2PGrdNvxKQyu7nZOz5mL2sxLbrQtqYMB1x3WdPUvxydOEdevChbXref/lV2hduw5BYSHUrFeXqKQaxHbpROnFi5z8agr+dZI5uWI1Mc2bUv/B+yoYhuz8+FO+njMHC1BdNHFOdXEOsAEK8PYtvbh47hy1W7UirEocv/4+i9ohwRQ7HdSJrUSBw0FAcQkf7dpJ7xq1GP3FJ7S5Rfer2LJlk/c+lIemaeQVFlNicyDLEgICJrNMWGAATrebUruTQH8LJkMsa//vc6haUkxJSAhR1atRdPESkbf0oMSlYNu/jwFPPMm8zz5n8CMP08FsIUSAPxwO2gNvbVyP6/RZjk//jeTbhmNNrl0W3Al6MKBpGgWnT3N06UoKbMWEhYXTcPSd3uDBA0mSUA0CpygIqKo+kQPeIEKPoQSvZ8mfFqJyu1n17HO0uv1Ogpo2MspkGgUlpQT5+yFLYlnmAT0oE4334elaUTQV7eJF9s79g6bj7/MOLQCyKIFbz6T8Xc3H/iw0TcNstv7z38hfgC+w8MGHmxCB/n7ERIahKgruvfuxtmh2xZf5qam/Un3IQISAADTApVyfsa8UFLD3/Q8JjK3Mgpkz6HfP3TS48w5kixWhuJiz6zdx6cABcpw2zqWeo1r9+nR+aByOs+fIOnyYhIH9DeKhBqWlaP7+PN2xMxlABnCrvz+9H53A9Km/sCo9jXZ+AWTaSthnnH/D8qUsnPgMp0+fpN+do9i5YD5fXbpEJDDr22+w1q1Dm3Yd+PSuu2jx0IPYUo6QX1hApdat9etXVTJz8ikutSGJki7rLYiEBPnjbzHjdLkpdTjJPXSIkxs3Url6IhZJpNaQQQDk7tpLaEQEJTHRPDVwEPuLi6gDHAHWT5vKmp+mcmD1WvJRqFO7Nn0fuJ+gJo3JXL2Gyn16V5DG9lyP55kcW7SY8KgYLh48gIpG4/vGIgoiiqoYgYJYVh7R8AYW4NEXEY3W1TLPkz87eW+c/BHt7roDMTrae31FJXaCAqxeJdaK168Agvc1t0E0nf/kM/R9+gnMMTFogCSISKKIq6gEc1CgV430n46bObC4eRttffDhJobN7sDucGK1mDl26DCNWzav8LrjcArVunVGDAz0EgVlQcSl6avKxU89hyaKVK2bzPnDRzGjcXr7dloOH0ryww+Q/PADAKiAW3EjBvhTuXkTdq1czrBPPi4jG6oqpppJ2Ox2Dn74CXUHD2T1zN9ZuHgppUAB0CUmloLsTPpOnEhc545cevddNGDIbbeyb8c20g6nUANYPekVuj/yEKe3buenKV/jUYnIBbrcdz9Njb/PnjvHwjbtMAETHn8SWkPh0WOknThBjaZNMIcE6cqbThcOpx1RFLCadYlvQRBYuGwFraKj+Pa77zEV5tNh+3Z6v/0mgS47o24fyfhRoykp1kWpGoaG085qZstXUziadh4FhUpAg6ZNCGrRHC2/gJm//MqYagmE1a/rnew9HRUIehtvRM0kouvUIap1c2zHTpA6az6JI4YgiiJuRUHAUybxCFPpbb8ehxJV03TfDz0t9Zc+M/7+AThdLjy9JJ5nqHuIacZ1a2hGGUQSK7rCypKEpIm0GTCA/b/NovUTj1Z0fRU9rJj/P+bi/x+yLn8VPo6FDz7chFAM0SUBqFatWoWVZvGJk1w4nIIcFwdQlq1AX13m7NrDyVPH6ffumzQcfRdtbh1Gj/feosWQoST36nPFuTzdCc7SUhJi9TE99X6TLONIOUrpmVTmrVpF19FjeH/xUoKBAODeNm2o06gJL65YzuE9u5n+8ATuvfdePho1itPbtpGWkUUDIKFaNebt28vL9z+ItbiY00Dd6FjiwBtQvPnGa0QD4qlTnAROAGt+/Em/xhIbr7/1Nr9NfJpRvXtz8NNP2fb+B6hnUxEFgcISGyU2B6IgsHnFMp7+ZRpjR4/mEvDDhg281K4DU9+bTCRQ87ZbiRUlBkRGUpKfizk8gne3bKb43DkygE4DB/H9bzOY2KETZ1avZdioUXx1331ohkBU+Una05UTXruWnsEAApJrEVKjOgd+mqoLZgkigqB3+ZRxKwQjEyB4xbQEwdAp4a9Nes3uGcPBpeXJl3qGpbDUhtPtxul2GR1HgrcN1vOsPT9FUaRqt84U5uVRdO5cBTVWySTrSqeXaWf48M+DL7DwwYebFKV2B25FRTTJYNflh7WCArJ376H6iGHe/QT06oQuxKQRkVyLRm3aeV8Pb9YEgKaPPoSpqICj03696vlMVaqQPGIwl8p1BhycOx9XWjoJA/sx6Y8FfHjnHSxevIjuffrRr1Yym7duJSa+EpKfHz2ee5aA5GS++OZbrC43TpOJZk2b0KpDe8ZN+5mPZv/OdmDqrFlMeestKnXvRgJQCFQG7pn0EplAkdPF8E6dOAksy88BILRZY1KB2ampBAIfrViOlJ3Jivc+4NW+ffATBc4vXcaOp57DH3i4ZUsq9exBtUqViABki4VqzZqSBnxz3wO4VYWF2dn8AZxKOUw+sAloADy2YD67gIbJdYit3wCh1EbVuEpcXL6qglrlT/fez7p3PuD4bzMpSUnRV/eKwpTRd7N57nzy8vL0bIXglYQoe2bGJK6oZVLqAmX6Fn+pBG420+Leu73BjyTq+h2Konq1KDQjc+K1l7+s/dSD3q+/wslFi7m4eStgdIdIoi6S9Q+X9/bBVwrxwYebFk6nk4KiYoLq1SF/127COrTnzLLlJPYryzp4uhFEw3Zb0zTsWdlUq13rqmPKTRpxcdUakp1OuIwVr6EhV60KqWc59NtM6g7qT1FaOuYH7sHucoAG0VUTOLd4MUFBQRxGZSNQ5/BhmqBPlgOefJy+jz9KzrwFZK9fz9ED+7GIEo227KBy25Y0BRp17EhpVhZvTP+VKRMncnbbNnKKirGEhvLp+nV8nZkBmRn0N1voN3o0p2bPJWnYEH4eOpSTZ8/x+q6dPJuYxMcnjhOHUUrp3oOqQE3ZTER4OFEJCfTt3w8BuK9xE9bv28vJxYtpF1+VSrJIQuPGSPv2US8ikra39ODI9N8QgAXAyMAg6rZowZrt29k/7WfavPEa7bKyWPvjj9zaugXLvvwaCYnIyCi6Pf8MqCppK1ZyeMNm1Lw8+o29h0od23pFqDRVqJAV0DtByrpCyk/RiqoamY2Kz03Tygcg189oaFoZf8KtKPhZzN5MiKiV8UREUUIzAovLx1OApg8/xKZ3J1O5XRtvRkywmnGV2rAEBf7lks1/ApfrcPjw5+ALLHzw4SaFhp61CIoIIzflBIdWriauaRMIDNRfNyYbURBw5+VRcPY8WefP4idKVB/Q75rjdnrgHk7NnEu1Xt2RIyOveP1sWjq7Zs3FrGn4BerCVACaqhHbvTOyLCNLEq006L16HZfS0sjeup2otq29pMNsTeOXC+nUBVJUBe3ZpxnyzDO0b9eO7Vu2snXDBgD8D6ewfNMmPly9Ek2W2dJpna5tAQweMpTvv/2GzcDCYyd59I8F5BvXeP70GZqjZxneHjOGF3/6CRdw1O0kIzeXwrXraA8kmSwcu5TBvXeO5uSB/Rw7sI9DQJjJwq33P8jib77mu+m/EQtcAOoAPxQX0XrtGt5dsZzU2XM5Me1XKnfrTNHevdhz8ygtKKRx+3ZEJiXqFyOKVOndi3ivEJWGopZ1YGiahiQIXuKmRplauCDo5SvKdZyoqopgBALlPwtuxe1tXdWPvfqk6tlcYrNjkkUEUTe208fRjPKMgKRp3q6Uy8dSNRVV1YivVYNdP06l4ajbjeMFRLMJ1e3+n6tv+oKLvw5fKcQHH25iOJwuSmx2cswSTfv3pWrLFoAnqNC8k8+5xcvY/c03mBSNyn16XXdMMTiYpDtvY8f3P0FpaYXXNE1j5ddTSM3JotrAflj8rd4ltSAKhvqlhmJYlEclJZB/6SJOhxMlPd1LGDyzYzcP10jiwUEDmTxkKFuBL959l2Fvv0nnTp3IBqoCXy1dQtekWmx7532e6NSF8+iE0GqxlZi1bh2dO3UiHsiNjSYfaGFcZ2JybUqANYsW0nrMKO7r0IGffp7G3R060QB4Z95sXluzimJU2teuwdkLafgnVec8kA7kuBzMnjeXLUAoUB14KqkGxcDCqT9zBujU8xbmLFqEWFyCOTCQ7Qf2s+GddwkNDiAqIYGTe/fjcjrKnoemGa6mqpeoWf6+quX+ud0KDqcLp8uN0+XShbEURTcyEypKankUVlVNo+T8eTa+/CpFZ85c9xl7iJl+FjNmWUYWdUGs8noa6nUmZs0wVDtz4ADNRt2BSZQweWXLdeXT/zUq+vH68GfgCyx88OEmh1tRaHLHbTguZlBy+DAAy158mZfbdeDSpi3s/fYHYtu3RagUR9KQgciiVC7Vfu3VXN1BA1n24mvkrNPlu4ULF0GFvp06kQH8/ugTRIkii156TV/hGpLYkih6GwOEuDhi46twLjSKoxs2s+X3ORzcf5RFmzcQ16QFBw4f4fe5c/hxyhSeffFFXG4Va1AQffsPYPJP0xDCo5h+6jiuoGAuoretNo2JJS42huS4yuw7dIg04KPvvqU/OqHzTiQatmzJXmDn+5O59NM0Cs6loVWuxKWcbPYCJ5atZPkHk0lzuUjPymHP1u0smzePPCDMeP/pWZl0FE30CwrDEhSEHBJCVeD073MYUlMvJdVv345vpv9KxvqN1E6qSbYo0fnBB9j422/k5WQjSRKK26WrZnpbS6+8555J3BOUudxur3S7vl01vEOEsgxROR6DWlLMCx27MHnkndTt04vgxMRrPlf9GsBkkim2OcgvKqXU4dDJvZKIKIpeg7Sr8SvA8JIRBWo1aoIoy95jPC64itOJ6nbjtttRnE5cNtv/OffizwiJ+VARPh0LH3y4yeFvtRAbGQ4OGwc/+JjGEx9nzadf0mX8A3w69l6SmjalalwcIVFRVOt9Cxq6XTfoqW5FuzqLX9M00tdtImX1Ks6cOkWw2ULdenVZ+scfjP3yS2Y/9TQhkZHcMnoUlW7pUWEi9ByvulxcXLqCY1HxxESEcX7Pbt7+8hMAnh02ElNpMWcuXOTWF54lPTUNd2YGuRcucjztPO1GjcbpcjPpwbHYgPqAP5CJLgsO0BadQ1G/bXsyt2xiMzAkKIJbPv+Mz0bfTq2q1Tl67gwHgV5ApaqJzDl3miD0TEQWOjn0qfYd2LNpI1JUNOlZmeQB0UCV4HBshbn4x1UhxM9KVtoF0u0lZAFjWrUiv9SOFuhPeno6VWMrsWbHdgb37Ue1qCgS7xnDucVLyMjIoOU9Y71Bhd4pouhkyXL8F7fi9naSAN5WU1HvWUXVNMwmk9eB1iTLuly4283sx5+keY9uJPTr61Xq/FdQVJXCYhsOl5tAfwsBVl0x00PcVFRdJVQSpQrjeTIkGnDw0y/ILS3hwplUatetR0S1eBKHDEYpKOTz8Q/z8HffIppkVJcbQRRx2+2Y/P0RZOkfUaIwmSx//4v8L8AXkvngw00Om91BYXEJon8AYkgoG596hmZDBiAGB/PY7Jn0f/5ZSouKqNb7FkCfsEyShEk2XeH8WR6CIBDfpQM9Xn+F+6dPY+TP3/PbH39gB6KqxVMQEMjtX3+Jq6CA7PWbrjqG68hRjm/ahHTiGPu/+wYxPY2RcQl8+Piz/DD7N0qL7dTvN4C0VWuxBQSSfz4dMScbpbiYtD8WcWntahohkgzsA/xCIxnYrpN3/LOAE5i9ZROlgAkIDw7mx9G3sx/IcDmJj4gB9GDk3LnTFAJVgPaxsWQCQyKjyc7I5AAQoGrkATFAp5atUAtzSQViXE7OnzyBKsBO4OeF8zmTlo6Ixidbt1KnShV63XcvCZUq0Xxgf6Lr1cF27hwJfXqz748lKHl5+r0uR4RUNVVX6RR1gSldPltv99SzEno5S6VMMEtVPV0b+vvXNI3J3bpxaNcu4nr3QjW6SG5kwSmJIqFB/oQE+nlFsC5vLb2aJoXnNUkUMYWF0+2F57jz269pPGEcIgKnf5/DrOde4OEXJyH7WRFlWf9pNmEKDNCzF1fxpfHh7wNfxsIHH3zAYjIRGxWOeD6deW+9RUKzZvj5+VG7V09Uxc2ZpctJvnesd6XpUW/0GFwJ6BOcp9Z/LWx4/0PqNmjIJ2+9yYg77qD+ffcgSSJHfvwZV14ejZ543Luvpmmc/v4HYrp1Y9anX3D7C89BcBC7f/6VmNq1WPnbdHLOpfHgL9NY+eqrhFWO48DqNSwqLUQElvw8le3zFmL1s1KpWXNmfvMVeekX2F1SRDIwaMRtyA4XZ/fs5Nj5c1iBNcAI/2DmlxZSip7RqFQ1gTnnUqmFzpXYgx5Y7AEswO1WP/bYbSQDW4EIdGGwYvQ2153oTqyBwNtdu5Jhd7Jn1y5q1a7F8oMH6FUrGVAIT0qiSkICuSUlVK1fnyVff0NoYADFTieZR4/yyE8/YKlZA0EQ0Vwu8tavJ7hLZyRR0hU4EXCrim78hqFdASCISGKZZ4gekAiIhirm0+068MaKpV4bdU9J6lpBY/k5w5OdKN/54fl5+X5XQ0HKEfwVBbl+PYOUquilNvHaa17F4dQ7jG7AofV/DV/GwgcffLhp4XC5yC0oRIuNomH37gRUrkSDu0dhT01l5mNP4nDpOpaelSZUdKYUBEEn8EkSoiHR7OFfSELZ76qmsWP9eu4cfTeV27XxLmjr3D2ayq3asvzFV9j91TeQn8+m51/Ev359/BKqMmryO1giw/GzmBGLS3BcSKdqdBT1oiPZ+f67yCLc8vTjDLhrJEHoE/u8d9+hcpCVoLxcEjLO0yYyElV18coDD3AC+H3mDA4sXkiQJDGgUhXOA24gv7SQFiYT0eidHP7Ge3cDx9HLH571sgM4YbexH5iH/naigf3onNSD6MHF09HR1AZqv/A8DXr2pNugwRw+fJjXP/yQY3m5VA8JJ8AvgKShQ5g9dRqFJ07SaeAACouKuf39d+kzejSfPfQQT7XryPi27XmhUxcefekVnuzQ2Uu8VAy1TlmSjOfimex1d1GT0W3jkU1XNZWC06c4CBQtW+b9LHjUM8tInWVaFF7xrsv4Gy7FjdOQfC//mbicE3L5OCF163Dh+EmvWqhJkq8ZhGiahmoYr/nw94av3dQHH3wAwO5wcn7XHkx2G1bJWHO43NTv3AXFpbDkxVfIungR2WxCE0U63XEHca1b6kS8cmROj0mXS3PjWbR6LEAkSaJK1XiOHjhAj+ZNjBW0vlNE25b0bNuSc7/PZM7zk6jRqCmxrVriVhXQQBLBlp7OxvVreGr+HOpoGkuefJbjGzdSrVFjtk75jl0zf2fBwgV8M2YsaSkpdBs2lIPHT+LYupMDqWfwC4+g1W238rnVyrFt21mxfRuZeXlsKiigCOgKNGvTln2799C2chS9mjfjwP5DhANffPQRfv5+zPriKxRR4NC+ffQHmnbrQcKZMxzPyea9BfO4o3MXaqEHIQASsC8zEyew7d3JhCfXZNXG9axUFW7LzqZmaCjnQoKxnjjNsO49uX/QILJz84iwWLj9nTeZ9egTtOzbh4krV3gJhZ7M0Nj2HZk24THu/PQjr6upaEhjO91uVCOo0I3BFC85VhfWEghISCAa8G/UyPs50AylVLxetmUuqbIk6RbpqoIM3iDTw6O4vv6FPprHwl5EDz4CTLLxGbla90i5QAUBl82ObDb9z1tRfbg+fIGFDz74AOgTv6gqnDl5mq5vvsq5ZStR3S6aPvzgNfbXDPKgMdlRzgLb2K5pulqnPrmpNO/bm9kffczY775l//c/0ahpE0DXZdA0FQ2Bw7v3MvTzT1n55tveTIgn1W4JDaVa1SqAPhH1eXUSE/r04+T+fbR2uxnw7DNIVgum2Fgef+lF1NAwWvU1E2w2cfybKZTmFXBh8WIUm4PUAwd4/u23MLncnE89y4q1a1l45jTq1i00Sa7D6cwMQmvWJHXhIgKBVfMWICtuBJeLGkFBjDcHsMtZwoV9e9mdk02dqtXY9O33/LpkMZ379AUgGb39dAUwGpi+YilJO7bTuG0bDl68wA9vvUXL2smYBI03Du4lAYirWo2T27ezc/MWhvhZ6fXII6SuXUPRseOEJCfrxMjMTF4YPAwrkFS1OtlbdxLZpoWuY6GWeXN43UwNwqag6YGGKOrupKfmzad5lSpI1atXfLbl/uv5TdFUBBVvsKhqKhKit2zxr8iUnlKHqmloioYoy5QcO8bmjRsZeB1dFJeif4YEj/upyXTd8/jwv4evFOKDDz4A+koysE1roqrE4zx+AiU7k4R+V3p/lEcFtUY8aXRPwCF4PUFAL4kEVInn5JGjiIKAv9WKqqleXQbdU8SNX1J1FJcLt2KMI4pIkgTFxTx+S2+0woKyCwgM4tMN62jWsCEj3nmTMytW0alnL3r27UPqyZMUnj7Day+9iBIdSfPuPalXvz5IMtaEasRUisV+/BSH580nxmbn8SlfMnnQIFIAm81OrWoJpB45xojbR9JCtlCvRQvCKsWiXbzIjB3b+cVZgmyxcD4nmyIgIy2NjTNno5TamPOLLms+vENH7z3aABwFVubnMmvJYoa3bEnDGjVR7TZWrlzFYCAY+PzTTzh/6SKJCdUIr1GDDTOmI8dWIrBWTW9ZgshI2rVvx1ebNtDuqUe5cPQIP4y+F4y2UqGcqyhamTeLohpKmEanyLnjJ3jgx+/03YzyiOefd79ylBl3uY4TVdNQCgsRBOFf6l4YJ/BmtDTjs+JfqxatOneC65AxTZKkl9MEAcnkWwv/E+ALLHzwwQdAnz/yi0qoMmgg37/5NtWHDf2Xx3gdNY1JzGOapW/0OG2KRkukxvt3jmbo3aMBiKpVk7zN270rYA/a3jMGJJHo6Cg09FWuW1U4tXYdu4ETly5xYeUq/RSKG+XMGTq1b8+k/gPZduo0g2Irk1FYSEzNGuxbsoRuSUkc+uZbHEVF+EdGYLFYKb54gSxVQ6gShxgezoW8PHZ//jU/z1/AXUNGsujsGcz+AUS1aYdcNQHBbMGvcjwrl63glF2ha/uO1AdCZQvp6ITNzarCcpedO4cN48COvfzw/mRKC4soBhLQuRaBeDpKKhFbsyZRsZXYfPYs/Ro24gxwADgEbDl7lr5vvsZPz79ARGAwtoxLzH7sSfL3H9EnWEkiKCjE4LxINL3nbnqOvZtv7n+QN27pXY5A6ymPiHopQ5S8racC0Lx7d47OXVD27AwhLbei4FIUHG4XiqZ61Tg9MEkSJ2bP58VefZg7fgJv3HEX2z75jNML/7i2doWol1Iw2mB1WXCI7dYVbf/Ba37GvG6tDieCeGOtsD78b+HrCvHBBx8qIOD0KbJSU2k8dvR191M1DcWo1YuiaBACtbKVMnhLGB6PiqfbtueDrZu9E8/UMWMZ8vxzmBITvNs82Y6C3fuw5xdQuUdXPQ1vtzO6Z2+mb97IlLtGEx4VSUJAEAvXrObuSS9S9ZZuoIGqqKSuWcvdr7/O3A8mE968KZM7d8EBpAF9+vbBYnPw5prVTB52Kzv37ePs+XPE167F5gP76diuA1EWK5+tWUmDiBhycjK4ALSNiGFLTgZhQHJ8PFvT0q64J/2iY+jZ6xZmTJ3KCcBs/DsDtETX0KgP1AiNwpRcg/e3baUHkAIMatwUweXi88MHeaxaNT4+e5Z3Bw8iOyub/m+/ybkZM9m3ag3xzZsRXyWeo8dP0nXiYxXOrwE7vviCNX/8waAxY6k1XA8OPV08nnuscyjg+PQZVK5VC/9mTXAprrJnAHiYtaIgYCou4ZfHHqfo7DmiaicTGOjPqu07+HTLJm+GRBAEDs6YhWK3oRYVs3blChq2b0/38ePQ/PwAvZyilCNfmiRdSyN9/iLiBw+44n56+B6KpoJbQdLA5O933c/l3wk3a1eIL6/kgw8+eCEAwU0bc9ZQ4LyRAzwdCNplQYWHzOeRB0/57XdKoUIAERAUhL2ggPRZc0kYPoTs9RsJb9MKTGaCmzQi9ZsfiL+lO4Im8GXP3gyKjMClKIz5+gtkf380VaPxKy96zy8gIMkSiT26sbxVCzb9MJVuSdV5Yt1aSg/sZ/HHn9H/madRFJXcU6epXiWO4KhwoqKicVeJo82GrZg6dMStqLweVYlDc2bR9e0P+P65iTRProW4OYOY2HiqxldDSUvDiplinOwx3rOam8/7U6fSu3U7tmzbjD/gmQbPoWcuAI7nZxG3LZtO6OWRzlHRhBYUULlDex7392fZzu08HluJmp064r//IFnLVlKUfoEGzZtx5PQpYmrWpMuTj6IanAnQgwEBaDV+PK3Gj+f0gkUc/uU3Go6644pWUEnSCZxmq4WQpo1RRAFBEa6Qsd7+6RfsW7WazOIiAoEWAwcRGhbCMz/9zA/PP+f1/JANwm79W4d5u0lqDRmAqaCQnVN/odG9Y68qka2oKqIkkZ2TQ/w1PmKSJKK6NTQBNPXqpmY+/L3gCyx88MEHLzRAMJvJzsy8gZ01Q5rZM7FpFXQNoGwiEwWRHcuW8fmWjd5avoDAoE8+QtM0rLHRpP72O+dPHKdpYnX84+LQNNi3awdN3fciSCIbgGmzftfJoFar11Triqyrsd0aHEyn8Q+wb/Y8AoKDqNH7FoLCQvm0/yAeWTiP6JAQUnbuIiw6isOpqVQWWpCecpD4oCDiE+JJuZhKidvGwSlfoACVSkvo3q07Jv9A/CrFUGXbZlR/M6dKnViASkCp20E08M22zTzdoiWHdu4kB40cdEfPAqAEvQZtQqJdi2Y0PHAAISqKqSmHaZh5icjYSoyu3xCpahX2fvMdfnXr8u1HH/LCtJ85sXQlRaWlkHqKJY8vodeH76OiGh4g4MkyCIJAUs/urHjhZXbm5xMRF0fSsMHeW+TJMFTv24eUn38lrn5tNq9cQ6fxD/Bcv0EkxMaSdukSLWrWpPuYu6g3YoS3hAKwcuwYQA8MZMM3pPzzRhAwRccgxMSQ5HCx5vW3iK+ZRM1hQ0Aum3ZUTcWtQGDA1bMQguEJL0sSLk1FcTiRFQVB9k1df2f4OBY++ODDFahbuxZTHnzo+jsJZROUBhVsrj1mWJ7VpSgIJCUmcWzuAl3EyTDUcqt6mttaOY6ad95OYnJdAsJC9bFFgRGvvoKr1IbictOlZk0o55apaXC5GJdm/M+zODabzTQcMRRNljny2yx6ffAevXv1omenLrx6YB/OkhJyc3JYsmU7KWvWcvjkKeyHDnBx915OZ2XRtE1bbG6Fc8C6vXu4cOggixbNZ9eK5dRo3Zom9epSDegTG8s97drhAmKB4cDMnTuwREdTt3oiCej6F0fQL+0kUK1GElGRkfgnVeeblMOcB06XlDD00QlE1a5JfkYGH6ekkBgWxoi77mLfwj+wVo1HLS3l05+moppNpM6cpbfxFhZ6BbA8k/sP4x+h43NP0fK+sZjCQ/n13gfA6fTeK1EQwWrh0rlU7n3iKRYtXUrPfoOo5G/GLUq8tmYl/ad8SdKQwbqJ2VX0I1SvdLdx/42g0eO4KosS4Y0b0vXF56netTObP/mcSyvXXDGOJptxnD17zY+aR1FUsJhxO52oik/L4u8MX2Dhgw8+eOHpHgirEs+2/fsBcBw7dvV9Ka9bUFbe8IxTfpsGaP5mFLsdSRSRJdlL6pRE0dslEFi7FhdWr/N2LQTEx2EO8Edzu4kMCWHnL9PB2Pda7pMaugKDip65kGSJWj27U6tfb+a98x67T5/GCUQBr+3dTWZBAW0b1UcpKCKvII+T58+Rk53Fz0eOsGDrFmrExzEgLo5q0dHkZGTQp0VLQs1Wjh0/QdrxkwwZM5ouXbsRFleVzUCLBg0JEATG9enH6cwMzp05TapxbSK6qNbQ0FBWnzyGtVkTgmJiqGy8/uSgQeSlpOAqcVCtYQN+/vJLNm3ewh/bd/Dpzz8juBzU79iBu24bSYPWbdm2fAXpW3fweJ9+TB33EK70dFKXruDErDk06dIVa3Q0+PtTtWsXhj77FN/d/wDj2rSj9MIFUleuBSApuS4y8MGaFcz94Rsm/PEHD/3yI2CocBp+MNdSVL28LKFpGpKkd/KUtaKCHB1Nuycfw43Amvc+YsVb75G5czcIEBgdhVBcctXxPZ81URRAlFAUVe+p9eFvC19g4YMPPnghigKCprFjyzaqA98PGc7xbdtZ/85k3h08BNvOXRz+/geACqtjtHIaFuiaFIJQkcS5at5CwqvFe7eLomjYbRt6CwhENm1CcLXqHJsxyzMsiAKqojL4g/c4sG5Dxes1siGedlfPPw8UQ5USQcAaHsbQF55l+KMPc0dyMtNm/k4Y4HY4qNG0KQmx0WhAz9tupdWouwBdObPF4xPYm55Os379qZqQiM3uIOf8eZbm5nCsIJegwhJmTv+Vr2b+xjBg3cEDJLdvx8kNG0gMCiYE3bAMdEXQE8CC/HwOA0dWruJIbh6Ng0NoHRqKyz+Q2IaN2LtxA9bAAPavWcualMOMumcs3y/5gw2LlmJBwFVYRHy7VrQbNozvn5rI5MWLuOv9d/n2+Um89/pr1OjVkyaj7qhwr6w1anDvTz/So21bRg8bwc+vvMTC5ydx5Phx/NAn78CEBP2+Ipa52JYLHCRBrMCj8QSG5YMLSZQuCzoruuDG9+hC16cfp+fzT7P+52l8c8/95J06xaXDKVwNmqF/oWkgSyKCpv0tbNV9uDZ8hSoffPDBC0mUWPriK7Rq2pRU2Uxk9QQajB4FQIfs0aRt34nt4kXmPTaR4OAAur32qjcj4c1d6HURNGOVKxk1+AwgolVrVFX1lkfKp841NCREwps3xl1SwKWFi6k0sB/Fh1P4dtLLBEdEEh9XCVEQy9pcjRq8JIlebQWdyKkHOKo3gwIZq9eiFpcQ07gh8RERpK5aS/datfn2SAqNjqQQFRFBDvDdt99SPSmJUCAfmHDrSFKAGT98jw3o1LgpO20lOND5EnsK8zkKZKNzKIqAgLPnIDiIpRfSqWqM40E0Oh+jV2IN3tu+jZlvvknqqjVsXr+ek9mZhB88RGBSAr999jlLgXsbN+aJRx7h2bH3smrfHtr26Maq5SsoePc9Us+lAyCG6WbttwwbTvUD+xGDg6/5jIdMfp8heCZslbXPv0hzwGIy41J1PYnygYGoaciyybBclxDQAwydU1NxbXotUqUsSQiqboJWnqsx8svPkESRnP2HMIUEXvOaPb0qblVDNJu83BofifPvCV+7qQ8++OCF2SRTsGo5tW8fyVejxvL4j995zakux7avp5Bx6gyVGzSg2Z0jvV/yblXBlpbO6dVraThmlLfddOnLr9LjpUleJ07B2NdrlgXougt6gENuLmdWrWbJjN8Z/9P3qAGBepZEFHSXTjRvpgOMDAplk9vRBYtY8vnXPLZwNqKfH+nrN1Fqt2HLymb1ggU8POVL3HY7jw4bwbARt9L+gfv49pEJCKWl3P/qy3z24stUCQ+n04MP8t6DDyLJZlon12btoYPsBaY9/iTnz6ZSs1tXnh0/Hje6W+r4xo0Z/MrLCIEBPN+9J8VABBJHUSgFWgBrgYeqVaW4oBhraBjV2rZh4/RfSGrRisjk2rw6bSom4K7QMLpNGE9pYTHhsTEUHj5K0lg90Fv29LP4KRqr9+xCDAzm9eWLcZw/j1+1ajf0rMu3lureIJST8PZoTaheDw/vEyrXtur5+/IxryXPrWtX6GUy1VBnvTzjcfXjyrpBFLsdQQNTgP/fPrDwtZv64IMPNz0EQSAmOhaAQKuVLTNm0HbMmKvu2/rBBwD48f5x+Lnd1Lt7FI6Tpzi9YSP+oaEUZ2Wy+u13sYSHY8vLJuvCBT2VbaxyvUGFIOgrYCN7AYKe1QgL45NPPiUaeLV3PyZ8/DGBDeohmE16mt7Ik5Q3tvJ0pghAzf59ebxXTzZO/oRqLVsS37WDV4xryYzpbPz0CyLatiYK2L9+HSH+/pxMSWFYz57I4eG0rlePwpJSwpNrkdCkCY3r1KNOQjVWHjpIAPDLR5NRgfMpRzhV7r58sW8fmwcNphA4bWx7tnF9aiKyZt9erEA3YPPZc9xStx6ZKcdYeiEdNxAXGsr306YytnYyFrebqEoxOFLP8/XUn5nw8MPkSwKPdenGXffew46dO1kFNACe6NcXZ37BvwwqrhoQaBoIoje4kETRm01CKPMDqVDauI6vx7Ume11mXNYDBUUxyKbXvdzLjje4GhYLisNJuVYYH/5m8GUsfPDBBy8CBbCeP4t/qxZQUMDvTz3HaEPy+Xoo2neQAxvWE1+9OlX79EJBN706tXg5+9euZsOOnbz80ouE9+jmXfGqnnZVY4LRv4vKXkOARc+/RP/XX0EttXFs0WJCrRakyrFEt2qpr3YlETRdeMnD5RQEnfhZXi2y/Ir34C+/EhsVhRQdQ1jjhuyY+itntm6jx+0jeWPSJLrUr0dklSocP3qc5AYNQBR4ae4c7k+qQbPhw1g2Zw4j7riDHWvXsnXjJm5//DG+/+UXHntoHCExMXz19nvEhoWxY98e9gEfjb6bP37+kb3AC8OG8eTs2TQHBvXuy9qli2nYoAGSCssOH6RFvXq07taNC2npNGvahOILF3n6yy+Q0dU9X3nzTYoEjSU/TcUsCmSnXaRll46IWdlUSqhO8qMPX/FsLv+O92QhruY8Wr7LQwBDsfP65mIeuBUFTdPKHFS5egbDI3pVfr/roey6FFS3G0HV9VIki8WXsfibwpex8MEHH7xQL2WgWf11oamQUC6eO8u5RYvJy86iMC+f4LAwZIuZQJOZasPLJL+DGjegXeMG3r8lTUMUBWr2701i31sYDGSsXEPuth2Et24JGEz/cuRPRdUQBM8kqHFx3Ub9C0oUkP39qHf7rWiKwvGZsxFlmchmzUDV9TAkQdQFlIyshaZqCCJe8SjQJ7fMzduwXcogoEtnRJsNgGh/PwLbtUEoLqZ+u7bE1Eii5di7CftlOgmNG3Nm714aWv3o3aMX1rg48otLyC4ppkGVeJq99BLhnTvQ/vgJBL8ATCGhJCbXpHOnThzcv5eHmzdHdNppllyH5qrCrNmzefvWkbz9+2/MXLqYLk2bsffUKcSCfKyAX1Q0sqqRWLUqm3bsIO9wCg0ANbYSL/w6lfXvvU+nSS9wf4cOLH3mOcJkE6F+/lQbM5r5X00h2XivJRcuEFC5sve9l2V0jIldU5ElucxRjDKfF6lcmcqTFVBU3X1MvEwArTw82aIK265RMvEIal0e9JTn6pSHTiIVQQVRlJAs5r99UHEzw9cV4oMPPnjhLCrEapIwyzKSLBMaHc3u+Qto0LcPHZ54jEZ3j6bekMEU2R3s+eQLdv/w81XH8Thqeib9fTNmcnbfPpZ8+jlKaam3XdRjQKZoqtFNoq9Ozy5bzd5Fi+n39huAgCDLegupAIm9epJ39KhOzjQyEYpBAPVwLgRB52F4MhWe7pGNc+bQ+r57ODx9Bu+PGQtAZkYW836bwe7Vq/h540YuHjzMpcXLOL5nDztnzqTWsCE0bN4MV6P6/PH99+y+eIFI/wDe/+VXln8zheO/zmD7ju243C64cIET+w6yfeEiHn3ySQIUBUf6RYKqVMGmqDw2bhx5x49jBRqFR1JaVExtP38k4KOVy9mybi25sowpOIjUtev59tRJLgGd+/fjkT79qNWqFcd+/hWKi+n9+qusOnSIdFEiOD4Of5NM4eq1pC38g4wdO698Hh4lVOM+uxXFKEd5TMeMZ2F4eMhiWbuoqqq4Vf01z+uXw2PJ7sHlGZCrXovnOhQFp9uFy+3C6XbhdLtRFD2w0TQNp9OJq6QUAZCtf/9Mxc0OX8bCBx988OLA3j30vW2E/sWtqlxITeUg0BvwUjitVurfdTsABadOXWMkvKtjxWHn0IqV3PndFHYPu40NX36Nv58/ZquV8LBQKnfuiBQWpneKIGDPymTXgvkMn/KFUb4w0veGjsHKT76gU/++3nN4yiB68CAZhmeCVyxL1fQ22rWTP8YSGgqhobR44jFOnzsHQGKj+rS+kEaHkbdTZ/t2EmSJmHrJNDc8MDSTieDgYNLPpGKunsjHPXoSUq8uL7z8Mh+++ipNIsLJy8jgwOp1PLl6BVZgccZF7ko9h9NWSsKQIcSrCtXi47mYehYhwB87sCg3m9DcbKauX8vKd97jx7H3Mua22/jl448Y98gjxNRN5jlZ5mJOHh9/+y0//vgjM7/6muRq1bird1+eGv8wvTp2IOtoCiu++4lbP3iX1I1bSOzf9wo+hCdboarl9Sg0ZKFcOUIACXApblyKG5Mse4/1mMiVlUmECgEClLUbXw71sq4h7+dD063bNUASBDzrXF0mXEGzOdDMZlRPicVsRrKYr/l58+HvA19g4YMPPgD6ZFG9chyyJ4Uuitz/1ttc2n8Ak8l01WNCkpKAa9XSVW9baHxCAjidjJs7U1+FGvvk7DnAyncnk3v6NA0G9CMvKwv76VTaDxtcIX0PequiKIh0umcM2Vu2YsrMIPKWHhXOqRqBCBqkL1uBqqrE9e6JoEnExcUT37KFPhlKEiM//xRFVQmrV5etzz3Prg0bUIFTboUL8xZgVVWKbQ5c+/fz8dIlsGQJvZKSKDh5ksATJyhx2gkGFKcLCTBXjiED3cF0Wt++ZFy8yOI9ezi/YyeZYaF0efsNVo4YyS0tWlBoXO/U775Bsdvp8ugjfDD2XhoUFPLa198w8MH7Wb5uLevfeJsLZ/ZwZ5OmODIzufvlSZxYsYbEqGgaDOpP45EjeOO2O5CCgvn8gYewBIVQPyODdrffdsXzEAWB8rkDkSt5FqBnKlyKgqKoCJIRNIgiaAJuVZ/k3aqiBwSGFslVP0+GxoVHZ+Rq0A3MDC6Hsc2tgOJyIlssyBYzmqoiGK6svkzFPwO+UogPPvgA6CXs/JISirds926L79KRo0dSkCyWqx5TviNDvex3z6r29K8zqdu5A6d27ixLjysKaBDVrDF93n2Tur17UatpM3bOm4+AQKUe3a88F3p2whxXicrDh2AvKIaCAu/rnvPr70UgvvctWCtV1idUVSWhfx/2LVgI6BOZIAjknj/HL888x9OLF9Guaze6dupM3zdfxyyIdH7iMfq98Az9J4wnDvhq7D00S0ziQmYmlYODqBMXTwqQfvECecCubduoga5RUXXEcGJ79SKuWXN6ff050bExrH7hJbp1785dCxfwZOfOfPDwI5CdhzkoiB1LlhEUF8f+Cxcw+Vl4rktXfh11Ny4/K3e8+CIt6ySTnnKEC2vWUTU6nNemfMmqjz9j1w8/cOuwwXTu3Jm46tUJCvZn1o8/8fs771d4PoC37ASXq6Ze9jkQ9JZfRVNxKW7vNr3tVMIkyciSrAcUGiiKgtPt1l1IVRWX211R5ru8Amu567naeQFUux1ZEJHMJgRRRJRlBPHGCKQ+/D3gy1j44IMPgP7FHmgyEdi+TYXtdZs0BX//ax6nqjpHAgQU9PS2anQeiJLIiTMn6TH6diLxpL9Vo0ShIhpamY3HjCJ9zTpaDx+BxWGn4NQZAhKqAh4CZjkBb2OCCW/ShMOz5lL/vrHea9HLIiKS0bIa1aQhoqi3smoWC36lpfw4bjxjv/4STdOITqjO4AnjkZ1O3KJA4bl0SrftINYvgKOTP0YID+PLH3/ktoYNCQwLoZrVjP3SJUx+VgL9A4mTLdQODqFFtQR699EDl8MmGa2omGOHDhEXFsqZWXMQwiJoVLs2ET26MWTbNqIrV6b5sMHs+PFnsnft4NyxE/x+8ABD/AO4d/Ro8oDOZiut27ZixZtv8autmPlff01Ug3rGPYBbnpnIkx0707lDexZt3MQXs2cixcQwgrIWUQ//RFV14TD9fnqyEFdvGfW0AUOZ54tIGW/Gk35QVRW3Mb5+77VyJamyrhC9A0R/jqqqIoiilzR6tWBBMrJjguhb9/5T4QssfPDBB0CfEIICKgYQ+atWkbJtC00fvBd7Th7WiLArjlO9pEvVW8O3XbjI8YV/4G82U7NxE6+6ZoXjNBW329sjyqmUFDo8PI6Un38hIDIcRVH0GMIwJLsclugIsnJyrtiuqCqaUE7oyVgli6JIo+ee4pf2nTg/YwYRLVviV706obWTKTp3HrfdSaXKlQjr2omQzh3IOnKMRx98kI8nTiTj1GkCA4NxO124NRVRA7/QEEZ278Y3U77GAbz7ySfUAeKbNGH9okVEyzLWkFACY6Kp3rED7kuXODd9On169eaezz4hYPp06qJrXeQCz7XvwJebNlIXaGyyUqteHUrOpBKVUJVHrVb2L15ME00jslEDNE1j7utv0WPUaNxF+Xw7+QNyD6eQt3EzCcOGeIOJy++5LIreYEG3O79y8haNDhtPdsNjbX45BEFAFkUUFW9wAeWEt8qdWx9DNMTSFG+bsVguyPCMKUoSLpsdyezjU/xT4QssfPDBBwBMskxgSEiFbafOpnHbpx8DsOr9d+n3zjve1zyr28tZ/8dmzEIWNBrdNgwhNAzBEF+6GlRPHkLTaDvufgDsNjsEBIARpAgGifJySCYTiqpgO3UGv6Tq3msCvP4gkmeBLZRJjL+zeBGr3niDCwsWMfbXaZSePctbd99DlxYtCKwcp19DTg6zPvmEId26k3YunWMHDxNZrSpVmzXj+I4dnDt4iOD4ykihoWwxrmcAYImKYffevbS//Q4sQYEk3nk7u958h6LMLA5v3sKJI8do0KUzAI+0ak3Kjp3s1BRG1qzFxm3beKjfAC7lZOEuLKLp0CGYzFby5s6l7YRHcJ45y4lt23CVFCNFRhAZGUHHB+7Bk0IIQ8N6JpXU6TNIGDEM7SpBg0f10rjpuHJyEDQNOTJSf1UQ9OyEETB4tpWHp6XX03HjgWgYhblVvYTi0akQjCDCM5YsSHrJRHV7eRgVrlAUESXRJ4D1D4YvsPDBBx8AKNizB5PLRXi51PfRrVtYuWgRdZKSSG7RHCiviVDWJZB38AhF+/fjtJoxK25qjrqzwtjK1TsUK8DTPnrx5EnIyUGMiPS2Nl5N0VFDo/vEiZxesABTyhHi+/XWX9CrIWAEPvq+Ot7uP4hRT0ykx3vvsviFl1BLS1nwznvUqVkbh6Ki5uucjf0/TGX3kSMkHTlCnQceJCIsjIu7d3Pu4AEqR0WRlZNH/rkLpJ8+RQKQClwCagQG0DOuCTHVqrLm1+mYAoP4YdlSqm/eTFR0FCNGj0KLjuae8+fp88G7RH33A87Zcxg6YADF2ZkkdupI+rETzJo6ldytO9iZk0WrFi2RY6NRU8+RUWpj0+SPadimNT0nPl6BNCsgEJCYSGJkJLu/+56kzl0JqJ3kvV+6Q6iIqAleG3RTUBBiyjEwAgvPWFCmNVF+mweeVl4Bvc1ULKuQeO+3W1F1pUyxrPPE02UiiSKqolYQ66rwbFWt7KH58I+DL7DwwQcfEAWB7FNnaPnA3RVS37ePG4fQrMkV+3uIgJlbthJRI4ncfXuxhocjZmUS265dmfKiapiM3eAsoWoqnR9/FPz9vYtVRVMQlLKZS8DoNpBNYJapPngQZ+bOI3v9ZiI7tasww52aO4/qgwfpxwkCHfr1pWq3jqiqRu/nnmb2Y08w6M3XscTEoLgV1nz7A6dmzKRq21ZY/lhImMlEgztHUr9daz575nmCYmJw2S4gOpwkd+rAnB3b6ZVch0s5OfhZLITFx7Fn5y4CIsNZeO4s2yZPZuJrr3Mp5RBt7r+PPR9/ipSdyYL9e4l4531WLv6DSmHhrFq7hszjJ+iQmUWltm1Ju3gRR5U4erVpReHFS0iiRF5RAe1GjSI/JYW88+nXlNgWg4NpMf4hMtevJ+PEUayRkYS0bqU/A49IlvE87AUF5B8/TqVG9f+lZPflz8nzLNyqUub3cdljNmgXFTxcPMGFLOqZC0+ZpOwYDU1Vr66U5cM/Ar7AwgcffNBT1LYSivcfIqRJQ+9ksG/fPpqUCyzKjKs0MlauIef0aZTCIuIbNsTaqH5Zkr1cnV29RhnkWrDERqGJklF7LzufTgwUDZEnUBwOZLOMIEkkDh3C4anTObBpMyn79mD29+NU6lmigZhFS+j/5BOEN6hL53G6v4koCmybPY+SvFymPPEUj/wyFUpLmTr9F36c9gtyQhUGd+hIYvNm+v2JiqJz717E1a9HSOPGZG/bwUvPP0cgsOHoERIDgxgw8UlimjUlcPzDNGvcmMOrVtNt4ECqd+7ApSMpZO7eQ15OHsdOHCcOWL74D4YMH87Ls2bxXatWOGvXodEj40DTcL1uIScjg42r1xASEMAPX31FOBr7VJW2STXYdfgQrrvv5c5vvkK4rBXYM4FHd+oEQN6efRSuWoPD4SQ4NoaCggJiu3VB1TRMFgsBUZEGkfbqZMnrBRmiKKIa5bDLk1J6NqNMErx82cTjcCtL0hVBp4dn4Yss/rnwBRY++OADkiQSWTWegpOnkEODCE6qYTg+yeSu28DupUspcqvsOX6UB554krT9+zl16CAjvv7C20FweU5CVXXhKkmUvJ0gN4or1R0Fb2rem6r3s3peAlGk/ug7qONyEfrGmwQ0aEjDzEu0eXg8ACsefowuzz6FX9UqXuEu19EU1KJSEkNkXunYiei4eEbUb8D+ObNpMn4cNZo1JWnIIADSli5DLiri/MHDhDdvRkz7NsjAQw8/zNjPPyeluIjb0tJxx1XGERJKxID+jBBENi7+A9N3P6Dm5vPtq6/z7JxZ1Fm7nvHvvE0u0GTPXkzA68uW0q9BA44+O4ne995N85bNueWJxwj49HPajXuAvV9/w2MzZ9IJKD51kru69iDTVsqyF16k59NPIUVGXHEPPfcprGlj7zbHhXQCJZms+X8Q07cXW7/4mrZPPY6iqrg15TI+BBWcY8tDEkUk782/OlQ0NFVBNngbiiG/Xj5zARVl1wH0xIonqPQFF/9E+EzIfPDBBxwph6ldtzamatU4MXsuh9aup22fXuTkZFOjU0dMisb+H3/Cbbcj169PvTtv4/j0GWSeOUvb55++Yrxrfa+o5bQUbhQCIArSFVoGh2bMpv6tQw1ipobbrepEQIeDjGUrqTykv96F4HDwXvdbaNe2DXZJIig6kj8WLqFzi6YUldioXrMWzceORg0Kwp6Xh8lsYdmbb9OgXgOq3jECgBWTXiIhqQZhLZoRVb8eu3/8mUu79/Lu/r0kA/UDAklo0wYxP5/Pd+3kpW7dyEm7wMZjR9gGzH/pZbYuWUL1Nm3IyMxk5by57HE6qQooQP3YWPxCQigqKGTRpYsAPNC+HecPp9CuaRN2ZGaTcvAAfVq0JMpqpWa79hAWysevv85tvfvQ4vFHbljnQdM0VIedtB9/QQwJIqJ5c8xJCToZk7J2UY8p3OVmYZc/W5fiLqfmWQZdOEtDEPSshaIqSOK/Nh5T3W5cJaWYgwL/8S2nPhMyH3zw4aaEIAj4FRaxb/YcIurWp1bvW9iydCmx/foQa+yz+PGJRGkatR56AP/E6qiqhhQUhDUy/JpjXg2iKCIg6jLNN5jBEMWy7oLy0BBA1UAScLkVnC43/hYLgsVMVKvmnJ07j4ShQ5AsFp7ZsBaA0rQ0tMJCLmXn0e31VwDdBVVFL7dYw8LQNI1bXnmJLx94iN7B/tTo15e4xCTyJZFa9euhFRVxdNt2Wt3Sk66pZ+g1oD8ntu0guUYSJj8rA3OzkQUBi5+V4X370TI3l7BunelgNvPEpBfo0a4dr/7wPffeeRf1YmJp1bUzhSdPce5SBqMmTmRMfj6bNm2kQb365F3KpEHzFhRu3sIyYPhHH7D2xVdY/OUXNO7cha3FRTxqKKVez7L88mejldoQIsOIHzaUotXrkBOqeDswNE1DVyW5smPjas9WlmTdeVTVCb2yKHrt18sfI11DofOK8SUJ2c+qK5r6zMb+kfhnh4M++ODDvw9N41RONnU7dsIsiuz7bSZ3vfpyhV0a9eyOGuhPSM2a+oQhQELf3jS5755/qahYHoIh7+wVW7r8dXS/EM8rsiRfNagACI8IQzP0LdyKqq+sRUAUEKOjkFSNotOpFfgefnFx+CclUTMxqdxIZdfvceiUzSbGfzcFOTiELT9OZeH8+chZ2Ryb/hufDhpOQmwM586mcaYgH6vFwu1vvkqtO0ZSfchgmjVoQs3OnajRswehtWrQ8a47eGfEraTs3cvQ9u3JTUtj6uQPKQKiAwNZuHwVDrOJ7EsZ2I8cZsOcuUS53AiSRPXgYNyRkSTVq48DOPzDT+w6cpQzhQW8sXA+AI9/8hHbn3nh2jfd7ebU1F9Jm7eQkkMpADiLi/H0kwa2aU3+2o3eZyKKom4odoO25qIgIIsSJklCEkREUapQtipf+rjRwEcQRBSnE035c9ktH/4e8AUWPvhwk0MDGvTvx/4dOzAXl5CYUA2pSpUK+8T37kX1tu0pNUzHyrP8vYP8CYiiqAskCWVhhCiISJKEKElIkuxd4V5rMorr3MnrfolhNOY1xpIlrJXiyd2+Dc3odfW4rapAocPOmpdfQ9KMdyOUBTueQESSRBI6tqfNmLuY8OnHHM/JptbwYRxz2riYmsbBdWvJBIovXGTNtF9Z+/5kbFu3Y5JESvLyOZpyhJO79yJnZqO5FWp37ogoCBw8e5Y+d9xBIVA5MYluLVsSU7cuD372MYcys5Aiwlhw6CCHTp7iuNvF5uUr2bprBzWA1du2U696Ag0TEkkC6gJjbr2VS/l5rHl8IlpBAWeXreKjkXew46tvWfb8JA5Nm07SbcOJG9QfW242x6Z8S/ra9RRlZOnv2d+K1WrRSyCiHiSUJ13eeDBglE248SDimp8Pk4wgirhsNjT1SnE1H/7e8HEsfPDBB0yShG39WjJOn6bNkEFY69e/6n4nf59FUtfOuEJDveJWnon9z5pElf/u8aTx/9TxNjuYTKiiQKnNib+fuYKUNW4F5/FTHFqxkiZj7kAMq6ga6kq/wNJPPmfoB++iepxM0bwkw/JunZqmYb94iWkvv8KBo0d5atx4fp85g+6t2xIUFkZJkD+pu3ZjEgU63XcPAbVqG/GKAE4n67+awoWUFIY+/gT75swhJTWV7UePMHLEbXR6eBySAKpHevxffCe7cnOZfO8DhKoam3Ky+H7eXAp27CQrM5vUnbuIi6tEi5euzGB4fFpETUM5eIj81LNEDNR5KLkrVhHUqT2CLHs5Ef/rEoSmaShOJ4rDieznhyjfWAbl74SblWPhy1j44IMPuBSF0LZtyT11GjU4+Jr7JQ3oR/auPVcmKP6C82R5222PKdifQUlWFoKmekmb5QMBQRAQTDLmurVoOnQwZzduuWLSNsVVpsWwYbq6p6Z3olQwz9I08o8d945nrRRLvM3BAeCur74gJjCYQgSiOrYnOysbR34+i7bvYMeiJSgOO6qir7TP/LGERbNnc9sbr2HLy2Xu6lW0jI/j7QkTOLpzJ3+8+BpOI7A68dvvuqbIoYNIkqi/L1HwanoIgCk8nGfnzmJPThZD2rRBzcsjvGcPAuIrkVZSzNnsHJwHD1/1nomCAKKI1Kgh/nXqUrBpM5qmEdalEyWbNnt9Wf4OEAQByWzGFBCAq7QUza34Mhf/EPjImz744AMATrMVISwMv8vKIOUh+PmhOF0VdAn+V6vIEytX03TsGASX+/qBTWw0Fkliz7ffc/7ocW55aBzWpAQEQaBSy6ZeXoWnDCKWM9oKqV2zTCZc1fjp7Bn6+QcSHhPFqJ9/RFM11r34Kt3fehVVUxlw5AhnD6XwTI9efDB7JmJsLKtmzGTie++yd8ky8gsLqVotgT9OnKBRWBjnCgpYs341wusy4dFRBEaEoQExDRsBVxp/AWTs28fGb77j4Vt6UfvBezmzeSupS5fS85HxDIqIovDgAUp278FdUoJfqxZXtHeqmi6U5VcrCcEsc2HufOKGDsYSHUvu9h1EtG71X3lefwWCIIAIluAgnEXFyH5Wr0mZD39f+EohPvjgA6CvZou2bKbxbcOvGywoOTlc2LyVqN49/63zaZqG5nIjyhKH5i9i/fz5hAUFM/S1lzAHhyCIIpqqIogCLpsNSZIRTSa9bCKKHF+8hDoDB1BidyIIGhbz1SecMqdNUIqK2Pj5V7QaOhhLzSSDDyAiiYbbmbckonM2PF+PmqbRoX1Hbk1MZPzPP1JyJhVNceGXmMilHXvI2L2HlWtXISoKRdk59BowiOoN6rFq1hxqtmpJ6/vvQTP6YERFQZMkbyCTte8Aa2fMYNArrzD36Wfo/eCDhNSt7c3keMoSzuxs9n3zDSeOHCM2MZFuzzyF5ueHoqrsnT2P2pHhBHZoz+LX3qB6ixacXreBarVqUqtf7wrBYvmAUNM03BmZKBcvYW3SiHOzZlN1+LB/67n+N6BpGqrbjaao/6hOkZu1FOILLHzwwQdAJ1QenT6dvhPGI/j7XXffvDXr8O/QFg3Y9t1PNL99BPJ1rNWvCk1DszkQLWZKj5/AWikWJfUsYnJtfcKXZTS33h2hud0g6loWmiE5rroVBKuZklInFot8VadOwCs1rRndH4JbYf/nU5D9/LCEh1NjxCBDY0vvhtA0tYxnIeodCgLQtm17Nv7wHWrNGmiq5hXaEjDcV42OF89XqigI7J76C8d27KD7mDFUbtUC9SodNJqm4SooZNrLr9AsqQalAUGUXLpAswH90HJzyT9+kn2Ll1ISHkLz5i1oNGF8hWM971EtLUXZthOheROy9x3ADpxeuQq73U6f98vM4676PFevZf/mLTQdNIDghg3+3HP8P4LqVnDb7ZgC/H2Bxd8cvlKIDz74AOjiVW3vGcOF1auJ69/vX+4vCAIX12/GXVz854MKQFN0+qcqCvjVqQ2A1KiBlwiqAYJs0c9lKvuq8vhzCrKEy62gaqqRcbjGecrbciOAJFJv+GBkfysX9u1n6QMPUQo06z+AxP69jW4VwSA7gohuMd4kIABq1TRcNz3CXXrrrb6/HryIomAIQqkERUYSFBLKsp9+pNWZs9S5dehVJaxNIcHUbdSI+b/N4JlFC1HR2DjpRaKSatDq4XFo4WEk9+uDEBBwxbEeiP7+iB3akrd8FZE9u/PJoGFsyssmBuhRUIAUHFRB+bI8wrp1oVPnjghXsUe/3v281rX8NyCIgtdH5Eau04f/HXwZCx988MGLkKAAcpcvp87tt3m3Za1agyk2mtC6dcHouijYspXMEyc5npZOt6ef+GsnUzWvwFV5e+wb6TIREFA1lVKbE5NJwmy6zhqpnPu2R03S65elqOz59ntq1a/HT++8hxwWxvjvpiD6+6FputmWKAgoisLTnboy6bEJrN6ylfj4KggWC63HPYBmlCtUQwdDFESvSZsrK4s5L7xEu1tvoygnh4zU07gRueWZifo1aGWW8JqmsezV1/lj9Wr6tW5LWvp5HvjtV8RynS4esqtis1G0/yChrVte+X5tdqZOeJzuAwbgttuI6NEV8dARCA/DklzLO94Vt8kwKLuilfgq+ymKapR2NERD/Oq/HVjoXSIuRFnymuT93XGzZix8gYUPPvjgRVhwIOmLF9P4rjsqbFfy8ig+lEJIh3YApG3czNnt22n26MPefc4sWkJJfj6azU5QZARScDBVOrYDs/mq59LcbjSHC8HfWkYwNFbUooB3Yr/8/6hGwQFV0ygsshEc6KeXIv4FPHsYoYXXj0JzuTnwx1IaDe7Ptk++RNEU2j8+wVAJ1c82ZfhIFlxMJwEY0LwFvT/50NtBUkEECqO7xPheddvtmGQZwWQy7MUFji9YxOH16xnwwXsoqlLRj0PTOLVkGWun/cItd95BcX4BkeHhxHTpiObvb2RDRPKOHOXQ9z/Q4YP3yt6g08n85yZRo3oCan4BDR56kKLMbDIP7KfKoAGcWbUGd2Eh9W69OodG0zQ9A6SqWMymawYK/6uMBej3U1NVTH8hQ/a/wM0aWPhKIT744IMXpXYHoUk1SZ27gIQhA3FmZHBp23YkFdJST9PKCCzi27Uhbfcub1li9w8/E1W5MvXvup3i1LMEJlQjc8PGawYVAIIoIVguy1YY1t6KJnjLIZejfClBEEWdEKn/dV2ZcK3C75pRUxEQzCYa9u2F6nDS+rHxrHv7PQ7//Au5efmU2ooI9g9m2sV0fpz0EtM+/4w+n34EgCxJqIZ7q6Zq+tsQRO95BMBk1Y3SVE0DVUEQJRL798EcFMyM8Y8w/LNPUI1Vv56RgKS+vYmpXZt9v/5K+6eeRPbzI2PFSkpLSqk2qD/ntm4na+ceLjqcOLKzsURG6idUVSSbncRWrfBv1ID8BYtRw4KJa9SYnD+WUGNgf5wZmSx9/kXyRZHb33yt4vMwPEKK7Q7MJvmawUf5/f+vIZnNuEptqIryj8la3Izw6Vj44IMPXjicLoRq1cjZdwjN4SB31RqqDOhP7MB+tHzs0bIdVZVKkZHk7TtE7t6DXDx5girdu4CqEhAfh6YoRLVti+Zyg6KgltgQXAruohJwuXEVFoPLjepwIl+WmjfyCFcQHD0ztieL4MlsuN2KcdxfSEIac6NoMSPJMn+8+hqdnn2KuqPvpP1jD9P7+Rdof+dI2gB3v/EajevUqdC2KWA4fYoigqEB4THx0ksOgtfYS9M84lsQ16kdTlWXIfeUUVQ0FKOcElCjOu1feI4dkz8GWSamT2/ie3Rl18dfcmHxEtTSYnqPvJXzGzbpnR35+ez54gt6PT0R/xbN4FwatpIiQmNikPNykarEk7V5K3J0JEJUFMUnTuIuKrridkiSiCxJFJfYUBTlCnMxVdN0p1pDbEsxfi//rLZ+NYU3+w2EvLw//zz+5fMS2Pjj1H+525+Rmf9vwMMFuVnhCyx88MGHCnArCiVmmXeHDue3335jy3sfUmFx6naz4e33OXk6laOrVlF06SJ933wdpdSOoGoIioqkCQiqiqBpOtfRYkaTRKRAf5BlTEEBYDEhBfjhvuEvYI89e1kIYbGYcLjces1fvTETrqtBlmRkk4mgyMgKDiZ5x47x7OChvPbDD9QH9m3dwlcjy8pEqqbhVhTcXpt3vW1VEASvVXz5TpHypZ2s48c5OmsOklDeHcUTMIlIFjOJnTpwZuESneAZGkbziY/S+PXXqPnYYzjr1iMoMYkL8xey7eNPOX3yNFLVeFyXMlARCO7cicI9exEb1iO8cSOOrV3DxZ176fzwg9z2xSes/eqbKyZeQRAI9LciyTIFxaXY7A5v8KDffJ2w4vF8UVUVt6J4J3FXejoZ584z4esv+O3rb/7Ss/hXMFnMKE7XVV/TNA3F5cJVXILicN6wHLiqKChO138kENEMnRC3w/Fvj/VPhY9j4YMPPlwBkyyjaRomWcJ88iQBbhcB7dsimEwc+HEqMdGRRPfpjVtRUDRVn3DcCkiSbgJmrML/21BVjaISGwF+FiTpz6t3eiAg6CqeNgeHli+l4eDBAEzu3Y+m3XuQdzEda2Ex+48e4alfpxGYmAhQbuWuVCiBiIJgtKNiZDMEo8TjWeHD8tdf59iOXYx4ciLx3TrjVtxl12JkPA7+Mh0pOJj6A/sDoKgqeQVFmE0mAvysKKqK2SSTuXAx0QP66sd7dTs0UFWKV64mr6iI0Dp1KD59mohO7VH9/LCfu8iOxQvpOeFKy3VN03C6XOTkF2MyyYQE+mOS9dKDW1UQNL0Vt/w92PjSazjMMr2eewbBYvlLz+FfQVM1XDYbssWCKFcshWiahupyGRLgegnKWVyCOTjounLxmqqiutwoTieS1YIoX70MdMPXqGleMS+rf+BNybHwZSx88MGHK+Byu3ErCjaHk5KE6rjr1mXbl9+QtmAhxVmZxPTt4538QM8lqG4FTfvvp3+9ZEdAEsuu4XodJFdu0yF6tCfQUA0Z8JXTZ4CmseeFl+g6cACdH5/AyfwCZh49QgFQfDEDVVVRjUyL3hUheg3RVE3DrareoMJzDkVTUVWP7gT0fHEScdWrcWTlCt1uXJJ1V1Dj4rZ9+iV5WVkktWvtzYhIokhIYAAWiwkNzTvZXzp8+OqTp91OcXYORWlpBNRNxm4rIWf5KkyCiF+VStRt2hR3ytErSgeCIGA2mfD3s6CqapmkuCAgCWKZWqnxGZAliSx7Kb1efvG/FlTo0IOHy9k3Xl8RpwtTYACiLCPKMuagQFzFJaguF5pa5m1TPpOhut0oLv04xe7Qhbj+YlCsqSquklJM/n6I8s1LYfQFFj744MN14VYUcp1ukocPIW3zVkIiwr2vefgEgiCQsX0nxUeP62UAj3DUv3nuq41hFBvKNmgaTpdynXNdlu6nzOlUz+wLZe9FFMnKyIS0dOZt3EiTB+9HEAUmTvmKAsAJrP/1V5yKG6fixqW4vWJaJklGNjo/9LFVQ2xLwaW4K0zQmgbCpUucOH6KqMREcLmNe2mURex29m/aQKcnHsUcHmG01xoCX5KAJIleN1eAqr16kbVqzRXvPPfwEaJHDKVKh/aceOd9qnTrTliP7pRu3IIsy0S2bEHK0WMcXb4Cl+LGrSoVggur2YTN7iS3oNjbBaOqKoqmohgloMNTf2He088SHB3z3yd0CgLiZa3FmqbhKrWBpmHy96twDYIoYvL308W1bDbcdgeqy4Wr1IbbbkdxufRgxDjOFOCP4nQZwcufg6ooqG5dSVa4Qcv5/19x84ZUPvjgww1D511YKFBVWt8ztsJroiCy66sv0RSNZg/cV7baK+cn8p9A+a9pT6lB1TT8rGbsdpdhoGVkH8oTPy8bx6OYaVwimlYxp/HEZ19w/uhxuvXu5d0miSL5QCBQ5HTgvHgJv8qVjRW7HkgoqmpkL/QykmK0RqoWs/caynd/PD5iJG9O/wVBFDgwdSqC2Z/Go26HzEy2fvMd1aOjmXvfeDSTyODPP8WtKLoYl4fDYbTLCgKENmnIwS+mENW1s1drBCC8RTM0TSPtwEFiO7Sn5Nx5xKAgju/cRQ1/P8zRUSR1aEf66rU4cnMxh4WhIFB85AhFJ04hhIcT3LgxpQ4nRSU2QgL9OTx/PqumTSexUizp+fk4S208PmvGfzlTgfG8BERZNvQs9OlLU1VUpws5OAjhMiKwIAi6Y6so6hO/04Uom5GtFi9PQzTJ3s4kQRSRLWZUgzdyo8GBXoZxo2kqstV6UwcV4AssfPDBhxuE0+Wm+ZBBOM6cxVIlDoxadOqsucQl1yW6fRtUw/sDrq138Oegd36omke6qTx1U4ckijrPAwFZ8ohTKRX2Ke8X4hlDUVUkScJLCtU0EEWiG9ZB0OpgCYtgz9ff0XBwf6SoaDpXrca6c2fpXaMmv7/8Gt3HjKFax7aG3oaCJ/TxZBZUt4upDz9GzZq1SD9ymOj2Heh431gEAQ68+RZVKlcioEoVNDQa3H03JadOM/Xe+2nWuQutR92JEBTExYMp+FeK9nI4RKOl1svtQPXKkSf26sF7AwYzceG8K8oiAUHBBLdtjfvUaY7Mmk3DJx/Dvu8QWVt3UmXkMOJv6cH6L7+my4P3IYaGknv4KFWHDjKCQxVZligoslFqd1K1XgPaNG1GcV4uvW7rReXk5Ou2Ff+n8WjnrrRq0oS7vvisLNskS9fVMhGMzp3yBmbXKlWIsoyr1KaTgY0xRUlCEMUrAhcwOBXFJcgWM5LJF1SArxTigw8+3CBURcWvSRPObt7CwtfeBCB1zjzkAD/iu3UBBDRFuf4gfxq6rLanBbW8JLUncBFF0eCOKjqZ9BpdJoYSt84TEKWrK1DqOyBIIjFNGhDXuDHbfp2JIMAr034iADh/5Ah3TvmCsJhoUtes83ItVE3Fqbh1EqYA5qBg7p7yJR3GjuLkmTO0bNaMt7p159fxE7iYV8jTs2ciSRKyJCEIEFAjkUY9e1LnjlsRq1VDjIigSpeOBNesAYBJkjBJsl5yMX5KgujNDPklVqfPrbdW1Osw7pFLEHBeSMdUI5EG4+4nY8EizJWiyMrKpPjYCfxCQ+g47n7mTHqJ7+4cjWg26Toixqrd32ohMiwQf6uZ0ohI3LEx+FVP5MzR41jiKv2fTqZ1EhO5/aMPcdsdBl9CQ/gP8xnMQYE6T0OSQANXqQ3lKuURTVVx2+zIViui6dqiYjcbfIGFDz74cEPQux80Evv0wq+wkIt/LMEcFEB8n95GilpCNJv+cqbCk1XwrLY94ltltuZlqpmesgfoNX+M8oKmXZnREIxr1zC0IlQVl9GBcb33qkkiMa2a0eHR8RScOYviclEVCEuoys6fpmGtUpmDm7YiCB6HVMmY9KWy6zObUGNiePaH73jxsUfp1rMno776gl6T30VVNa+2hdsgg9YZOsh7DW5DR8ITRJR/zx69DFmSMEuyYZ6moYqaLkwG3nKQoipUGdgPc+XK+nWGhnIhM5Pza9eTeuoEaVs2o9ntWC1WNu7fz76zqciXMsHpRElLx3b6LAAWk4mgAD/CgwOpO2I4Z0+fQrWVUpKb93+mF7H1ldepFRevZ8U0DVdJKYrTCfz1VuOrQRAEJJNOAJWtFkx+foZOiQ4PAVR1uRFE/bPvCyrK4AssfPDBhxtGbkEhpWYL9YaPwJVXQEhAIKLdDpo+0aku918mbHokrz0rc1mSK/hoeFQsyhxCMVxLQZIkPBpa5c8vCB6apmEqpqpoqk6o/FeToSSIyJKMJooEV67M72++yxGgTrtOOC5eAlnmluefMpQqyhNNhXIdFroviVyrFpGhYbR69mlvh4dqEDtVTfMSNzHelx5kaYZGhGrwRlTcqk6YVFX9vejEUMVLIq1z661YwsK5tGSZzslA58B4u2fcbtZMepWkFq2oMepOBr/zFm6Hi98eeZR3R43ms3lzePuzz8hJT6PoYApHVizHdvo0zrPn0f3bRGRZwpqbTfWaNen+8iSslSv9FWmyv4TZy5fR6r6xiJKE7GdFlGVMflZMftd34/13oWkqqttV9lw1cDucqIrbx6m4Cnw6Fj744MOfgigIWMxmYiJCEQVQDqZw4cwpAqpUI6RhPRSXC9H654h8ekAhe1fZqlbGHVBU9erlDYMvgSBgszuRRBGz+cqUuGhM7qpWZp6lH6/pdfPraByAETBo4Cgu4f+1d95xdlXl3v+uXU+dPpn03mgJCQSlC4K0iKigVKVIUd+rgHK9iLz6gqDXi4iiYgFFFBFBuPTQQZogJUB6I31Sps/pu6z3j7X3PmcmEwhFEbN/fsZMOWe3czjr2c/zK8uffBK5aTNJBBt6ezjwa+dHxxkeU9hdUZ4V6td6EL/uel60/9oejCZENHoIZaq1xVS1SFE8Et+XQaqrrky3gmIk/N3Gu++mbe7c4FhUMFpI+Hz62p+z75fPDQoODd+p8Nf/vJgX1qxl5JTJfObyy+j5wx9xe/sYfv7/wfd9+h57EtncyKtPPsV+h3+U1578K3ufcxbCtKJC7t0sri9c/xt012WvM09/U77Gqt//gYmnnfqO9/NOIaXELZVUx8e2cHL5HfK82FmzQuKORYwYMd4WfCkplcv05vIIXceaNYOxx30CbeNGdCkVIfJt3LAoQ6nqR5HrKSdNz1fz8+3e/IhqvkXCMnFcL1JMhNsNvwmaG2i6hq4H/Aohos7Fm1tAC6QQmJkUUw8/nN3P+Dwj99+fdCo9wNra85WrpqZp+EExoIlwwZdRURBKdMOhTZgSGnVnkKqrIQKfjoATYuo6hq5FPBMRdDWM4G+apsYxAPlcAZAUS2XKFZeK65IrlFh7z/2MnjwJIxidSClpf/pZ1m7toDGVoqevn67XFrC6UmZ5vo/NDz5M9xur6c3nWXr7HXzozDPYmi8zf+Ei+ksu5bLzloXZjqBz82ZmnXoyr914E6/88vrtPq7g+ch/hFX4W0CNRiyk71Hq7nlPjLT+nREXFjFixHjbkEB/vojjuJFJUsPHDqPzoUfV2KFceRtbCwymILqHV8WAxPEH5lWEZlO1xwHKKdQydPLFcjSS0DU98n94MxdQ31eeDF6txDD0jAA0TUQ8j+AXpHedxqwzPodwPYQvkZ2d/OWCi5SnguPiOF7kvKkKBKU+CbsRuqYp4mV4BYJuw+B8FKVwqXIxwk5FGOcuhBYVNqHjpyYEdXX16MUSa9ZvZuWadjZ39PD60jdY274ZMWMWvf0FfnfhRTz+jW+xZv1mDv7Wt6lLpFjx6nweuPZaWo/5BMvWtXP6ZZex6ImncHafyeiPHMraFaspDR/O/hd8nfYtnfT05d41v6Jv4ULWLluGlskw45wvsKWzk66XXt3mcUuvv4ENr7/G/zvhs+9qf+8UmqFHUtew0xVjaMRy0xgxYrwjhJkIENzRJRN4TXWse+BBRh31MaTnI/Sh710E1SRSJf300GqSQYeCJgSGpgfOltuqT5IJm97+PI7jYRr6Njbb22w7nIgMuddq0FkYeqYJDcM0cSoOhmWg2TZCStxCESHh4FNOVcWQqzoutjCRGtHIJjB+rHZnNJ9QRBM6cg60BdcCQipBN0TN9kUw2nF9H01THQtPKj6GERgzjTjsUJb99iZ6UxneWLmK8UccRff8VxD5HJ7nsXJdO7m+PCO+dSEAm3N5XMukD3hx+TJeO+lkhu22G59qaaO5uYktPf3YbaPQH32Yiu/BjJlkJ4yvuleGhBeqluQ7ilKuxMeOPz76+YhvfoOVN9/C5iWLGbvHbkgp6dnYTk9HB0dcfhlHvI+R6Zppkmiof1sduZ0RccciRowY7whCE2iDCodh++1PyjSRvo8YxIsYbBldC9f3IyfL7cGXEidwe6wtasJCw5c+tmXiuO42keuDlwHPU8dm6iYaIiJqihoDK01ThErP9xCRjTXohqG4GkH3wsikEE2NtMzYFUplTN/H0ghCyFRBFGaEhJ2J0Jcj7MAou4TqUeqaHh2LlDLqchiaHmR0KEWIHnQswjwS3/fJvfEGr9/8R5Izd2fURw7mw8d+nMKzT1PYuplkNktvf4GGbIY95uzDsOZ6CsUiFceleeJkBGDYKSbM2J2eSpGPf/WrrLrrbppXLWfEmuU07Pdh6o47jsSmjSQTNqapzMBcT41bKq56Dd9OsuiwD+1Fsb9vwO8mnXISu3z2eLYsX8GG1xfw9B//xJwvnAXvY1EBQaGp68rpM8Z2EXcsYsSI8Y4gELiej2GokYHiRfhoba2UV63EGj8hcD6shkWFnIgh+gc7hNruggjcN0P4UqLrGqWKo0YOIjTOGrSNgCBp6GqRlrKazxEWPHrAVwhJo7qmKUtuTVApl9ENbaDplqah2ToGGr7rVosH38dTG0bXAmVKQEwNU0KVwVb1imjR74PiQ1MFg+JpVGPZpeKtUtmyBXvYsGic1L9uI5M/cjDWxAmq0zFqGKNm7oLnemx64q/0Pf0kBSRjhzeTsC0StkVzYx0PrF/Dlb+7EdHTw5Jnn+VIM8FDv7+JXy1bwrxvXER62pTIC6S0ZQJWXQrS6cjSPDwDz/fpXryI1t13GWi9/iYoDMWbMAwmfPqTAEw79eQd2s4/A29mxBVDIe5YxIgR4x3BcV02dXTR25+jq6efDVs62LilA3/iZBY/9zz9S1dUOxNhp/w9aiGr7Ypoca/9vef55Aol9fN2nl+pOKrjIjRETeZGFP8dSDjDUkaNVVQBpeuhKZUqrkJipQiMtTTbRJgmGiBcH69YRgQdEi+ITZdBS0UEnQflfSEihYkQNeFmIblTVD0+JNC9YCGv/OIXLP7DzSy6/kYqK1cBMPzA/Vjx5FNKJWMoXw1dE1iWSdtHDmKX008l29KI8H3SSZvdpoxj7MhhHHHwAQybMgm7uZlrbv0zf3xwHv2VMj/60pdY+tqrQRdHHU1i9p5s/uuTUcLpAAt1CU/detvbqx1dn9KKFW/jCe8PlKOqh/5PdBr9ICIuLGLEiPGO4boeHd19dPb2Ua44OK5Hf77AqI9/gpXP/o3S5i3qgSKUZL41mXJHEaoqau+KJSo7JF8s0Z8vBWZag8Yuro+uq0RORdCsFhVuTRvfcT3cyFWzyn7wPD9Y3FUMuupAKP4HwfFomoZm22DqmJaFXyrjFoporod0PfwaNYpSpiiZqGkERlgBr8L11DH4Nf4WoXT0wZ/+jBnnnMMeF3yVXc84lRXPPMvffnk9f//ZL1izYCFrb7wJGFigWJaBbmiM/uRxCCvB0ltvi65L79ZOii/PZ/1fn+LKb13CuKYGiqUSu3z0ECaMHI3/xprqdTZNTE1Ho0puDSEEmL5Lx4uv7PBrabUN4+UHH97hx79fkL6PVyqh23Fh8WaIRyExYsR4Vxhqll6qOIw6/lPIbDqQXarFbSjS5bvdt1JxqJ81IUjYJk1alkrFpey42JYRKTA838dxHBIJC8/zgi4ACKkkpWGRoRZyHzwZdBBUl8ANioDagKpQMhp6WAy4JkIDQ6AbSZxCkd431mCkEth1dZBI4DsuZtJG03U2/PUpDGHQuv+Ho+TScGxS2rqVra+8ypiPHIywLXwp2bJundq37yOFYMopJwbEUMmae+6H/n4W/+4P7Hr6aQgpInKsF6STjjn6CDY89CjP/eLXDB85gp5Vq3l4wUKO+Z/vI0wDf+0GSKfQenqp+9De5Oe/Ttrz0CZNxJeSpg/tQ+7Fl0juNXvAayKEAF1n05KltM6ZvUNEzpHjJ/D0s8+9uzfDPwi172/fcaJ01Z3VA2pHEHcsYsSI8Q9B2XHp7stRqbhoQsMfgu/wnqDm8125d2rYpo5l6RTLDvliGQBfzR5IJCzlLRHIP0MIIdB1vYbfwDYdjVqlSLSwBDzSiuviRi6YXnC+SgpacV08Uyc5bhRmazO+Zahuh+uy8bm/s/qZFxg5cSK3/PgaXM8NHDdlFKOebGjAdl1+d96Xuf5zZ/C//3EBm3p7WXrbHYjgMbqmK2Ot3l7y69Yx7rRTSLU2sfD3f4wkwbqmYYakTySjPvZROteuoXvrVg7+3uUcfeXltN/7ABvuuZ8JR32MaSd/lvYFC1hz132kZ8/k8UceY/2LL6lr1dxEf/smxWMplQa8JLtMnsgjf/xjRJJ9K7R8eA66YcB2cl7eb0Svoe/jCxERVd/qa2dF7LwZI0aMfygStklzQx2GoUycfH/bPI93Co1q1yAkhoaZIZ7vB3yLMvXZVJiMHY01woIhvJ/2I3PugZwBLSgk/KCCcCoOumEM4GYgJdIHoQ+8Ow9txBEos6/B5x0QH6XrIvMF1jz/IhOPPLzqzimqRxlGtHvrN9DX0UXWsjAa6jDGjImUI0II/nbVNXz4wq9E8elL/ngr00/+7DbHFao3Fv/hFhqGtTHu6CPY9NzzvHDDDUyaMplpX/9atP/VDz6C29fP2OPm0vvwYww75ki8QoEFv7mRlpEjWLtoMXtddCEEYWCe5/OtQw7j0nkP0FiXGbJrUbv2CCEovvEGpVVv0PjRQ7f/gr8PCEdknuvhFUpoSXsAIfnNkE1ld0qmZ1xYxIgR4x+OxroM2Uxq+2zKdwBF36wtLAgWWL0aRiahv1DCNg0s04jGFspAS0k1g4cNsNoe/H24uPvBKMW0zG2DScLjEgINEblvhuoNIBijDB2Whi8RUuKXKmgJS21e1wc8Ttc0bNOKuhnqaYqDsfzW2yh39zLlqCPITJwQPWfZH/7I5GPnotfXR78LC6/w8//hC77G2L32RngebsWhbngrXes30jJpApnWVvrXraPSvpkJ53yBZddeR6lSYvys2dTtMxuyWSiV2Pjgw7Qde0y0/RXzHkaTMOXoIzCHcKn0A36JEUhryeWY//ub2fOL5+6H56gLAAA/70lEQVTYG6DmXIZCrVz33biDSt/HKVdwyyW0ZEKNzN5iW+Ex1aXrdsrCIuZYxIgR4x+OXKGIZRrYthmtsqFs0n0X7e8qp8GPDKhCHoeGcspMWCa5YhnPlyRtM4hZV4ZVWiBJrV28t1nwwwIicAOthmMQOHv60bFEC44AHQ0PNQ6pLkRaVGQgidw2JRK0QGmSTiBcD12C7zsYiUS1QAGe+cnPGN7ajJ5Ks3HtWlJ2Es/zGDF7FsP2ngWo1n3I0Rh/3MdZceddTA0yNpRfV5gGC70vvcwBZ55JYtoUlt1zH7sfdQRaNsuY3l68LVtYcv8D7Pp/vkz7vfdz7Qkn8rFjjqFBZKj76MHBeQPJBNoAHxDB5CMPZ/4vrqd7/UZaxo1RKplB6psBq24qReIdkiLDvBS1+SphVwajKEPfsQ7DkNv2fPxyGU3Tg4j2bRkEUkp8T6Xsur6P47jomkZd+h3v9gONmGMRI0aMfzgc16MvV1D+EYHVNqi48cGqjR1FOP5QcsptF46QQ2GZBrZlUChXlM+GCIymgkIglHlWPTYHQgvIoTKsXPxqEaFrWvT3AfuWMvLQqL27jSLhhUBoitOh1x5/8Fjf0HENjVd+dQPt9z+s0jwNHaFp7PPl89CHj2LURw5izhmns9tJJzDjnDNp3XtWpOp1fU+1730faSdo3GU3Xv/NjZHXaW2w2+rXXic1YzeEZZG1TbRsVp1bfT3mlCk07LILHX+5k4Zx45n76U8y7fTTGDltOjLgEIQNg5a9Z9H+0COKqBsoV2aefQYr77qXcqWiVDwDZKk+A1o+lQqpumpX5e1ARc+rpFevhiAcdpxqM2HeLjRDx66vw0wmMIRAOm500io+XeI6aqxEwGUpOx69+Z3XRCsuLGLEiPFPQbnikMsXozEEEDltmro+YEl/u6VG2P3YFgFh0zQxdS3iDER8hShtVGBoNd2EcLuaQA+e53s+nuOh18zXtSC19N3kRtQWKYP+wIRDPkLnmjeisLMQow/aDzIZZMJGbicy3NB1LN1A1zUaZu1BxbTJrV4TeWeYuoGu67Q0N0MgkU0mEwOPCxh9+GEYqRSpGbuSHDWKdXffQ2ncaPoeeLDqqyHBGD6cclcPughdQjU0w2DK0Yez9Pc38/zVP+FPX/wy5VfmI6TktV/ewIa771WvkpRIXccpV95xAbA9GJqO58sBBUeIkAPzZvuLXh/TRDcMNF8GnBqJ53q4jqveJ4YOQpnGJRMWtmm+Z+fwQUNcWMSIEeOfAl9KcoUSpXIluNPXarIvqotzbTgX8JYdjfDuWw+6ELWopUF4XsBvCP8mJT5qwQ49KWohgmNRx6kWk0TCjgqLULEBDCRyvgOoxUsLgtOqqJs2hYqm0/X8i6x5+HHya9dGjw87Lm/qbikIFnqdPU46gfkPPEy+WFVw+L5H/dSpLLvhN7TfP4/UuAlDdlj0bIoNt/8vGV8i+/pJD2/jteUrq2FtAWl22NTJ9L/6ejSK0YQgO2E8u5x+GuOmT+XYi76GbG1h8533sMdnj+eNhQtZ96dbWfy7P7D18ScY+bFDcb23L0neXlkQHr/KUBl6ufPexv40w0A3DShX8D1PFWmWgabr+L4a7ZTLFRzXxdhBgue/I+LCIkaMGP80OK5Lb66A6/nqrjYgJ3qeq+bXVOPEByzsgxCOLrRgpu9JX1luD7HMemHh4HsUiqUonCw0nFJSTbUfXdNCOoVy8fR9SqUyFcdFN9TYIgzZMnQ9GF1UuQKGpgejnrcPEZhfabVjHV1jj8+fQjGX52+33xZkmyj4wV3z9hQ2jucp2WMwEjF0ncbWRpb++Q4qxVJ0DdLTpzBqv/34+4MPkZo6ZUCiqrqTl9TvfwCNjQ3UH3ow5tgx6B1d7HrwAbBp8wB5bmb2LBY98iibnn8xWGirypvODe2kJk4kMXo0bZ/+BGZzMwdfcjGjPnMCk089kZbDD8NqbnmP9EIDr2uYtVJbNFUNynac4yOlpPuV11h3219YftMtOJvaB3BrHNdDCEGprLpzOyti8maMGDH+qSiUShSLJbKZVFAYiIgUKUQ1K8MPEj2HalMr7waC/AzQ5MB8jdp7WClVhkh9Jk2p4uD7EhcV926EeSASNF1EHQ2B2kSpXMb3fWzbrhmjwAC/z1ASKgM7bqqkwe2Frm0XAkxN2XA7QeYIpsGwg/blU3Nm89qfb2PsrL2RSIbNnrHDuRW+9MGXTDnuWJzePjY99DDdHZ2M2X13fA02vfY6+xx8kLoWgWGYIrkG5FIhyOy2C96yFYw8+CC6H3mM+oMP5IGLL+HIy76NSKejcx01cTwNY0ZG1z5EIpMZ4nUUCE1Dun5kpKa9DaJlOMrwPK/6OryNzpHjepTKDpZpvenTpJT4+Tzlv79EV2cnEz53KrKvj3JPLyFrVNc1NE1gBAXoe+Eu+0FF3LGIESPGPxW+L+nNFyiVKzVtauVsqSSIMvC6YEj773DpDlUa6jE+Zae83bvPfKFMLl+K9gNhaaAsul3Pw3U81fUQAqTqVjiuj2VZVFwPPVjw8vkyuXwxGimEZNSw2wHbjnPeDsIOhGkYKnlVCzojqQQzTz+N4XvNpLRlM6tq7Lh3BOF1tOrrGH3sXGaedTo+4JfL7HbyiSx8dUE0WvGljxfwX8I7fjFyJOUtWxAClr34In1/+jN6Ty84zoAOzchjP07+tQXBT4H0tqeHBY89iszntzkuEf1fVRb6ZoVYGOTmBkm3obIm7FjtKBlYCIFlGliWieM6279uviT/wssU5r+OfcB+TDzuWPW+SyaxRo7YZpsiKDIyKXuHjuPfEbGPRYwYMd4XJCyLtuYGLMvElz5OMOsOxxBvdsenBWTDSK4pVVCYplVHJ+EC7Tgury5cRX1dhraWBnr68jTUp8kXygghcByXYqmM63k01Km76mTCJptOsHJNO20tjXR095JKJjB0nb5cAU0ILMtQc3QJpmmQTFiYuk4mnYxUCu8GauSi4tdr4+R1oYOUbHj8r2xZsxpNCMbOnEHz3rMHPm8718/UjagrBNWFuv2+eTTsugupyANDMniw5LdvYvOjj2NPnEC5owNj7DgasxkYPxZNEziFIkYySedDj9B0yMHKMMt1eeXnv2LOGadx35X/zeHn/wf2qFHRNnfUayJyQ0Xiet6g4DMZqH2UfDjMUwnfSwOu66CfS+UKrueRSQ0kwUopeeORx8lv7WCXj34EfVgrvpRUcvnomLWEjdC1bZ4X7mdnNciKOxYxYsR4X1CqVOjq7ccNSHC1d/mDl8Sh5KQg0YWGZZjYpollmoThYFVTK/Xc1uYG+nMFVq/fDEChWKG7t5/evjw9/TkMvTp/37y1m77+PEJKbMtk1bp2ErZNV28/y95Yr+y2kXR097F63SY2dXSzcXMny97YAEFBNJQC4e1CiKrNeK1ixJMeHj4jDj6Avc86nbrGZp7+45944OJvKTLldsZHb7ovBMOPPpLul16htGIlcsNGhD9EB2H4MBomTKBx3w/j+pCdPpXi+g1V4m2Q+lm31550P/lXANb/793s9cWzoaGBfQ/5CPd+/weDzlNEeSzbg/L6ULwRNSIaeH7h+MnxPBzHo1QpUyyXKFTKlCqVyI57KJiGQcKymH/rbay7fx5OZye+75NfvQbdddn9pBMw2oYBqsgTho5IWOjp5DZFRXg+74bI+++AuLCIESPG+4ZcsURPXz7wlxCRgqFaFCjSHYMXkqBlr8Ylimzo+1W3TA0R3bF6vofreSQTFq1N9RRLKjvEMpUUc0RrE0LTqM+mcByX+rq0yrgQgtbmelKJBHWZFIau0dSQpS6dIpNO0tbcQGN9lpbGOprqs2hCYNumSkh9D65NSKBESgzNwNSrlDhNaOiBk+ik447h49//LtMOOIiNDz4CUDPuoeorUUN2DbHm0SeihV3XNLZu3oLb10f3xg30PfMsr/ziV3T/7XmklCz67Y3Irm6KToXChvUM33cO+Vfm09XRgQg7BqaJrmkkWoehlSqsvPlPtB6wH75pUtq8mReeeYpPXXP127oO1Sh7xTnZjs8mvh+MQ7TQSTWw4/Y9Kq4TFYSDoWmCxbf+mfF7zqRtn7350WlnsPi2O3jmgXmMPfLwAUWCLyXS8xBxv/tNEY9CYsSI8b5CE4Lmhiz12WqmRLiohnfqtaMFtVgqopzvqzZ+7egkMsYUtWFi6i+6JiiWKri+T8JShYWGhut5aLpy5HQqLtL3MS0Tw9Dxg9a663mBg+PAPBIkbNjcSUNdhkw6sV2VxpthIN102+sjhOKChB2JkGlYm1UifMnTP/k5+53/5QGLoRaQVIcaCZyx7/789rlngk1INs97iIbDDsHQtMgaPbdkKV1Ll9O6x26UNrbj9vXRuWkTI2fvxdbnnsMbPw7Z38cuJ1bzSKSUdPz1afr7+hl79BHKYXXTJnLzX6PxqCPe1h19OKoJR2WDi0wCWStSmaIZmh4Vd7Km4NQ1DdMwVFCblGz92/PI/jwb29upa21l0tHBcVUqYG3rAOr7PpVKBTwfKSTiLXwqpJQ7raV33LGIESPG+wpfSvKlStSqDv0PNE2rIXQGNt2hb4MgWjBADFhrwrtVTdOAais/FFAkExaGrlEsO0QiEkATavHxPBdNF0FoWrBoCQLWv4ZESWWVd4VSk4wfPYy6bPIdFRXhOQ/4edD1UT4dGpZlYVtWJJ0Mpa8IFfu+60cOZO0d/7vN9e1dtpxnLruCZX/8E3LrVgBWX3cdx+4xk41330t+40YAli1bXt2mOjBS06Yy8uNHsfHRJ3jtvvtwNY2elWtINTdSbGqivnUY44aP3Gb80rz3XpgbNrLm9jvV9RveRtG0WHLnwON7M0R8BUT02svwBQ7It5HEVxPR48Kk17AADa9xbsMGFtxyK+vuuRetoZGWjx7C7qd8lglH1XQmaooK5aypUmjdYgm/VFak4R0ojHbmcUgsN40RI8b7jorj4DguSCJjIen7kW03EN11u56LkEHEOcHC63nbLulSzd1rfa/CIiNhW1QqeRzXBdNA4uP71U6EYRjB3W54g1xLZKwaeQU8yhovDBH5QGwP4VYGqFOCH0J78TDPY/BWwtAuLejQaJqI+AdogoYZuyO7upEbNiBqCJLP/fJ6srtOZ8IxR7Lg9jtpGtFG9sP7MvfUUyCRYMMdd1Mpl9i0cCFv/OVOtq5Zw5T99qftgH1VESNh1McOIfeXPjo7OvEa6/AENLQ0s+X116mbPRtnYzvWqJHI7m7kkuX0FgqMPuvzdL0yn8qSZZjTpjDisEOQf7njzd4K6tqE3iNe1WgrKhLCYLZAGhx2tYQUgB8ZnamQucDESlfcm8V33s2c886OuCAquRQ1ypFyyGKgkssjDEORg1MJ1SEZ4jWtLfSGIo3uTIgLixgxYrzvcF2PvnyRurRi5ocR60CwgAaLSi15IFhQh0wKpRpGFpIgXc8DX3UefD8ILau5M1cOjAJDN6J9h/4a1ZGMN2jBCJke4Houhm6gawK/RsUxGGFxE3ZoBh+9P6igUAWOhyMVIVUa1gBFx4BOgabRfOhH2HLPfaQWLsGauTtmWxuH/+AKhKbh+j5TP39q9PCQYjriU8dCocDyBQuY+unjmKzpdD6oLLsr/Xk6nniC1qOOoJLNMPvQg3n6mmu5/yc/Zbjn014pM+Uzx/PTjx3JrMM+xt5HfozsvvvQqKnr3LDXbPoefRJ7+jTa5z3E8Bkztnttas9JhdPJoGOjrhRBJ0IgkCLoJgT+F7qmDchA0TCiBFtdaDh9fSSbG9Eta8BrqLog2y8EddvG8T2EbQVeGWKA34o65vCVrEqgq+LjnQ/xKCRGjBj/EujL5dnc2UO+WMJ1q6qKiCOACAyx1KJc8ZSrZG2aafhhXm2hV0l8lmFimgagnu96HqVShVLZIbQVl1Ii9CpfQwucP0X0VdMhCI4tHNnUWoUPhbDjEo42hkJtUSGC54T714TaT+jdUL1jr/InRDC2aT78MKxZe7Lq/geVw6lhomkqHySUmxLtJ1BlpNMc/p1LeeG6X6nCKplm1a23Y5g6DbNm8sqvb6D9tddZ8sNreOrll5je0kZy5Ai6V77BFZ/8NH9FsinfR3b/D0PYRRAqbE2bNJ7+m26mZebu6FMmR+Zhgwuj8Htf+uiaUMer6VFxqIi6gXGaX31+GDKmDzIMMzSVl0KxxKZHnmDGpz+9TSfhzXwvojGa52HqBpZuYBnqGuqakhq7nuL/uEFRE3as3k1q7wcdcWERI0aMfxk4rktnTx/5wFeiFqER1lDrdninGCJsn4cyVQnKUClQBoR/L1dcypVQviijjWlCEUNDN0gBVcvwmlZ3bedAQyClr7oaQ9ythtuqhYDt3teGQWlCEHRsNLW4BQTEgGqiuBdBsRAWL5qmYWSzjDlgf+b/6Cc8/fNfUnnjjSiszdQNjNqujGrM0Pv6IiqFAhue/Ct2XT3ZtjaW3HIriZEjmXX2WRzz46vZYidocTwWL3iN5x54iN0OPJAsGjfdcQeTk+kBBUM4HshMGE+huRF9WFv0ioUFQu31AYIigciPJHytpKzyTTzPjzo9in8jquqWIDE3vK751atZe+99jDv2aERiW9MqQ1ccje1BMw3MRAK3UBzwejuei+MPrTTZ2RGrQmLEiPEvB13XSCVs6jNpErY1QOHhRlkfNYUEoRV38LihVmupWtSqKNBwPA8ZuGuCJGXbaJpGqVQmlUpExYah60EGWdX4qDZ3QrlA+gP4EZoQQWdhoFIlGu/4fjCrDxaq4P/DFnoY6hUqM6pjHVU8hEoJSbUTEnZhJBKvXEHzfHzX47K5c0kD9dl6vvrQ/TWXQ0bulT0vv0rXgsWUpMvu+x+AnkgiEwZLHnqYjg0bmb9mLScefTQOkucfeYw23Sa7/3703PYn1mztwq2vZ48TPsXWp59iaW8vZ/7sp5iJBEKAZZo4jotdKLDo1j+z2xfPVoVMbdck7AQFhYMvfdWtCRQcYVCcX5ONIgKVT2SGVbPody1eQnnNGsquR1FKJn/sMEzbjvY18G0hh/z94Me4pTKaoeNrYrsdp8HYWQ2y4sIiRowY/7JI2DbN9VkSCWtA4JjqKFQ9DTShRXe6IIMFaVAXA7UYRc8LiJqVikuxVKEuncKyDCqVCoZhDDBtEqGTZbA5Xdej4wlHI7XdCEngmOm6EUcjvIM3dSMaBYQFRHh37vkeXrB4hoRFieII1C6cQ0lHwwIkXPQMTccrFNn47PPY0kNzHIZ//JhoG7Jcprh+PZ2dnfQuWcGUk0+oXqeg21O9zpIwn+Vbn/8Cnzr2GEY1NPLg7/7AyITNVttmS8dWZh5+JJfc8AtGAF///tXYzU001GUQQOr1V8kMH47jVGj40JzouKNrVkPYDF+3WpmsL30VbCZEpBIydD0qLKSU+J7HoltuY8z0KWRmzULTVIEXXrPaYqX22r0ZQi+RSqGA1HXYwdTSnVluGpM3Y8SI8S+LUrlMZ6+kSWZJJiyEJjCEHt2tKwKdMtCKFpdgIQgRkuyieb4Q6AEXQUqJbggs26DsOBiG4jO4nocVFBYqP0TZh0eEPFnNMqn12wjhh8TMQeOPkEOhh7yMmhFMdTGvRrh7vqeKi2i3anGtLXrUGEZBmYkFoxPA1zTGHnIgPcuW427tiBZYKSUv/OJXNLcNZ9369ez71S9HxxgRYqORTuADEfAc5s79OCXPZ2vTMGRvH07TeDynwpq1q/GffAyAVqDrlVeor8vQ3tlD0hTstus0UrNmsPnhRyguXUFq+pTo+MPzjwq3gIjpBscQjbZ0ERUXEVdFUyoNKSWdDz3C5CMOJ9HaHHU/9OD6eQE3RcjwfeIHoXFDdzBqXzPP9/ARSNdFe4vCIiw0pb/z3rvGhUWMGDH+pVEqV+jpzyFlmlTSjvwKwmRSz3drZIfV+HREOJ+vLvphjyPsOPjBrNzQNcoVL7hbVioV01SSUy2QkVZ9FKqjFil9CH432JRKokY6YQFS9QoNxzbV8U2ISForAm5IeOxCDHiWqNmKlD6uHBh8JgC3VEZ6HlsXLOSXF36dk79xES1BEbLk3vtpbhvOmOOPY0zwnJsv+Br7f+jDjD/xhODcBulVfA8pBHseexRr75mHZZuM2306C9ato8GXzD3ko4w86EAO2LSZpklTSE4YT0VK7K5eGhe+QqquDiEEbYcfxurb7mDCuNGIZLLa8Ql2E3l0aCIqsFQREEbWS4QUGFrYg1KF3DPf+28aJk6gtbU5uDrB+ISwY6SKlaCpFfE/wnMNjdBAGbJ50o8KSOl6+JUKRjoVdUjCx3t+tcNSO87Z0TC0f0fE5M0YMWL8y6NQKrO1p5fe/rzKFlEygahzoYc+zoHCofYmVNYQBbVg9FDNwCDwOdAxdY2y4+J7Hp7jROTN6qIzWF6ouBqhvNDzVVETFRk15MWQpBl2AzzPG7DNwXyDwRkdQp3IwL+plkvNgisi/odbKiv/BV1HHz6cr9xwA4V161l5+x2sufd+/K0djP7kxwdc48nDhnHz73633dcgVDqYpsFt993Nqj/cyA+feJzPf/cylnR2kgB+8v++Q2HRYipb2hkxspV0wmb6pDFMPumzdKxeHZ3fuE99go6HHkH291clv4SEVQ02tkfFY/gF4RgosHmnynVZcMufGVPfwB4nnRhdM01oAUlVj17jkLOizqf6egHR66eeW1X/SNdDOg5aKokU1YIlfFxt/eD76n0QncdOiphjESNGjA8MTMOgLpMklUhgGjqeDFwwg/FFyIWoWY4DyAGdC0OvqkXKlTKgDLf6+vPgeXiAbRiE3lWGruN5HqZhYNkWQoD0letmRCisWfhDoyxQ62b4MasF3RbX9yIOQ1XCKqMCITpqWe1wDDTpIhrrDMlT9TzcUhkzlcRxPTzXBcfBr1ToXLqc1n1mDyxagCsPOoTpu+3KJ6/7WfB7VQoN9UEpENz55f/gxddfZ9fZszjqiKNom3sU++9/IAngui9+keknfgZZY3tdWLWKnsVLGDX3GKWqeOkV1r30EtaI4Yw+8ABoaEBK2HDX3WxZuxE/nWDapElkP3LgwFFWAC8geEopOXP/A/nNvAfQ6uuGOFoGFIghobZ2bERwpsrNVeLV7Ev4Es2XYBnbkDarg6KBrxeo98LOSt6MRyExYsT4wEDJUfspp1yaG1RrvaevwKatXdiWxYi2JixTZ8OmTrLpFHXZJH39BUplh9bmenr78kgJvf15HMdF0zVam+oxdJ3u3m4a6tL4UtKQSSElbO7sIZcvUpdJk0nZrFq3Gd3QqcukyKaS9PTnaaxLg4Cu3jxJ26Kzpy9YsASjR7RgmUZUbABB50SjOtpQ8Hx/G9ljbRYIg4qOwY+p5SoIw8DKGFHBIgVoyQTC0GmdufvAYiSofMxUimLQ8QgJmyFp1PMHOptKJJ/6+bXsctPNWIUid954I+d9/Cg+BrwCTDvps0itSqoESE2ciOzqQba3079oKfq4sdR/5jMkyyXa//4Kadti0dIlDN9zFnvMPRoch+4lK1h90+/Z43OnbXPu4bgIBF88+9wh8z0GXydN6GgBD0cT1c5WyO8QQuJ6ilMTGV65Lj4ChuBMDP7Nzuy2WYudt1cTI0aMDyzyxRLlioPn+by8YDm5QoliqYzreuTyJV5bvIrFK9YCsGlLF8+8tJDunhwbNnXQ0d2LELD0jfWUKxWEEKxYszHajh8oR95Yv5k31m5C1zU6e/ro6cuztn0LmqaxZOU6Onv7Wb56feDaKVkeRKprmsbmzm7WtW+lUCxRLlciaWfFcVWYGFBbVIQL1FCmUdXHyG3uiLeRTrLtc0VNQaObRrSz8JkyKFq+Pu8+Tvn5Twd0TZQaRHVsdKENcJP0pWT6505hyhfP5rNf+Q/+ev5FXHzfveyRStG9ciUi6ArVHqM+so2NN/8JZs7AHTYMU9cpWTaJfebg7rEHE477JKlJE5W3hG3TvNt0snUNMEBFM/gLZn7qWJ6+6ffbfb/UdpJqi7wB46aAj6NMxKoOn6Ztq4C67bipDt0z2rkRdyxixIjxgYOUkq3dPdimRXNjPT19/aSTajyy/I1NjBk5jM7uPvr6i2iaRn0mzdJV69F1QSqZYFRbM2s2bGHM8FaEgP58gfFjhrNhcydTxo/CdX02be1i2oTRtLbUI33Jls5eDMMglbAxDC2ax3teKBFVZM2kre6cd5s6nmTCDlIxHQAqjqu6A6aBZVlYpvoIDjkUPlLlVtTIU6snXR1MDNWloLqlAdfJ8zxEYLBlIHBEtLmaTdd0O4TiCoTskJBrEBIpQzlqZL0tJfUH7o944UVKzz5HdvhweufPp3HSpCgBNPf6QrzOTgrlCs1fPJvyi/NJzNkLO6XIm1VuQg2PRNNUnP2UyTz5wx/TOm40KSvB+GOPiYqWEL2LljIuMt96cwxVkIXXKpQzCxlyJGpURr4ETY2fqhbiEl0IHN/bdkc7MeLCIkaMGB9IeJ6Pb0ia6rO0NNaxaMUadF1j/aYOUgmbYqnM6vWbSSUsRrY1AYIFy1bT0tRQZfEj2bipk/5cAaSkuy/H+FFtaLpG0rbp6O4jnU5QLFXwfZ98ocTq9ZtwHI/mxnrWbthCb38eX6IkrBKWrlrH+NHD0YRGvlghmTAxLRNdE9i2he/7lMsO+UIRI5tGj+7sCf4V0SKrUZWVEiz4tW3msEOhUj23TaeQgNA0dF2L7sB1w8QtVxCGgfR9hGkEXA31P8/3I9VJVc0iIhVNeGcvBBFRESQHnPV5ltxyK5895KOMPewwnv/5r2hubaGhbRjpbIbsIQdTJ31y+SJy1p5YyUR0vrou0PVtG+hCCBp2nc6HRo/CTKfZcsddrLj5FiYdczRacxNSSkrr1/PDb36TK/58y7t+T4VW6QQjkZC/oyUSUCrjV1wwdKSuRQZqtRMSEbyQOyt3MUQ8CokRI8YHF1LS0dPLG+s2kU0nEcCYEa3sPWMq+87eFd/30XWddCrB5HEjGDOilYRlogmN+mwaEDiux5yZ09hrj6lMGTeKUrmCoWmMHTWM/nyRlxesoH1LF4ZhMGHMcGbvPoXG+gy+7zN6RAur129m7YbNjB01jO7eHBXHZXNHN2s2bKJUKtPZ3ReoWVSxoOsaqVSChG2RyxeC8LOqa6iyLZcRybDWGjv8ueb0I/XK9q5PaFkdyiSNhI0IDb48DwLVQ1hIRETTQDLrB/JaVbgI/C1bWXD+12h/9Akl/XUcVt/xv5SXLGfM3nMY/qljOffjn6Bp+DDq6utYOm8eZksLAL6nDMlSCXuH+AjhudvZDF6pRKq1lYmnnETPM89SfGM1G+97gN5ly/mPCy7AaG19J++gCKGSQ6LUL0qK7EU8Fd22MJMJcFw0zw+UPVXPEXXNlL26FahRdlbEqpAYMWJ8YKEJgWmaNYsvICCdTNCQTUdmSkDU4g8sLnBcxYfwfT+Kavd9SXdvP/lSCRCYulIdJBM2hq5hWSa2ZeK4HvliiXyxhAg+SUJVRy0l05MS13URQpBJJWmqz6AHsd++L8nnixi6TjaTivwPatUaoT9HrXLE92WkOqk4LrZlIiDqfNR+pruep+LcQ+VDpI6oKiSk60EQHx/xIqjxeYiKCnWOT138LfY69KN0LF2C09jIC/PmMXr//TjwvHMQCBzH5UsfOYRfPfVX2h94iFRTPf2btjD2U5+gN5dHk5DNpne4sAhfW9916Xp9AXWTJwPwxgMP0TptMnVTp9Lzyqs0zN4Tv1JBsy28UgUjaeMWSxjJBF6pjGZZSNeNAtLwfYSh4zsuumXilSvotk2lWESzrepzK47ipvjKs0QIgVcq4yPRsxlEEHyma1oQWlc9L8tK7JQEjLiwiBEjxr8dhBCkkwkSloVh6NiWia5rA7wo/MjcysfzZbSYbu7soVAsDbld09DJplM4rkuuUHrbLe9sKklTY12kvBBCUCqV1THadsTbCKYL6k45sLUe2KmQVByX3lyBhrp0ZP8NIeFS4AeunYNdOmslk1FxUXZUwWVV5aFG6EoZHEuY4lq7UvYvW866l+eza2CqBeD099P9wosM++ghSCkpL1rC6sceZ/q5X6Cn7JC0LRL2mys4arHNNR7imruui2EYVfsxqUZABJLcUFUzhI6DQA4SPVb6fpBU6kXXXRWMSiVj6AYgKffnIGEjgvdVaNgmAm8UoWnYcWGxcyEuLGLE2Hmgaxq6rpOwTbLpFLqmUXaciDeQKxTxPIlp6BRK5Wg88Y9AXSZFU0O2ao6FoLcvh21bJIdI34RtyZohShUHTahuRb5QoliukE0lsW0TpBq7bJPHUesFETpMuh5+uYxm2UhDPScMQ1PSzGqmSW0SbLgpXVdFyJa/Pc/3L/wa37n0EuqPPjra34pbbqWxrp4+JGOPPCKIr98xVL08lES09hzCc3McN9pmrXqkdhvVALqhyZu1jw3txAdDILAMHadQQjMMfF1EIytDU52o2qyWZCIVFxY7E+LCIkaMnRNqli4CMySFf+bnoBCChroMjXUZ1TYXAsdxyBdKpBI2dpDmWovaxVXKQfknwQimXHHY0tVLKmGTSdlYpjmk+2MYVhYOXMIRkee5ePkiWtJGGEb4YHUjr6kxk6kb0TmExxOOZsLfvXbbHeyx34fRRo+KujIA5bJDLpejri6rLNW1N1/gB597uF9f1sp11fF5rosZKFBCO+3B2w6tt2uDzYbaR4iK5277e99HVNToBF0foJYZDIEgk8rslIVFrAqJESPGTgUlwXz/7iuklPT257EMnXQqiQwIpvXZNIVCEc/zsG07UklUF/Ew3ExE1uCRmkMILNOgqT6juBvFMgiBbZrbLKKhj4OUNd8LXxE6TYNo2CElXrGMVyphNtSBpqmCRKgguNBUStcE+D6bH3gQISVZKXElWDXHXiqVKZQq1NVnMXQd3/fxPKIxzfYKjNrCKTr+sCQKzsHz3AEFVDjwCJ/hSxUSNzgobsB+kIG9t5qK6Jry7XBlTddCSoQvwdDxda2mwNn+NndWxKqQGDFixPgnw/d9Onv7KZWVQVc4qkmnU+i6TqlUolAoUqk41bFM4Bapaxqu61EqlXFdN0pY1TSNVMLGMnVMQ4+6C0Oh1hQK1KjI0g1M20YXAt9x8CsOuqZhmCY4XjSCiBxEa1QrXlEVRC1HH4lj6fzw4v+K/l4qVyhWHOqyacwgjl51LBTPJMzr2JGu0eDHyLCjUnNMtQZYUM392N52Qh8NX0o0rcpV0TUtUNNUyxq3WMLXquOPGEMjLixixIgR432A63p09+UiwiaoO3jLNrFsC93QcVyHnr4cfbm8CsmSEsd1o3thz/Mi++1wsdQ1jVQygdC2bzEtEIGKodoNATAsC8Mw0Fwf4flgm2iZlIpQrwllU8+pUZYkEgw75kgAJs79OMVNW5FSkiuUKFUcsqkkRg3fI5R2hkqWULo5lGtoKJPdnp15beBXbUBYFKuOIqm6nofne7j+tvsKr5/vqzFR7bU0dQPTMNAl6Am7ajgSY7uIRyExYsSI8T6hWCrTXyjRVJeJfhcu+oauY1sWCdujXHHI5Qqq6DBNpPTRdKX4cF0XMBRXwlNyWl0TA8YHMFC6OYDYCAEXIjDk0nXsbAakxA/JiMkEfrGEpuuU80XMQMGiFtpqoSAAzdDJ41PY0I5TV0d9Jr1dPkVtUeAF4W9ajTx2qMe/GbQgbXZwd0UTGkKT1YhzMVDfEqaehnwJ1/dUYq4gMgUjcFeN80DeGnFhgUpMzGbSFIpFSuUKuq6RsGwkkmKpTCadwtA0evr6t5maaUKQsG0kUCqX3xMSmKHrJGwbX/qUypUBdzTvBRK2he9LKo6yGbaD8J5ypfKe7uedQNM06rMZXNdFCwxmevv7/2n7TyeTWJZJX38Oz/exTPVB7noujuNSl81QcZRr4mAYuo5tW0hfUiyXIsZ8wrbwPB/HdaOfQ5ljpeJgWSZCDPwg9XxPMd0NA9syqThu9HrF+PdCf65ANpXANIxo0QoXViEEhmGg62q8kcsXI+lnqPjQdR3P8xUhVfpKueFLdC003JI1MlaBDB4b8RtgAP8gkrYGyhBNV8mxBIoVw9BVNeL5IFVgl15zvFJKpo0YSTmdIWEab0nSjMYxgWeI6sLIbTgmQ0FKGflIRGTWcKxRU0CF/xr6tqZVIpCaGpoedTPUV5VfoWsahm3h9udA10GLi4s3QzwKAaZOGMf8F//OqLY2hjU3MaK5iTeWL2X9G6uYOn4sjZk0K5ctZVhz04Dn1WczTBwzio1rV9PRvoGp48eSSaXe1bG0NDbQ1tTAkgWvsW7VSsaNaGP6pAnsMnkiTQ3172ibI9ta2XXyRIY1NzFyWCtOIU/aMqjPZmhtakT3XQzp0dzY8K6O/e1gzIjh7Dp5Is2Dzqm5oZ6lCxeQti16O7fS19VBJr39a6oJweRxY5g+aQLpVPJdHZNtWaRtkw1rVjOsuYmJY0Zj4rPotfm4xQLTJ02gfd1aUqYxQIcvgBHDWmipz7JyyWI2b1jH9IkTSCUTjGhtwSsVaWtqwLYshrc045dLdG1uxynkmT5pAgldo2tz+4CvhlSSXSZNIGObLFu0EFuD8aNGvikBLcYHExXHob9Q9c0IOwqlckWFqhWKSv7oSdKpJJVKhXK5QqXi4Ht+xFMIVS7Kw8KnXK5QLpcplyvkCiUKxbKy00bdhbvBGAWUbNR7E66DoetYhomh62i6gW6aCE3DK1cGkSklZcdheT6PZVskdtBhs/a8DUN1X9wdkPzKQEIafl/rWBqd46BOTe3XNvvWt1WMhNtGCKxUElksKcdSqTJEpB/8G/wcI5abkk2nWb96Fc8++ywXXvg1/v73F7j44ov5zGc+Q7lcZvPmzVx55ZWceOKJ3HTTTaxctwHf97Eti4Z0khNOOIHjjjuOUqnE448/zp133onr+2TTaUB1ATZ1dFIolmhraaKpvp5SucKmjg7qMmma6tXCWqk4dPX2okmfT37yk3zhC18gl8sxfvx4jjnmGObOncv9998PEFXjaoZZIGkn0DTB1q5uOnt6aGpooLWxEZB09/bR0tTIkUceybx58wA49NBDGTZsGL//wx8wdJ299tqLOXPm8OOfXIvv+6SSCUrlMps6OknaNm0tzYD6D31LZxfdvX3RdbQti7aWZrLpFKVyhc2dnWRSKZob6qNtZJJJWpoaARV73dufo6WxYcAx+b4iTgE89thjzJw5k/vvvx8hBKeeeir5YpEtnV001dcjBGzp7Ka1qZH6bIaXX36Z22+/nSuvvJLO7h50XaehLkuhWGJTRwcNdXU01ddFx1yuOIF7osumrZ305XKAKna+838v5Stf+Qpjx43je1deyZIlSzjssMNYsGABhxxyCLvvvjtXX301l19xBWs3bgKgtamRV178O1dffTXHH388PT09+L7PF7/8f0hYJnvssQcnnngiX7ngQkzD4NSTT2KvvfaiUCgwf/58LrnkEp5//nmefPJJ6uvr2XPPPTn88MNZvHgxt956K8ceeywPPfQQhxxyCJ89+WQ2bNryD/gvIsb7Ccs0GNXWgmlUm8gr17ZjWyar1rUzccwIunr6aahLg4S+fIGkrcy/DN1AaErOWZ9N05cvIH0VdJawTPKFEm6Qc+K4LiOGNavuWyZJJp2k4riUKw5CaAh8spl04OzpUako11DVVROBEVVgBCXBKxQxU0m04LiLpQq5fJ5MOkViCNns24HnecghvDigSr50PS8qBkI79FoZcQg9sDDfEfjSH8BjCRE+3y9XkK6HMFSHxa+4GAkLr+KgJRNIUe2QZFPZnbK1sdOPQuqzGb5z/fVcfvnlCAH/+Z//yc0334yVTCGApoZ6PN/ngAMOYN68ecya8yH6cjka67P88Ac/4LzzzuOIo49G1zQSiQTXX389c+fO5ZtXX02xWKRYLPLDH/6QcZMm8POf/5wXX3wRTdP43ve+R29XF5d9+9vkcjl6e3v5+c9/zoKFC5kxYwZnnHFGdIx33303ixYt4oILLuBrX/saP/jBDwAYN24cBx10ENdeqwqCc845h4MOOojHH3+c//ztb/F9nwsvvJAFr73K4sWLueCCCzjnnHMASKfTdHZ0sGrVKmbMmAGoFv13vvMd1q9fj+d5XHXVVTQ3N3PmmWdi2zadnZ1ccskltAwfQU9fP6ZhMLK1mYsvvpj+/n5Gjx7NZZddxg033MDjjz+OYRj893//N4Ym+NKXvoTneWzZsoWrr76a5599JjqmCy64gKuuugohBKNHjyaZTDJp0iQA5s2bx+OPP45t2/zoRz/ib3/7G7lcjo8ccihPPvE4yWSSp556iocffphiscjVV1/NVVddxcKFC7Ftm6uuuorNmzfz//7vpfT29nLKKadw//33k8vlsCyLa6+9lr5cDiEESdti6dKljB8/ntWrV/Poo4/y6KOP0r5lK5/89PGkkgkMXWf58uWRjE9KSWtTIxdffDGPP/44xYr64G2sy1JxHO677z7OPfdc7rnnHr797W9Hjo7nnnsuw4cPZ/bs2ey9997stfcchBCMGTOGI48+hkwqyWmnncaLL75Id1+O008/nTlz5nDyySdHbPoY/z6oOC79+SKNdZloUWrIplm2egPZdIp17Vupz6bp6OqjP18gnVIju86OHizLpFxxyKSSdHRXi35D1/GljxGMGMLxytqNW3Bdj0w6yZRxIyg7Lqmkja5p5ApFHMfBMk3KFZdyuYKha5QqDqahU6o4NNdn1djAc9FMQzlcohb7fLFEwrLedVEBatwTklPDtFfpR96agSvpoA5eUA0oa3cRnffbORKBwNANXG9gcRFlt2gaUvMhGNXololEFR5+qYQIwtV2Zuz0hUU6mWTlypWMGjUKgI6ODkaMGMGSVasB2NLVTSqZYObMmcybN499DziQvhxYpsWrr77KOeecw5bOLgzdYJ999uGGG27gkEMO4dVXX+WJJ57g+eef53vf+x5nnXUWCxYs4De/+Q0vv/wyV111FaeddhqLFy9m3rx5/OUvf+GWW27hvPPO46abbmLOnDnss88+XHLJJcydO5frrruOH/3oRwA89NBDPP3007S0tHDYYYdx7733ous6xx57LPvuuy9XXHEF8+bNo1KpcNJJJ3HXXXcxffr06PkAp556KjfffDMrV67klFNO4fbbbwfgkksuYevWrTz00EP85je/4aKLLuKBBx5g5cqV5PN5Tj/9dO648056+vpprK/j2muvZZ999uGUU07B8zw2btzInXfeyT333MMzzzzD5Zdfzre//W2ee+45XnzxRZ577jl+/etfc+WVVw44pocffpgnn3ySYcOGccEFF1AoFABoaGjgpz/9Kddddx1//OMfyWaz9PT0IIRg06ZNZDIZ5s6dS7FY5Hvf+x7z589n0aJF3Hjjjfz5z3/m2muv5ZhjjmHBggU8/PDDtLe386tf/Yo//elPaJoW8R4s02TZsmWMHTsWx3VZsGABc+bMobOnl+6+frr7FM9jRGsLEyZMYMmSJaTrG6m4Dvl8HtM0sewE67esB2BzRyeTxo7m97//Pddddx29vb089thjHHbYYQBcffXV5PN5Zs6cSSqVYtPWzui1KZXL9HR1MnbsWCquR2dPD4mExS677MKKFSuoa26hVH7/+TAx3lv05QpkUskoSr0um8K2TMYMb2H1hs00ZNNsKlfIpJM01CmuT302TalcIZtO4roeTfVZjOBO2jIN2rd2Mby1kb5cISB6quyQ7r4cDdk0ni+py6ibKD9QRfTnCqSDDmQ2ncQ0DIrFEvlSWfF9Ko5ShHg+olxBtyzlHRHwI4zEuy8qIEw91XE9DxFsO0qCBdVhGbQfTdOi+b7v+you/i2cNofarwZDFhcAwtARxhABY7qG9iYS350JO/1VEFpV4xxWxqBaZwI183c8D9M0qVQq0RvU8zyam5vp6OigdcQoDEOno6ODpibFw5gxYwZ9uTx77rkn3/3ud1m0aBFLlizh/PPPR0rJ9OnTAdh9990plsqMGDGCRYsWYVkWv/719YDk9ttv50tf+hJ33HEHAP35Atl0irFjx9Lc3EypVGL58uX813/9FwDjx49ny5YtrF+/nq9//esATJkyJTpXx3EpBwTAfffdlx//+MdkMhmGDx8OKL/9z3zmM8yePZtcLocTPHbq1KkgNFpbWykWixHZ0zQMFi9ezAknnMCKNWtJ2DZrV69mjz32oLuvn9mzZ3P55ZcDsOuuu1KuOIwYMYKenp7omHKFIplUktGjR9Pa2kpnd/VvAHvuuSc9ff3sueee3HvvvcyaNSuYl7LNXXul4rBixQpmz55NV28fs2fP5oEHHgBg1qxZdPf2MXLkSA4++GA++clPMnbsWH784x8HH1LgOA6maeK61dfWDrITUskE2XQaoYnovZAWyr0xlUqRz+exLRMt+DAcMayF7q4uXnjhBa655hrWr1/PihUrosJi7ty5dHZ28rvf/S46nxCe59PY2EhnZycJy0IINXLq7OykqamJshd3K/4dUXEc+vMFmuqzwbzfYI9p49E1ZZ6l6xrNjXWRtXauUFBGTrqG6/mBisRUqofA26G1qV4RouvSKtAsIFqOdl10XQ+suBU0IJNK0tOfoxR4WISE0mQygdA1crkCrusF0lE1NpDlCqHJt1rM37vuv/L40HEcZ4CCZHuPhcEeFT6IHU8ZHejyWbUw3xGzKykl0nHQrJ1+WY3Jm8ViidbWVnp7e8kXSxx//PF897vfZfLY0Ywd0cZLf3+BEa0tLF++nN122y1i5ueLRc444wwuv/xyhjU1kEnYXH311Xzuc58D4NlnnyVpWzzxxBPMmDGDWbNm0djYyP/8z//wox/9iE9/+tPAtkY1GzZsoL19I4ZhMHHixMgSt1wukw5abKoVLkkkEkyePJmLLrqIa665hu985zsMHz6c1tZWLr30Uq655houuugigEBloRIWw/2de+65fOUrX4muxdatWzEMg0svvZTWmgji119/nUI+x6pVq6ivr6dYKgPqg3Cfffbh3nvvZfK4sTRk0kydOpW///3vZFNJHn30Ufbcc88hzxOgUqmQCpjmqtW57evzxBNPUJ/NRNexra2NFStWkLBtnnrqKQBSqRTd3d2YpsEee+zBE088QUM2M2D/oWY+7LrcfffdtLe3097ejmEYVByXyZMns2bNGjRNMGfOHJYsWcLC119n18kTEa7D+jWraayrY/Xq1UybNi0qvArFEgcddBC//OUvmTZxPMObG/n788/z+9//nksuuYRzzjmHyy67jPb2drq7uwFVrB119NGMHz+eefPm0VCXjc7Z8z0sO8HYsWO599572GXSRP727LNIKRk5clTUZYnx74e+XIFyRb2vhCAwlBKYpjKWsi2lUtJ1DSHBdR2kBNf3SSaswDVSwzCUZbZu6Pj4QUiZQNMIClUT09C3uZu3TINUwqbU2086YeFLFcYlgYRl0VCfJZVKkE4lSSWTmKkk/YUixXIFJyw43tbg4a0hhLoBDI203vrxtQTNHV/iwowQx3OpuC6O5+FLX5mXiR0YpwiBZttIb8eO898ZO31h0ZfPc+KJJ3LPPfdQrlS49NJLGTFiBJ///Oc599xzMQJS0qOPPsonPvEJcnnVou/p6+dDH96X8847j/POO48LLriA7373u0yZOhVQnYLzzz+fBx54gIsvvpiJkyZx5plnct5553H22WezcOFCGhoa2HvvvfF8n9bWVmbOnInneVxxxRWccsop/Pa3v+Xaa69FCBE9d82aNRx++OF4vseGzVu4/vrrufLKKznrrLO4+eab0XWdX/7yl3zzm9/krLPO4q677gLgK1/5Cl/60pdYsGABRxxxBJqmMXvOPkyaOo2Ghgb23XdfRowYwV577cVZZ51FKpVizpw5gOo2fP/73+eKK67gmmuuYWuXWhy7evs455xzyOfznHnmmfz0pz+lpaWFCy+8kHPOOYcnn3ySb33rW9i2zYEHHojn+2QyGT784Q8DcPbZZ/PFL36R1atXq3MKGNxz5syhvr6eiRMnsvfee/OFL3wBx3E4/vjj2X///dE0jbPOOot99tmH8ePHM23aNCZMmMC5557L1KlTOf744znrrLPYsGED5513Ho2Njey1114gIJfLcf7553P22Wdz8MEH09bWhuO6KjrbtKirq6NULNLZ08tdd93FHXfcwUknncTVV19Na2sr/f39pNNpLNuOzHfat3bw4x//mFKpxKmnnspXv/pV0uk0juPw+c9/Hk8zyNQ3cOGFF7Js2TIOPfRQkskk7Vs7+MY3vsGyZcuwLYvddtuN8ePHI6Vk45Yt3Hjjjbz66quccsopPPTQQ/z5z39mw5aYuPnvDMd16csVhiQghgjVD3bCBl9SLJbIptRNh+M40d8lanwgfeVHIZG4vk/Fc1WxMGjxC1UhCdOgIWWjGTqu5wfih+o21UKvvCYs06S+LkMmlcA2dcV5+AfQFTWhbgx2hFukCgQv+n7w3wYrX0LS5wDzrNALA+VpIZGYuqFyRrazXyEEPhIc9x9xCT5Q2OlVIZoQTJ0wjp/97Gece955rFq3geaGelKJBBJJuVzBNg1uvfVWPnvSSZESIERTfR2ZdAopJf35AsVSmVJ/LzfeeCNXXXUVvf05Orp7KJfLNDXUk82kERDMPJW8qaO7h4YgmKdcqZBKJLAti3KlQk9fP8Vymab6OmzLUqQqp0JvX458UY0RGurqsC2TfKFIV28vtm3TkM1imQa5fIHuvn6y6RQJ28YwdFzXI18s0hPwBloaGzBNg97+HPXZDKlEAss06e3P0VhfxxFHHMGDDz5If75Ad28v/UFxBUrT3tLQQDqVpFSu0NndQzqVpC6TpuK4dHT3kEomSNgWXT29ZFIpLNOku6+PTCo18Jz6c1QqDi2NDXieh9A0murrcFyXfLFER1c3QghamhpI2gkMQ6ent4/uvn4a6rKYhkGhWMIwdDLpFKVymc7uHuoyGUzDiI6lPpPBNE1yhQId3T2RZXImnSLX3cXGjRuZOXsv+vN5GurqSNo2ZaeCoRs8/9yztLW1Ud/cMvA66DpNwfumVrbXny/Ql8uhaYJhTU0kEjae55MvFOjq7aOxLksymSBfKJK0baSUbOnqDmbkJk31dSQSNqVyhe7evn8Jr5EY/1jous6IlkaSg6SaoZQyl1cES8PQ8RyXZCoZpaKWyxXlMyHCgC6JqlGqUlSpPLQiH4twYQ0fJSTgeWimEQWeBdZQkctnGOWuLCDU3xzHpVAogqaTStrYpsF7wbWQUqrxS/DZpevbN9CqdQUdkC9SMyYJ/xaeS+hbUb0AA7cZEkHDMZKSsW7LvYj273n4xTJGOkUmU7dT1hg7fWEBkE4laaqvoy+Xp7c/t81jh7c0o+s6mzs631Jbres6o1qbWb9+PY0trXT29L73B/9PxPSJ43nppZeYMn06Gzdvfb8P5x+O1qZGLMuko6s7akmHsEyT1qZGKo4TdW1ixPhHIJtO0dbcMGABlVLSly8gEKQSNo7r4rpu5PPieh6u62GaRo2fg6yOIRGK/yCrEeJe8PkvwpRTKdEQuLk8ZjqlgslqxpiO50bfV/0rFC+oXCqrWPGERX+hREMmHZlcvVNIWQ0HM4wwvMxXxRPbmmdVOythQRCe27aPC28APOlXvTCCf8NiQgtcUAefd3ittpcZIn0fP1+koW14XFjEeM8wDRgOPAN80AfiI4HdgaeBwls8NkaMGDFi7OSIC4sYMWLEiBEjxnuGnZ68GSNGjBgxYsR47xAXFjFixIgRI0aM9wxxYREjRowYMWLEeM8QFxYxYsSIESNGjPcMcWERI0aMGDFixHjP8P8BZSrlGLSq3uUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph successfully saved to 'sfbay_2_graph.pkl'.\n" + ] + } + ], + "source": [ + "############################## Download Networks ##############################\n", + " \n", + "G = combine_graphs()\n", + "\n", + "G = ox.project_graph(G, to_crs=\"epsg:3857\")\n", + "\n", + "plot(G, f'{studyArea}_{str(simpl_intersections)}_original_graph')\n", + "\n", + "G_final = G.copy()\n", + "\n", + "############################## Add Attributes\n", + "\n", + "G_final = ox.add_edge_speeds(G_final)\n", + "# G_final = ox.add_edge_lanes(G_final)\n", + "# G_final = ox.add_edge_capacities(G_final)\n", + "nodes, edges = ox.graph_to_gdfs(G_final)\n", + "edges_freight = update_freight_script(edges)\n", + "G_final = ox.graph_from_gdfs(nodes, edges_freight, graph_attrs=G_final.graph)\n", + "\n", + "nodes, edges = ox.graph_to_gdfs(G_final)\n", + "print(f'Nodes: {len(nodes)}, Edges: {len(edges)}')\n", + "\n", + "\n", + "\n", + "############################## Consolidate Nodes\n", + "\n", + "print('consolidate intersections')\n", + "\n", + "G_final = ox.consolidate_intersections(G_final, tolerance=simpl_intersections, rebuild_graph=True, dead_ends=True, reconnect_edges=True\n", + " )\n", + "\n", + "# Update length\n", + "nodes, edges = ox.graph_to_gdfs(G_final)\n", + "edges['length'] = edges['geometry'].length\n", + "G_final = ox.graph_from_gdfs(nodes, edges, graph_attrs=G_final.graph)\n", + "\n", + "\n", + "#Plot\n", + "\n", + "plot(G_final, f'{studyArea}_{str(simpl_intersections)}_consolidated_graph')\n", + "\n", + "\n", + "############################## Simplify Network\n", + "print('simplify network')\n", + "G_final = ox.simplification.simplify_graph(G_final, \n", + " edge_attrs_differ = splitLinksBy,\n", + " remove_rings = False,\n", + " track_merged = True,\n", + " )\n", + "\n", + "\n", + "plot(G_final, f'{studyArea}_{str(simpl_intersections)}_simplified_graph')\n", + "\n", + "############################## Truncate Network\n", + "\n", + "G_final = ox.truncate.largest_component(G_final) \n", + "plot(G_final, f'{studyArea}_{str(simpl_intersections)}_truncated_graph')\n", + "\n", + "plot_graph_by_attribute(G_final, attribute='highway', title=\"Network Colored by Highway Type\")\n", + "plot_graph_by_attribute(G_final, attribute='lanes', title=\"Network Colored by Number of Lanes\")\n", + "plot_graph_by_attribute(G_final, attribute='mgv', title=\"Network Colored by Number of Lanes\")\n", + "plot_graph_by_attribute(G_final, attribute='hgv', title=\"Network Colored by Number of Lanes\")\n", + "\n", + "# Define the file path where you want to save the pickle file\n", + "save_path = f'{studyArea}_{simpl_intersections}_graph.pkl'\n", + "\n", + "# Save the graph using pickle\n", + "with open(save_path, 'wb') as f:\n", + " pickle.dump(G_final, f)\n", + "print(f\"Graph successfully saved to '{save_path}'.\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "98eda2af", + "metadata": {}, + "source": [ + "# Save Network for the Simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fa52c30d", + "metadata": {}, + "outputs": [], + "source": [ + "# Save GPKG\n", + "\n", + "ox.save_graph_geopackage(G_final, filepath=\"SFBayArea.gpkg\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1cce2da6", + "metadata": {}, + "outputs": [], + "source": [ + "# Save OSM\n", + "\n", + "\n", + "\n", + "G_final = ox.project_graph(G_final, to_crs=\"epsg:4326\")\n", + "save_graph_to_osm(G_final, filename=\"output.osm\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9b0b2194", + "metadata": {}, + "outputs": [], + "source": [ + "# osmium cat sfbay-unclassified-partiallysimplified-unprojected-sfres.osm -o sfbay-unclassified-partiallysimplified-unprojected-sfres.osm.pbf\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e57b0fd8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d620c70c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/main/python/network_validation/__init__.py b/src/main/python/network_validation/__init__.py new file mode 100644 index 00000000000..8efceb33052 --- /dev/null +++ b/src/main/python/network_validation/__init__.py @@ -0,0 +1 @@ +# python/network_validation/__init__.py \ No newline at end of file diff --git a/src/main/python/network_validation/_data_collection_utils.py b/src/main/python/network_validation/_data_collection_utils.py new file mode 100644 index 00000000000..25420e1e44f --- /dev/null +++ b/src/main/python/network_validation/_data_collection_utils.py @@ -0,0 +1,435 @@ +import os + +import geopandas as gpd +import pandas as pd + +def collect_census_data(state_fips_code, county_fips_codes, year, census_data_file, geo_level='county'): + """ + Collect census data at specified geographic level (county, tract, or CBG). + + Parameters + ---------- + state_fips_code : str + FIPS code for the state + county_fips_codes : list or str + List of county FIPS codes or comma-separated string + year : int + Census year + census_data_file : str + Path to save the CSV output + geo_level : str + Geographic level for data collection: 'county', 'tract', or 'cbg' + Default is 'county' + + Returns + ------- + pandas.DataFrame + DataFrame containing population data for the specified geographic level + """ + # Validate geo_level parameter + valid_levels = ['county', 'tract', 'cbg'] + if geo_level.lower() not in valid_levels: + raise ValueError(f"Invalid geo_level '{geo_level}'. Must be one of: {', '.join(valid_levels)}") + + geo_level = geo_level.lower() + + # Check if the output file already exists + if os.path.exists(census_data_file): + print(f"Loading existing {geo_level} data from {census_data_file}") + return pd.read_csv(census_data_file, dtype={'GEOID': str}) + + # Get Census API key from file + api_key_path = os.path.expanduser("~/.census_api_key") + try: + with open(api_key_path, 'r') as f: + census_api_key = f.read().strip() + print(f"Your Census API key is [{census_api_key}]") + except FileNotFoundError: + raise FileNotFoundError( + f"Census API key file not found at {api_key_path}. Please create this file with your API key.") + + if not census_api_key: + raise ValueError("Census API key is empty. Please check your API key file.") + + print(f"Collecting {geo_level.upper()} data for year {year}...") + + # Initialize the Census API + from census import Census + c = Census(census_api_key, year=year) + + # Convert list of county FIPS to comma-separated string if it's a list + if isinstance(county_fips_codes, list): + county_fips_string = ','.join(county_fips_codes) + else: + county_fips_string = county_fips_codes + + print(f"Downloading population data for {geo_level}s...") + + try: + # Different API calls based on geographic level + if geo_level == 'county': + census_data = c.acs5.state_county( + fields=('NAME', 'B01003_001E'), # B01003_001E is total population + state_fips=state_fips_code, + county_fips=county_fips_string + ) + elif geo_level == 'tract': + census_data = c.acs5.state_county_tract( + fields=('NAME', 'B01003_001E'), + state_fips=state_fips_code, + county_fips=county_fips_string, + tract='*' # Request all tracts + ) + elif geo_level == 'cbg': + census_data = c.acs5.state_county_blockgroup( + fields=('NAME', 'B01003_001E'), + state_fips=state_fips_code, + county_fips=county_fips_string, + blockgroup='*' # Request all block groups + ) + else: + raise ValueError(f"Invalid geo_level '{geo_level}'. Must be one of: {', '.join(valid_levels)}") + + # Create a DataFrame from the census data + df = pd.DataFrame(census_data) + + # Rename columns for clarity + df = df.rename(columns={'B01003_001E': 'population', 'NAME': 'name'}) + + # Create GEOID based on geographic level + if geo_level == 'county': + df['GEOID'] = df['state'] + df['county'] + elif geo_level == 'tract': + df['GEOID'] = df['state'] + df['county'] + df['tract'] + elif geo_level == 'cbg': + df['GEOID'] = df['state'] + df['county'] + df['tract'] + df['block group'] + + # Convert population to numeric + df['population'] = pd.to_numeric(df['population'], errors='coerce') + + # Save the raw census data + if census_data_file: + df.to_csv(census_data_file, index=False) + print(f"{geo_level.capitalize()} population data saved to {census_data_file}") + + return df + + except Exception as e: + print(f"Error downloading Census data: {e}") + raise + + +def download_tract_census_data(state_fips_code, county_fips_codes, year, census_data_file): + """ + Download census tract population data from the Census Bureau's ACS 5-year estimates. + + Parameters + ---------- + state_fips_code : str + FIPS code for the state + county_fips_codes : list + List of county FIPS codes + year : int + Reference year for population estimates (July 1st reference date) + census_data_file: str + Path to the CSV file where population data will be saved + + Returns + ------- + pandas.DataFrame + DataFrame containing population data for census tracts + """ + from cenpy import products + if not os.path.exists(census_data_file): + # Connect to Census API + try: + conn = products.APIConnection(f"ACSDT5Y{year}") + # Get population data for tracts + pop_data = None + for county_fips in county_fips_codes: + tract_data = conn.query( + ['B01003_001E'], # Total population estimate + geo_unit='tract', + geo_filter={ + "state": state_fips_code, + "county": county_fips + } + ) + pop_data = pd.concat([pop_data, tract_data]) if pop_data is not None else tract_data + + # Rename columns + pop_data = pop_data.rename(columns={'B01003_001E': 'population'}) + + # Create GEOID by combining state, county, and tract + pop_data['GEOID'] = (pop_data['state'] + pop_data['county'] + pop_data['tract']).astype(str) + + # Convert population to numeric + pop_data['population'] = pd.to_numeric(pop_data['population'], errors='coerce') + pop_data.to_csv(census_data_file, index=False) + + except Exception as e: + print(f"Failed to retrieve population data: {e}") + raise + else: + pop_data = pd.read_csv(census_data_file, dtype={'GEOID': str}) + + return pop_data + + +def collect_tract_boundaries(state_fips_code, county_fips_codes, year): + """ + Download census tract boundaries from TIGER/Line shapefiles. + + Parameters + ---------- + state_fips_code : str + FIPS code for the state + county_fips_codes : list + List of county FIPS codes + year : int + Reference year for boundaries + + Returns + ------- + geopandas.GeoDataFrame + GeoDataFrame containing tract boundaries + """ + try: + # Download geographic boundaries + geo_url = f"https://www2.census.gov/geo/tiger/TIGER{year}/TRACT/tl_{year}_{state_fips_code}_tract.zip" + geo_data = gpd.read_file(geo_url) + + # Filter for counties of interest + geo_data = geo_data[geo_data['COUNTYFP'].isin(county_fips_codes)] + except Exception as e: + print(f"Failed to retrieve geographic boundaries: {e}") + raise + return geo_data + +def collect_geographic_boundaries(state_fips_code, county_fips_codes, year, area_name, geo_level, work_dir): + study_area_boundary_geo_path = f"{work_dir}/{area_name}_{geo_level}_{year}_wgs84.geojson" + if os.path.exists(study_area_boundary_geo_path): + return gpd.read_file(study_area_boundary_geo_path) + else: + from pygris import counties, block_groups + + if geo_level == 'county': + # Define fips code for selected counties + geo_data = counties(state=state_fips_code, year=year, cb=True, cache=True) + elif geo_level == 'cbg': + # Define fips code for selected counties + geo_data = block_groups(state=state_fips_code, year=year, cb=True, cache=True) + elif geo_level == 'taz': + geo_data = collect_taz_boundaries(state_fips_code, year, os.path.dirname(study_area_boundary_geo_path)) + elif geo_level == "tract": + geo_data = collect_tract_boundaries(state_fips_code, county_fips_codes, year) + else: + raise ValueError("Unsupported geographic level. Choose 'counties' or 'cbgs'.") + + countyfp_columns = [col for col in geo_data.columns if col.startswith('COUNTYFP')] + mask = geo_data[countyfp_columns].apply(lambda x: x.isin(county_fips_codes)).any(axis=1) + selected_geo = geo_data[mask] + + # def string_to_double(s): + # return float(s if s != "" else "0") + # + # # Prepare columns and mask + # aland_columns = [col for col in selected_geo.columns if col.startswith('ALAND')] + # awater_columns = [col for col in selected_geo.columns if col.startswith('AWATER')] + # for col in aland_columns + awater_columns: + # selected_geo.loc[:, col] = selected_geo[col].apply(string_to_double) + # mask = pd.Series([False] * len(selected_geo), index=selected_geo.index) + # + # for aland_col, awater_col in zip(aland_columns, awater_columns): + # # AWATER should not be more than three times ALAND + # mask |= (selected_geo[aland_col] > 0) & (selected_geo[awater_col] < 3 * selected_geo[aland_col]) + # + # # Apply the mask to filter selected_geo + # selected_geo = selected_geo[mask] + # study_area_geo_projected_path = base_name + "_epsg" + str(projected_coordinate_system) + extension + # selected_geo.to_crs(epsg=projected_coordinate_system).to_file(study_area_geo_projected_path, driver="GeoJSON") + + selected_geo_wgs84 = selected_geo.to_crs(epsg=4326) + selected_geo_wgs84.to_file(study_area_boundary_geo_path, driver="GeoJSON") + return selected_geo_wgs84 + +def collect_taz_boundaries(state_fips_code, year, output_dir): + from zipfile import ZipFile + state_geo_zip = output_dir + f"/tl_{year}_{state_fips_code}_taz10.zip" + if not os.path.exists(state_geo_zip): + state_geo_zip = download_taz_shapefile(state_fips_code, year, output_dir) + """ + Read a shapefile from a ZIP archive, filter geometries by county FIPS codes, + and write the result to a GeoJSON file. + + Parameters: + - zip_file_path: Path to the ZIP file containing the shapefile. + - county_fips_codes: List of county FIPS codes to filter by. + - output_geojson_path: Path to save the filtered data as a GeoJSON file. + """ + # Extract the shapefile from the ZIP archive + with ZipFile(state_geo_zip, 'r') as zip_ref: + # Extract all files to a temporary directory + temp_dir = "temp_shp" + zip_ref.extractall(temp_dir) + + # Find the .shp file in the extracted files + shapefile_name = [f for f in os.listdir(temp_dir) if f.endswith('.shp')][0] + shapefile_path = os.path.join(temp_dir, shapefile_name) + + # Read the shapefile into a GeoDataFrame + gdf = gpd.read_file(shapefile_path) + + # Clean up the temporary directory + for filename in os.listdir(temp_dir): + os.remove(os.path.join(temp_dir, filename)) + os.rmdir(temp_dir) + + return gdf + +def download_taz_shapefile(state_fips_code, year, output_dir): + import requests + """ + Download TAZ shapefiles for a given state-level FIPS code. + + Parameters: + - fips_code: String or integer representing the state-level FIPS code. + - output_dir: Directory to save the downloaded ZIP file. + """ + # Ensure the FIPS code is a string, padded to 2 characters + fips_code_str = str(state_fips_code).zfill(2) + + # Construct the download URL + base_url = f"https://www2.census.gov/geo/tiger/TIGER2010/TAZ/2010/" + filename = f"tl_{year}_{fips_code_str}_taz10.zip" + download_url = base_url + filename + + # Make the output directory if it doesn't exist + if not os.path.exists(output_dir): + os.makedirs(output_dir) + + # Full path for saving the file + output_path = os.path.join(output_dir, filename) + + # Start the download + print(f"Downloading TAZ shapefile for FIPS code {state_fips_code} from {download_url}") + try: + response = requests.get(download_url) + response.raise_for_status() # This will check for errors + + # Write the content of the response to a ZIP file + with open(output_path, 'wb') as file: + file.write(response.content) + + print(f"File saved to {output_path}") + + except requests.RequestException as e: + print(f"Error downloading the file: {e}") + + return output_path + +def filter_boundaries_by_density(geo_data, pop_data, utm_epsg, geo_level, min_density_per_km2, density_geo_file): + """ + Collect census boundaries, calculate population density, and filter by density threshold. + + Parameters + ---------- + geo_data: GeoDataFrame + Boundaries + pop_data: Dataframe + census + utm_epsg: int + EPSG code for the projected coordinate system + geo_level: str + Geographic level ('tract', 'cbg', etc.) + min_density_per_km2: float, optional + Minimum population density threshold (people per km²) + density_geo_file: str + Path to the CSV file containing density based geometry + + Returns + ------- + geopandas.GeoDataFrame + Filtered geographic boundaries based on density threshold + """ + # Check if filtered boundaries already exist + if os.path.exists(density_geo_file): + print(f"Loading existing {geo_level} boundaries...") + filtered_geo = gpd.read_file(density_geo_file) + print(f"✓ Loaded {len(filtered_geo)} {geo_level}s from existing file") + return filtered_geo + + # If not, we need to collect and process the data + print(f"Processing {geo_level} boundaries for density analysis...") + + # Ensure GEOID column has consistent type for merging + geo_data['GEOID'] = geo_data['GEOID'].astype(str) + + # Merge boundaries with population data + geo_with_pop = geo_data.merge(pop_data, on='GEOID') + + # Calculate area and density + geo_with_pop['area_sqkm'] = ( + geo_with_pop.to_crs(epsg=utm_epsg) + .geometry.area / 1000000 # Convert m² to km² + ) + geo_with_pop['density_per_km2'] = geo_with_pop['population'] / geo_with_pop['area_sqkm'] + + # Calculate percentile ranks + geo_with_pop['density_percentile'] = ( + geo_with_pop['density_per_km2'].rank(pct=True) * 100 + ).round(1) + + # Print density analysis summary + print("\nPopulation Density Analysis:") + print("==========================") + + # Density summary + print(f"\n{geo_level.capitalize()} Density Summary (people/km²):") + print("--------------------------------") + stats = geo_with_pop['density_per_km2'].describe() + print(f"Mean density: {stats['mean']:,.1f}") + print(f"Median density: {stats['50%']:,.1f}") + print(f"Standard deviation: {stats['std']:,.1f}") + print(f"Minimum density: {stats['min']:,.1f}") + print(f"Maximum density: {stats['max']:,.1f}") + + # Density distribution + print("\nDensity Distribution Quartiles:") + print("----------------------------") + for q in [0.25, 0.5, 0.75]: + print(f"{int(q * 100)}th percentile: {geo_with_pop['density_per_km2'].quantile(q):,.1f}") + + # Filter by minimum density if specified + if min_density_per_km2 > 0: + print(f"\nFiltering {geo_level}s by minimum density: {min_density_per_km2:,.1f} people/km²") + + # Apply density filter + filtered_geo = geo_with_pop[geo_with_pop["density_per_km2"] >= min_density_per_km2] + + # Print selection results + print(f"\nSelection Results:") + print("----------------") + print(f"Selected {len(filtered_geo)} out of {len(geo_with_pop)} {geo_level}s") + print(f"Total population in selected {geo_level}s: {filtered_geo['population'].sum():,}") + + # Calculate percentage of total population + total_population = geo_with_pop['population'].sum() + if total_population > 0: + population_percentage = (filtered_geo['population'].sum() / total_population * 100) + print(f"Percentage of total population: {population_percentage:.1f}%\n") + else: + print(f"Warning: Total population is zero, cannot calculate percentage\n") + else: + # If no density filter, use all areas + filtered_geo = geo_with_pop + print(f"\nUsing all {len(filtered_geo)} {geo_level}s (no density filter applied)") + + # Ensure output is in WGS84 for consistency + filtered_geo = filtered_geo.to_crs(epsg=4326) + + # Save to file for future use + filtered_geo.to_file(density_geo_file, driver="GeoJSON") + print(f"✓ Saved filtered {geo_level} boundaries to {density_geo_file}") + + return filtered_geo \ No newline at end of file diff --git a/src/main/python/network_validation/convert_network_csv_into_geojson.py b/src/main/python/network_validation/convert_network_csv_into_geojson.py new file mode 100644 index 00000000000..03f640ae134 --- /dev/null +++ b/src/main/python/network_validation/convert_network_csv_into_geojson.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python3 + +import pandas as pd +import geopandas as gpd +from shapely.geometry import LineString, Point +import os +import logging +import argparse + + +def setup_logging(log_file): + """Set up logging configuration.""" + logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(levelname)s - %(message)s', + handlers=[ + logging.FileHandler(log_file, mode='w'), + logging.StreamHandler() + ] + ) + + +def validate_network_file(network_df): + """Validate the network file has all required columns.""" + required_columns = [ + 'linkId', 'linkLength', 'linkFreeSpeed', 'linkCapacity', + 'numberOfLanes', 'linkModes', 'attributeOrigId', 'attributeOrigType', + 'fromNodeId', 'toNodeId', 'fromLocationX', 'fromLocationY', + 'toLocationX', 'toLocationY' + ] + + missing_columns = [col for col in required_columns if col not in network_df.columns] + if missing_columns: + raise ValueError(f"Missing required columns in network file: {missing_columns}") + + +def convert_network_to_geojson(network_file, projected_crs_epsg=32048): + """ + Convert network CSV file to GeoJSON format. + + Parameters: + network_file (str): Path to the network.csv.gz file + projected_crs_epsg (int): EPSG code for the projected CRS + + Returns: + str: Path to the created GeoJSON file + """ + try: + logging.info(f"Reading network file: {network_file}") + network_name = os.path.splitext(os.path.splitext(os.path.basename(network_file))[0])[0] + network_df = pd.read_csv(network_file) + + # Validate the input file + validate_network_file(network_df) + + # Filter for car modes + car_modes = ['car', 'car;bike', 'car;walk;bike'] + network_filtered = network_df[network_df['linkModes'].isin(car_modes)] + logging.info(f"Filtered network for car modes. Features remaining: {len(network_filtered):,}") + + # Create GeoDataFrame with projected CRS + gdf = gpd.GeoDataFrame( + network_filtered, + geometry=[ + LineString([Point(row.fromLocationX, row.fromLocationY), + Point(row.toLocationX, row.toLocationY)]) + for idx, row in network_filtered.iterrows() + ], + crs=f"EPSG:{projected_crs_epsg}" + ) + + # Remove coordinate columns as they're now in the geometry + gdf = gdf.drop(columns=['fromLocationX', 'fromLocationY', 'toLocationX', 'toLocationY']) + + # Convert to WGS84 for GeoJSON output + gdf_wgs84 = gdf.to_crs(epsg=4326) + + # Create output path and save file + output_dir = os.path.dirname(network_file) + output_file = os.path.join(output_dir, f"{network_name}.geojson") + + # Save to GeoJSON + gdf_wgs84.to_file(output_file, driver='GeoJSON') + + # Log statistics + logging.info(f"\n[NETWORK] Network statistics:") + logging.info(f"Total features: {len(gdf_wgs84):,}") + logging.info(f"Total network length: {gdf_wgs84['linkLength'].sum() / 1000:.2f} km") + logging.info(f"Unique road types: {gdf_wgs84['attributeOrigType'].nunique()}") + + # Road type distribution + logging.info("\nTop 5 road types distribution:") + road_type_dist = gdf_wgs84['attributeOrigType'].value_counts().head() + for road_type, count in road_type_dist.items(): + logging.info(f" {road_type}: {count:,} links") + + logging.info(f"\n[OUTPUT] GeoJSON file saved to: {output_file}") + return output_file + + except Exception as e: + logging.error(f"Error converting network to GeoJSON: {str(e)}") + raise + + +def parse_arguments(): + """Parse command line arguments.""" + parser = argparse.ArgumentParser( + description='Convert network CSV to GeoJSON format.' + ) + parser.add_argument( + 'network_file', + help='Path to the network CSV file (can be gzipped)' + ) + parser.add_argument( + '--crs', + type=int, + default=32048, + help='EPSG code for the projected CRS (default: 32048)' + ) + return parser.parse_args() + + +def main(): + # Parse command line arguments + args = parse_arguments() + network_file = os.path.expanduser(args.network_file) + network_dir = os.path.dirname(network_file) + network_name = os.path.splitext(os.path.splitext(os.path.basename(network_file))[0])[0] + + # Setup logging + log_file = os.path.join(network_dir, f'network_to_geojson_{network_name}.log') + setup_logging(log_file) + + # Check if network file exists + if not os.path.exists(network_file): + logging.error(f"Network file not found: {network_file}") + return 1 + + try: + convert_network_to_geojson(network_file, projected_crs_epsg=args.crs) + logging.info("Conversion completed successfully") + return 0 + except Exception as e: + logging.error(f"Conversion failed: {str(e)}") + return 1 + + +if __name__ == "__main__": + exit(main()) \ No newline at end of file diff --git a/src/main/python/network_validation/download_osm_network.py b/src/main/python/network_validation/download_osm_network.py new file mode 100644 index 00000000000..ac392eb60c2 --- /dev/null +++ b/src/main/python/network_validation/download_osm_network.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +""" +Download and prepare OSM network data. + +@author: haitamlaarabi, cristian.poliziani, zaneedell +""" +import os +import sys +import pickle +import subprocess + +import osmnx as ox + +from osm_utils import download_and_prepare_osm_network +from osm_utils import check_invalid_coordinates +from osm_utils import scan_network_directories_for_ways +from osm_utils import check_duplicate_edge_ids +from osm_xml import save_graph_xml + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +# Now use absolute import +from python.utils.study_area_config import get_area_config +from python.utils.study_area_config import generate_network_name + + +def main(): + """Main execution function.""" + area = "sfbay" # Options: sfbay, seattle + study_area_config = get_area_config(area) + study_area_config["graph_layers"]["residential"]["min_density_per_km2"] = 5500 # 2855 for sfbay, 412 for seattle + + # Generate configuration name and prepare directory + config_name = generate_network_name(study_area_config) + network_dir = f'{study_area_config["work_dir"]}/network/{config_name}' + os.makedirs(network_dir, exist_ok=True) + + # Define output file paths + graphml_network = f'{network_dir}/{config_name}.graphml' + pkl_network = f'{network_dir}/{config_name}.pkl' + gpkg_network = f'{network_dir}/{config_name}.gpkg' + osm_network = f'{network_dir}/{config_name}.osm' + pbf_network = f'{network_dir}/{config_name}.osm.pbf' + geojson_network = f'{network_dir}/{config_name}.osm.geojson' + + print(f'Downloading and preparing OSM-based {config_name} network...') + g_network = download_and_prepare_osm_network(study_area_config) + + # Check for duplicate edge IDs + nodes, edges = ox.graph_to_gdfs(g_network) + has_duplicates, duplicate_info = check_duplicate_edge_ids(edges, 'edge_id') + + if has_duplicates: + dup_counts, dup_examples = duplicate_info + print(f"\nFound {sum(dup_counts.values())} duplicate edge IDs") + + # Save GraphML and PKL formats + ox.save_graphml(g_network, filepath=graphml_network) + print(f"GRAPHML Network saved to '{graphml_network}'.") + + with open(pkl_network, 'wb') as f: + pickle.dump(g_network, f) + print(f"PKL Network saved to '{pkl_network}'.") + + # Check for invalid coordinates + has_invalid, invalid_nodes = check_invalid_coordinates(g_network) + if has_invalid: + print(f"WARNING: Found {len(invalid_nodes)} nodes with invalid coordinates.") + else: + print("✓ All node coordinates are valid.") + + # Extract nodes and edges as GeoDataFrames and verify CRS + nodes, edges = ox.graph_to_gdfs(g_network) + if nodes.crs != edges.crs: + print("\nWARNING: Nodes and edges have different CRS!") + print(f"Nodes CRS: {nodes.crs}") + print(f"Edges CRS: {edges.crs}") + + # Save GPKG Network + print(f"Converting GraphML Network to GPKG Network...") + ox.save_graph_geopackage(g_network, filepath=gpkg_network) + print(f"GPKG Network saved to '{gpkg_network}'.") + + # Create OSM Network + print(f"Creating OSM Network...") + nodes, edges = ox.graph_to_gdfs(g_network) + edges = edges.drop([ + 'u_original', 'v_original', 'merged_edges', 'osmid' + ], axis=1, errors='ignore') + nodes = nodes.drop([ + 'osmid_original' + ], axis=1, errors='ignore') + + g_osm = ox.graph_from_gdfs(nodes, edges, graph_attrs=g_network.graph) + save_graph_xml( + g_osm, + filepath=osm_network, + edge_tags=[ + 'highway', 'lanes', 'maxspeed', 'name', 'oneway', 'length', + 'tunnel', 'bridge', 'junction', 'edge_id', 'access', 'osm_id' + ], + edge_tag_aggs=[('length', 'sum')] + ) + print(f"OSM Network saved to '{osm_network}'.") + + # Convert to PBF and GeoJSON formats + cmd = f"osmium cat {osm_network} -o {pbf_network} --overwrite --output-format pbf,compression=zlib" + subprocess.run(cmd, shell=True, check=True) + print(f"OSM PBF File saved to '{pbf_network}'") + + cmd2 = f"ogr2ogr -f GeoJSON {geojson_network} {pbf_network} lines" + subprocess.run(cmd2, shell=True, check=True) + print(f"OSM GEOJSON File saved to '{geojson_network}'") + + # Scan network directories for ways + work_dir = study_area_config["work_dir"] + scan_network_directories_for_ways(os.path.expanduser(f'{work_dir}/network')) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/main/python/network_validation/main.py b/src/main/python/network_validation/main.py new file mode 100644 index 00000000000..8a3932c88da --- /dev/null +++ b/src/main/python/network_validation/main.py @@ -0,0 +1,99 @@ +import os +import time + +import pandas as pd +import psutil + + +def load_heavy_csv(file_path, chunk_size=100000): + """ + Load a heavy CSV file efficiently with memory usage tracking. + + Parameters: + ----------- + file_path : str + Path to the CSV file + chunk_size : int + Number of rows to process at a time + + Returns: + -------- + pd.DataFrame or None + The loaded DataFrame or None if file doesn't exist + """ + start_time = time.time() + + # Check if file exists + if not os.path.exists(file_path): + print(f"Error: File {file_path} not found.") + return None + + # Get file size + file_size_bytes = os.path.getsize(file_path) + file_size_mb = file_size_bytes / (1024 * 1024) + print(f"File size: {file_size_mb:.2f} MB") + + # Initial memory usage + process = psutil.Process(os.getpid()) + initial_memory = process.memory_info().rss / (1024 * 1024) + print(f"Initial memory usage: {initial_memory:.2f} MB") + + try: + # For very large files, use chunking + if file_size_mb > 500: # If file is larger than 500MB + print(f"Loading large file in chunks of {chunk_size} rows...") + chunks = [] + for i, chunk in enumerate(pd.read_csv(file_path, chunksize=chunk_size)): + chunks.append(chunk) + if (i + 1) % 10 == 0: + current_memory = process.memory_info().rss / (1024 * 1024) + print(f"Processed {(i + 1) * chunk_size} rows. Current memory usage: {current_memory:.2f} MB") + + df = pd.concat(chunks, ignore_index=True) + else: + print("Loading file into memory...") + df = pd.read_csv(file_path) + + # Final memory usage + final_memory = process.memory_info().rss / (1024 * 1024) + memory_increase = final_memory - initial_memory + + # Print statistics + print(f"CSV loaded successfully in {time.time() - start_time:.2f} seconds") + print(f"Rows: {len(df)}, Columns: {len(df.columns)}") + print(f"Final memory usage: {final_memory:.2f} MB (increased by {memory_increase:.2f} MB)") + + # Display first few rows and column info + print("\nFirst 5 rows:") + print(df.head()) + + print("\nColumn information:") + print(df.dtypes) + + return df + + except Exception as e: + print(f"Error loading CSV: {str(e)}") + return None + + +if __name__ == "__main__": + # Testing H5 Data + # url = "https://console.cloud.google.com/storage/browser/_details/beam-core-outputs/urbansim-inputs/custom_mpo_06197001_model_data_2017.h5;tab=live_object?project=beam-core" + # url = "https://storage.googleapis.com/beam-core-outputs/urbansim-inputs/custom_mpo_06197001_model_data_2017.h5" + # h5_path = os.path.expanduser("~/Workspace/Simulation/sfbay/urbansim/custom_mpo_06197001_model_data.h5") + # download_h5_data(url, h5_path) + + # Loading an events file + # Replace with your CSV file path + file_path = os.path.expanduser("~/Workspace/Models/pilates/0.events.csv.gz") + out_path = os.path.expanduser("~/Downloads/0.events.p3048964.csv") + #300181 + df = load_heavy_csv(file_path) + + if df is not None: + # Perform additional operations with the dataframe here + print("\nMemory usage of DataFrame:") + print(f"{df.memory_usage(deep=True).sum() / (1024 * 1024):.2f} MB") + + diff --git a/src/main/python/network_validation/network_validation.ipynb b/src/main/python/network_validation/network_validation.ipynb index 4b751b5919c..0f7903fd817 100644 --- a/src/main/python/network_validation/network_validation.ipynb +++ b/src/main/python/network_validation/network_validation.ipynb @@ -259,7 +259,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.7" + "version": "3.12.7" } }, "nbformat": 4, diff --git a/src/main/python/network_validation/osm_utils.py b/src/main/python/network_validation/osm_utils.py new file mode 100644 index 00000000000..7b688e36df0 --- /dev/null +++ b/src/main/python/network_validation/osm_utils.py @@ -0,0 +1,1640 @@ +import hashlib +import os +import sys +from collections import Counter, defaultdict +from statistics import mean +from statistics import median + +import geopandas as gpd +import networkx as nx +import osmium +import osmnx as ox +import pandas as pd +import pyproj +import shapely.geometry +from osmnx import settings +from osmnx import truncate +from shapely.ops import unary_union + +from _data_collection_utils import collect_census_data +from _data_collection_utils import collect_geographic_boundaries +from _data_collection_utils import filter_boundaries_by_density + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) + +# Go up to the parent directory that contains the 'python' directory +# If your file is in /path/to/python/freight/frism_to_beam_freight_plans.py +# This will add /path/to to sys.path +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + + +def process_ferry_edges(ferry_graph) -> nx.MultiDiGraph: + """Process ferry edges to make them compatible with car network""" + if ferry_graph.number_of_edges() == 0: + print("No ferry edges found in the graph.") + return nx.MultiDiGraph() + + # Extract nodes and edges + ferry_nodes, ferry_edges = ox.graph_to_gdfs(ferry_graph) + print(f"Total ferry edges: {len(ferry_edges)}") + + # Print available columns to debug + print(f"Available columns: {ferry_edges.columns.tolist()}") + + # Create default masks - assume access is allowed unless explicitly denied + # This is more lenient and works better with OSM data which often lacks explicit tags + car_mask = pd.Series(True, index=ferry_edges.index) + + # Check for explicit denials first + if 'motorcar' in ferry_edges.columns: + car_mask &= ~(ferry_edges['motorcar'] == 'no') + print(f"After motorcar check: {car_mask.sum()} car-accessible edges") + + if 'motor_vehicle' in ferry_edges.columns: + motor_vehicle_denied = ferry_edges['motor_vehicle'] == 'no' + car_mask &= ~motor_vehicle_denied + print(f"After motor_vehicle check: {car_mask.sum()} car-accessible edges") + + # Select ferry edges that allow passenger cars + selected_edges = ferry_edges[car_mask].copy() + + if selected_edges.empty: + print("No ferry routes found that allow passenger cars") + return nx.MultiDiGraph() + + print(f"Found {len(selected_edges)} suitable ferry edges") + + # Set ferry attributes + selected_edges['reversed'] = False + selected_edges['maxspeed'] = "10 mph" + selected_edges['highway'] = "unclassified" + selected_edges['oneway'] = "no" + selected_edges['lanes'] = "2" + selected_edges["hgv"] = False # Mark as not accessible to heavy-duty + selected_edges["mdv"] = True # Mark as accessible to medium-duty + + # Keep only nodes that are used by the filtered edges + used_nodes = set(selected_edges.index.get_level_values(0)).union( + set(selected_edges.index.get_level_values(1)) + ) + selected_nodes = ferry_nodes.loc[list(used_nodes)] + + # Reconstruct graph and project + g_ferry_reconstructed = ox.graph_from_gdfs(selected_nodes, selected_edges) + + return g_ferry_reconstructed + + +def convert_weight(value: float, from_unit: str, to_unit: str) -> float: + """Convert weight between different units.""" + # Conversion factors + conversions = { + "lbs_to_kg": 0.453592, + "kg_to_lbs": 2.20462, + "tons_to_kg": 1000, + "kg_to_tons": 0.001 + } + + if from_unit == to_unit: + return value + + conversion_key = f"{from_unit}_to_{to_unit}" + if conversion_key in conversions: + return value * conversions[conversion_key] + + # Handle two-step conversions if needed + if from_unit == "lbs" and to_unit == "tons": + return value * conversions["lbs_to_kg"] * conversions["kg_to_tons"] + if from_unit == "tons" and to_unit == "lbs": + return value * conversions["tons_to_kg"] * conversions["kg_to_lbs"] + + raise ValueError(f"Unsupported conversion from {from_unit} to {to_unit}") + + +def standardize_weight(weight_str: str, target_unit: str) -> float: + """Convert weight string to numeric value in target unit.""" + if pd.isna(weight_str): + return None + + # Handle numeric-only strings (assume they're in target unit) + if str(weight_str).replace('.', '').isdigit(): + return float(weight_str) + + # Extract number and unit from string + import re + + # Enhanced pattern to match more formats: + # - Numbers with optional decimal point + # - Various unit formats: tons, ton, t, kg, lbs, lb, st (stone) + match = re.match(r'(\d+\.?\d*)\s*(tons?|t|kg|lbs?|st|stone)', str(weight_str).lower()) + if not match: + # Try again with a simpler pattern in case the unit is missing or unusual + number_match = re.match(r'(\d+\.?\d*)', str(weight_str)) + if number_match: + # If we can extract just a number, assume it's in the target unit + return float(number_match.group(1)) + return None + + value, unit = match.groups() + value = float(value) + + # Standardize unit names + unit_mapping = { + 't': 'tons', + 'ton': 'tons', + 'lb': 'lbs', + 'kg': 'kg', + 'st': 'stone', + 'stone': 'stone' + } + unit = unit_mapping.get(unit, unit) + + # Convert to standard unit first (kg), then to target unit + # Conversion factors to kg + to_kg = { + 'lbs': 0.453592, + 'kg': 1.0, + 'tons': 1000.0, + 'stone': 6.35029 # 1 stone = 14 lbs = 6.35029 kg + } + + # Convert to kg first + weight_in_kg = value * to_kg.get(unit, 1.0) + + # Then convert from kg to target unit + from_kg = { + 'lbs': 2.20462, + 'kg': 1.0, + 'tons': 0.001 + } + + # If target unit isn't recognized, default to kg + conversion_factor = from_kg.get(target_unit, 1.0) + + return weight_in_kg * conversion_factor + + +def standardize_oneway(value): + """ + Standardize oneway tag to "yes", "reverse", or "no" strings to match MATSim expectations. + - "yes" for forward direction oneway + - "reverse" for backward direction oneway + - "no" for bidirectional + """ + # Return None if the value is None or empty + if value is None or value == '': + return "no" + + # Values that explicitly mean "yes" (forward oneway) + valid_yes = {'yes', 'true', '1', True, 1} + + # Values that explicitly mean reverse oneway + valid_reverse = {'-1', 'reverse'} + + # Values that explicitly mean "no" + valid_no = {'no', 'false', '0', False, 0} + + # Handle strings + if isinstance(value, str): + value = value.lower().strip() + # Handle semicolon-separated values + if ';' in value: + parts = [part.strip().lower() for part in value.split(';')] + if all(part in valid_yes for part in parts): + return "yes" + elif all(part in valid_reverse for part in parts): + return "reverse" + else: + return "no" + + # Handle single string + if value in valid_yes: + return "yes" + elif value in valid_reverse: + return "reverse" + elif value in valid_no: + return "no" + else: + # If we can't interpret it, MATSim logs a warning and ignores it + return "no" + + # Handle boolean and numeric + if isinstance(value, (bool, int)): + if value in valid_yes: + return "yes" + else: + return "no" + + # Handle lists (if that's a use case) + if isinstance(value, list): + if all(str(v).lower().strip() in valid_yes for v in value if v): + return "yes" + elif all(str(v).lower().strip() in valid_reverse for v in value if v): + return "reverse" + else: + return "no" + + # Default case + return "no" + + +def standardize_motor_vehicle(value): + """ + Standardize motor_vehicle tag to "yes" or "no" strings, focusing on a defined set of restrictive values. + + Parameters: + ----------- + value : any + The motor_vehicle tag value + + Returns: + -------- + str + "no" if motor vehicles are restricted (no, false, 0, private) + "yes" otherwise + """ + # Define restrictive values + restrictive_values = {"no", "false", "0"} + + # If value is None, NaN, or empty, assume motor vehicles are allowed + if value is None or pd.isna(value) or (isinstance(value, str) and not value.strip()): + return "yes" + + # Convert to string and lowercase for consistent processing + if not isinstance(value, str): + value = str(value) + + value = value.lower().strip() + + import re + # Handle special cases with multiple values (separated by semicolons or vertical bars) + if ';' in value or '|' in value: + # Split by either semicolon or vertical bar + parts = re.split(r'[;|]+', value) + parts = [p.strip() for p in parts if p.strip()] + + # If any part is in the restrictive values, the overall value is "no" + if any(p in restrictive_values for p in parts): + return "no" + else: + return "yes" + + # Check if the value is in the restrictive set + if value in restrictive_values: + return "no" + + # All other values indicate some form of access + return "yes" + + +def standardize_maxspeed(value, default_kph=None): + """ + Standardize maxspeed values and return them in the format "25 mph". + + Parameters: + ----------- + value : any + The maxspeed tag value + default_kph : int, optional + Default speed in kph to use if the value can't be parsed + + Returns: + -------- + str or None + Speed in format "XX mph", or None if the value can't be parsed and no default is provided + """ + if value is None or pd.isna(value) or (isinstance(value, str) and not value.strip()): + if default_kph is not None: + return f"{round(default_kph / 1.60934)} mph" # Convert kph to mph + return None + + # Convert to string for processing + if not isinstance(value, str): + value = str(value) + + value = value.lower().strip() + + # Handle special cases + if value == "signals" or value == "none" or value == "variable": + if default_kph is not None: + return f"{round(default_kph / 1.60934)} mph" # Convert kph to mph + return None + + import re + # Try to extract numeric value and unit + match = re.match(r'^(\d+(?:\.\d+)?)\s*(mph|kmh|km/h|kph)?$', value) + if match: + speed_val = float(match.group(1)) + unit = match.group(2) if match.group(2) else "kph" # Default to kph if no unit + + # Convert to mph if necessary + if unit in ["kmh", "km/h", "kph"]: + speed_mph = round(speed_val / 1.60934) # Convert kph to mph + else: + # Already in mph + speed_mph = round(speed_val) + + return f"{speed_mph} mph" + + # If we can't parse the value and have a default + if default_kph is not None: + return f"{round(default_kph / 1.60934)} mph" # Convert kph to mph + + # If we can't parse the value and don't have a default + return None + + +def standardize_access(value): + """ + Standardize access tag to "yes" or "no" strings, focusing on a defined set of restrictive values. + + Parameters: + ----------- + value : any + The access tag value + + Returns: + -------- + str + "no" if access is restricted (no, private, forestry, permit, etc.) + "yes" otherwise + """ + # Define restrictive values - values that indicate restricted access + restrictive_values = {"no", "false", "0"} + + # If value is None, NaN, or empty, assume access is allowed + if value is None or pd.isna(value) or (isinstance(value, str) and not value.strip()): + return "yes" + + # Convert to string and lowercase for consistent processing + if not isinstance(value, str): + value = str(value) + + value = value.lower().strip() + + import re + # Handle special cases with multiple values (separated by semicolons or vertical bars) + if ';' in value or '|' in value: + # Split by either semicolon or vertical bar + parts = re.split(r'[;|]+', value) + parts = [p.strip() for p in parts if p.strip()] + + # If any part is in the restrictive values, the overall value is "no" + if any(p in restrictive_values for p in parts): + return "no" + else: + return "yes" + + # Check if the value is in the restrictive set + if value in restrictive_values: + return "no" + + # All other values (yes, permissive, etc.) indicate general access + return "yes" + + +def standardize_hgv(value): + """ + Standardize HGV access values to boolean (True/False) + Returns True if HGVs are allowed, False if they are not + """ + if not value: + return True # Default to allowed if no value + + # Values that indicate HGV prohibition + restrictive_values = {"no", "false", "0"} + + # Handle boolean inputs + if isinstance(value, bool): + return value + + # Handle semicolon-separated string values + if isinstance(value, str) and ';' in value: + # If any part is "no", the whole is restricted + for part in value.split(';'): + if part.strip().lower() in restrictive_values: + return False + return True + + # Handle list case + if isinstance(value, list): + if not value: + return True + # If any value is "no", the whole is restricted + for v in value: + if str(v).strip().lower() in restrictive_values: + return False + return True + + # Handle single string value + if isinstance(value, str): + return str(value).strip().lower() not in restrictive_values + + # For any other case, convert to string and check + return str(value).strip().lower() not in restrictive_values + + +def process_tags(_g: nx.MultiDiGraph, config: dict) -> nx.MultiDiGraph: + """Process vehicle classifications based on FHWA weight classes.""" + print("Processing vehicle classifications...") + + # Get weight limits and unit from config + weight_config = config["weight_limits"] + target_unit = weight_config["unit"] + mdv_max = weight_config["mdv_max"] + hdv_max = weight_config["hdv_max"] + + # Get graph data while preserving MultiIndex + nodes, edges = ox.graph_to_gdfs(_g) + + # Standardize tags + edges['oneway'] = edges['oneway'].apply(standardize_oneway) + edges['motor_vehicle'] = edges['motor_vehicle'].apply(standardize_motor_vehicle) + edges['maxspeed'] = edges['maxspeed'].apply(standardize_maxspeed) + edges['access'] = edges['access'].apply(standardize_access) + # Initialize hgv and mdv as True by default if they don't exist + edges["mdv"] = True + if "hgv" not in edges.columns: + edges["hgv"] = True + edges["hgv"] = edges["hgv"].apply(standardize_hgv) + + # Copy HGV weight restrictions if present + if "maxweight:hgv" in edges.columns: + hgv_mask = ~edges["maxweight:hgv"].isna() + if hgv_mask.any(): + edges.loc[hgv_mask, "maxweight"] = edges.loc[hgv_mask, "maxweight:hgv"].copy() + + if "maxweight" in edges.columns: + print("Processing weight restrictions...") + # Convert weights to standard unit specified in config + edges["maxweight"] = edges["maxweight"].apply(lambda x: standardize_weight(x, target_unit)) + + # Update hgv and mdv based on weight restrictions + # Medium-duty vehicles are restricted when weight is below MDV limit + mdv_restricted_mask = edges["maxweight"].notna() & (edges["maxweight"] <= mdv_max) + edges.loc[mdv_restricted_mask, "mdv"] = False + + # Heavy-duty vehicles are restricted when weight is below HDV limit + # Create a mask for MDVs being restricted + mdv_is_restricted = edges["mdv"] == False + # Combine masks properly + hdv_restricted_mask = mdv_is_restricted | (edges["maxweight"].notna() & (edges["maxweight"] <= hdv_max)) + edges.loc[hdv_restricted_mask, "hgv"] = False + + # Process other restrictions like maxlength + if "maxlength" in edges.columns: + # If maxlength is set, assume heavy vehicles are restricted + length_restricted_mask = ~edges["maxlength"].isna() + edges.loc[length_restricted_mask, "hgv"] = False + + # Ensure hgv, mdv and oneway are strictly boolean + edges["hgv"] = edges["hgv"].astype(bool) + edges["mdv"] = edges["mdv"].astype(bool) + + # Convert back to MultiDiGraph + g_updated = ox.graph_from_gdfs(nodes, edges) + + return g_updated + + +def create_unique_edge_id(u, v, osmid, k=None): + """ + Create a unique edge ID by combining start node, end node, and osmid. + + Parameters: + ----------- + u : node ID of the edge's source + v : node ID of the edge's target + osmid : original OSM way ID + k : optional key for MultiDiGraphs (default: None) + + Returns: + -------- + str : A unique edge identifier + """ + # Handle the case where osmid might be a list + if isinstance(osmid, list): + osmid_str = '_'.join(map(str, osmid)) + else: + osmid_str = str(osmid) + + # Include the key if provided (for MultiDiGraphs) + if k is not None: + unique_id = f"{u}_{v}_{k}_{osmid_str}" + else: + unique_id = f"{u}_{v}_{osmid_str}" + + # Optionally hash it if you want a shorter fixed-length ID + hash_object = hashlib.md5(unique_id.encode()) + return hash_object.hexdigest()[:12] # 12 characters should be sufficient + + +def find_long_tags_in_gdf(gdf, element_type="elements"): + """ + Find columns and combinations of attributes that exceed 250 characters in a GeoDataFrame. + + Parameters: + ----------- + gdf : GeoDataFrame + The input GeoDataFrame (can be either nodes or edges) + element_type : str, optional + The type of elements being analyzed ("nodes" or "edges") for output messages + + Returns: + -------- + tuple + (long_tags, long_comb_tags) where: + - long_tags: dict of individual columns with values >= 250 characters + - long_comb_tags: dict of rows with combined attribute length >= 250 characters + """ + print(f"\nAnalyzing {element_type}...") + + # Find individual columns with values longer than 250 characters + long_tags = {} + for column in gdf.columns: + # Convert all values to strings and check their lengths + max_length = gdf[column].astype(str).str.len().max() + if max_length >= 250: + long_tags[column] = max_length + + # Print results for individual columns + if long_tags: + print(f"\nIndividual {element_type} columns with values >= 250 characters:") + for column, length in long_tags.items(): + print(f"Column '{column}': max length = {length} characters") + # Print an example of a long value + long_value_idx = gdf[column].astype(str).str.len().idxmax() + print(f"Example long value: {gdf[column].iloc[long_value_idx]}\n") + else: + print(f"No individual {element_type} columns found with values >= 250 characters") + + # Find combinations of attributes that exceed 250 characters + print(f"\nChecking {element_type} attribute combinations...") + # Get all rows where any combination of attributes might be long + long_comb_tags = {} + for idx, row in gdf.iterrows(): + comb_length = 0 + contributing_cols = [] + + for col in gdf.columns: + value = str(row[col]) + if len(value) > 0 and value.lower() != 'nan': # Skip empty or NaN values + value_length = len(value) + comb_length += value_length + if value_length > 0: # Only add if the value has length + contributing_cols.append({ + 'column': col, + 'length': value_length, + 'value': value + }) + + if comb_length >= 250: + long_comb_tags[idx] = { + 'total_length': comb_length, + 'contributing_columns': contributing_cols + } + + # Print results for combinations + if long_comb_tags: + print(f"\n{element_type.capitalize()} rows with combined attribute length >= 250 characters:") + for idx, info in long_comb_tags.items(): + print(f"\nRow {idx}:") + print(f"Total combined length: {info['total_length']} characters") + print("Contributing columns:") + for col_info in info['contributing_columns']: + print(f"- {col_info['column']}: length={col_info['length']} chars") + if col_info['length'] > 50: # Show value only if it's significantly long + print(f" Value: {col_info['value'][:50]}...") # Show first 50 chars + else: + print(f"No combinations of {element_type} attributes found exceeding 250 characters") + + return long_tags, long_comb_tags + + +def meters_to_degrees(lon, lat, utm_epsg, buffer_meters): + """ + Calculate the equivalent buffer distance in degrees for a given buffer in meters, + using a specified UTM projection for better precision. + + Parameters: + ----------- + lon : float + Longitude coordinate (x) in WGS84 + lat : float + Latitude coordinate (y) in WGS84 + utm_epsg : int + The EPSG code for the UTM coordinate reference system (e.g., 26910 for UTM Zone 10N) + buffer_meters : float + Buffer distance in meters + + Returns: + -------- + float + Equivalent buffer distance in degrees + """ + # Create UTM CRS from EPSG code + utm_crs = f"EPSG:{utm_epsg}" + + # Create transformers + wgs84_to_utm = pyproj.Transformer.from_crs("EPSG:4326", utm_crs, always_xy=True) + utm_to_wgs84 = pyproj.Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True) + + # Convert coordinates to UTM + x_utm, y_utm = wgs84_to_utm.transform(lon, lat) + + # Calculate points at buffer distance in cardinal directions + east_utm = (x_utm + buffer_meters, y_utm) + north_utm = (x_utm, y_utm + buffer_meters) + + # Convert buffered points back to WGS84 + east_lon, east_lat = utm_to_wgs84.transform(*east_utm) + north_lon, north_lat = utm_to_wgs84.transform(*north_utm) + + # Calculate degree differences + lon_diff = abs(east_lon - lon) # East-West difference (longitude) + lat_diff = abs(north_lat - lat) # North-South difference (latitude) + + # Return the average as an approximation + # You could also return both separately if you need different buffers for lat/lon + return (lon_diff + lat_diff) / 2 + + +def to_convex_hull(input_data, utm_epsg, buffer_in_meters): + """ + Create a buffered convex hull from input data. + + Parameters: + ----------- + input_data : GeoDataFrame, GeoSeries, or Shapely geometry + The input geographic data + utm_epsg : int + EPSG code for the UTM projection to use for accurate distance calculations + buffer_in_meters : float + Buffer distance in meters + + Returns: + -------- + Shapely geometry + The buffered convex hull + """ + # Handle different input types + if isinstance(input_data, gpd.GeoDataFrame): + # GeoDataFrame: get the convex hull of all geometries + convex_hull = input_data.geometry.unary_union.convex_hull + elif isinstance(input_data, gpd.GeoSeries): + # GeoSeries: get the convex hull of all geometries + convex_hull = input_data.unary_union.convex_hull + elif hasattr(input_data, 'geom_type'): + # Shapely geometry: get its convex hull + convex_hull = input_data.convex_hull + else: + raise TypeError("Input must be a GeoDataFrame, GeoSeries, or Shapely geometry") + + # Get centroid + lon = convex_hull.centroid.x + lat = convex_hull.centroid.y + + # Convert buffer distance + buffer_in_degrees = meters_to_degrees(lon, lat, utm_epsg, buffer_in_meters) + + # Buffer in degrees + buffered_convex_hull = convex_hull.buffer(buffer_in_degrees) + + return buffered_convex_hull + + +def adjust_and_add_graph(graphs, current_graph): + # Get nodes and edges of current graph + current_nodes, current_edges = ox.graph_to_gdfs(current_graph) + + # Collect all unique columns from existing graphs + existing_columns = set() + for existing_graph in graphs: + _, existing_edges = ox.graph_to_gdfs(existing_graph) + existing_columns.update(existing_edges.columns) + + # Add missing columns to current graph's edges + for col in existing_columns: + if col not in current_edges.columns: + current_edges[col] = "" + + # Also ensure existing graphs have columns from current graph + current_columns = set(current_edges.columns) + for i, existing_graph in enumerate(graphs): + existing_nodes, existing_edges = ox.graph_to_gdfs(existing_graph) + + columns_added = False + for col in current_columns: + if col not in existing_edges.columns: + existing_edges[col] = "" + columns_added = True + + # Only rebuild the graph if columns were added + if columns_added: + graphs[i] = ox.graph_from_gdfs(existing_nodes, existing_edges) + + # Add the graph to the list if it has edges + graphs.append(ox.graph_from_gdfs(current_nodes, current_edges)) + + +def median_lanes(values): + """ + Calculate median after converting string values to numbers. + Handles: + - Lists of values + - Semicolon-separated values + - Mixed numeric types + """ + # Initialize empty list for numeric values + numeric_values = [] + + # Handle case where values is already a single value, not an iterable + if isinstance(values, (int, float)): + return int(values) + elif isinstance(values, str): + values = [values] + + # Process each value in the iterable + for v in values: + # Skip None values + if v is None: + continue + + # Handle different types + if isinstance(v, (int, float)): + numeric_values.append(int(v)) + continue + + if not isinstance(v, str): + v = str(v) + + # Split by semicolon to handle multiple values + parts = v.split(';') + for part in parts: + part = part.strip() + try: + numeric_values.append(int(part)) + except (ValueError, TypeError): + # Skip non-numeric parts + continue + + if not numeric_values: + return None + return int(median(numeric_values)) + + +def most_restrictive_access(values): + """ + Returns the most restrictive access value from a list based on a predefined priority order. + + Parameters: + ----------- + values : list + List of access values + + Returns: + -------- + str + The most restrictive access value, or None if no valid values + """ + # Define a priority order for access restrictions (from most to least restrictive) + priority = { + "no": 1, # Most restrictive + "private": 2, + "permit": 3, + "destination": 4, + "delivery": 5, + "customers": 6, + "forestry": 7, + "agricultural": 8, + "discouraged": 9, + "permissive": 10, + "yes": 11 # Least restrictive + } + + # Default priority for unknown values - place between "discouraged" and "permissive" + default_priority = 9.5 + + if not values: + return None + + # Process each value and find the most restrictive + most_restrictive = None + highest_priority = float('inf') # Lower number = higher priority + + for value in values: + if value is None or value == "nan" or pd.isna(value): + continue + + if isinstance(value, str): + value = value.strip().lower() + if not value or value == "nan": + continue + + # Get priority for this value + value_priority = priority.get(value, default_priority) + + # Update most restrictive if this has higher priority (lower number) + if value_priority < highest_priority: + most_restrictive = value + highest_priority = value_priority + + return most_restrictive + + +def bool_all(values): + """ + Returns False if any value is False, otherwise returns True. + Expects only boolean values (True or False). + + Parameters: + ----------- + values : list + List of boolean values + + Returns: + -------- + bool + False if any value is False, True otherwise + """ + if not values: + return None + + # If any value is False, return False + return all(values) + + +def mean_maxspeed(speed_values): + """ + Calculate the mean speed from a list of speed values in the format "XX mph". + + Parameters: + ----------- + speed_values : list + List of speed values in format "XX mph" + + Returns: + -------- + str + Mean speed in format "XX mph", or None if no valid speeds found + """ + if not speed_values: + return None + + # Extract numeric values + speeds_mph = [] + import re + + for value in speed_values: + if not value or pd.isna(value): + continue + + # Convert to string if needed + if not isinstance(value, str): + value = str(value) + + # Extract the numeric part + match = re.match(r'^(\d+(?:\.\d+)?)\s*mph$', value.lower().strip()) + if match: + speeds_mph.append(float(match.group(1))) + + # Calculate mean if we have valid values + if speeds_mph: + mean_speed = mean(speeds_mph) + return f"{round(mean_speed)} mph" + + return None + + +def yes_no_all(values): + """ + Returns "no" if any value is "no", otherwise returns "yes". + Expects string values ("yes" or "no"). + + Parameters: + ----------- + values : list + List of string values ("yes" or "no") + + Returns: + -------- + str + "no" if any value is "no", "yes" otherwise + """ + if not values: + return None + + # If any value is "no", return "no" + return "no" if "no" in values else "yes" + + +def project_graph(G: nx.MultiDiGraph, to_crs=None, to_latlong=False) -> nx.MultiDiGraph: + """ + Project a graph from its current CRS to another. + + If `to_latlong` is True, this projects the graph to the coordinate + reference system defined by `settings.default_crs`. Otherwise it projects + it to the CRS defined by `to_crs`. If `to_crs` is `None`, it projects it + to the CRS of an appropriate UTM zone given `geometry`'s bounds. + + Parameters + ---------- + G + The graph to be projected. + to_crs + If None, project to an appropriate UTM zone. Otherwise project to + this CRS. + to_latlong + If True, project to `settings.default_crs` and ignore `to_crs`. + + Returns + ------- + G_proj + The projected graph. + """ + if to_latlong: + to_crs = settings.default_crs + + # STEP 1: PROJECT THE NODES + gdf_nodes = ox.convert.graph_to_gdfs(G, edges=False) + + # project the nodes GeoDataFrame and extract the projected x/y values + gdf_nodes_proj = ox.projection.project_gdf(gdf_nodes, to_crs=to_crs) + gdf_nodes_proj["x"] = gdf_nodes_proj["geometry"].x + gdf_nodes_proj["y"] = gdf_nodes_proj["geometry"].y + to_crs = gdf_nodes_proj.crs + + # STEP 2: PROJECT THE EDGES + # Always get edges with geometry, regardless of whether the graph is simplified + gdf_edges = ox.convert.graph_to_gdfs(G, nodes=False, fill_edge_geometry=True) + + # If edges don't have a CRS but do have geometry, assign the source CRS + if gdf_edges.crs is None and not gdf_edges.empty and 'geometry' in gdf_edges.columns: + # If we're unsure about the source CRS, use what we know from the nodes + source_crs = G.graph.get('crs', gdf_nodes.crs) + if source_crs is not None: + gdf_edges.crs = source_crs + print(f"Setting edge CRS to {source_crs} before projection") + + # Project the edges + gdf_edges_proj = ox.projection.project_gdf(gdf_edges, to_crs=to_crs) + + # Debug output to verify projection worked + if not gdf_edges_proj.empty and 'geometry' in gdf_edges_proj.columns: + sample_geom = gdf_edges_proj.iloc[0]['geometry'] + if sample_geom is not None: + print(f"Sample edge coordinate after projection: {next(iter(sample_geom.coords))}") + + # STEP 3: REBUILD GRAPH + # turn projected node/edge gdfs into a graph and update its CRS attribute + G_proj = ox.convert.graph_from_gdfs(gdf_nodes_proj, gdf_edges_proj, graph_attrs=G.graph) + G_proj.graph["crs"] = to_crs + + print(f"Projected graph with {len(G)} nodes and {len(G.edges)} edges") + + # Final verification + nodes_check, edges_check = ox.convert.graph_to_gdfs(G_proj) + print(f"Verified: Nodes CRS: {nodes_check.crs}, Edges CRS: {edges_check.crs}") + + return G_proj + + +def download_and_prepare_osm_network(_study_area_config: dict) -> nx.MultiDiGraph: + """Download and prepare OSM network based on study area configuration.""" + print("=== Starting OSM Network Download and Preparation ===") + + # Apply OSMNX settings + for setting, value in _study_area_config["osmnx_settings"].items(): + setattr(ox.settings, setting, value) + print("✓ OSMNX settings applied") + + # List to store the graphs + graphs = [] + + # Set up study area parameters + study_area = _study_area_config['study_area'] + base_name = f"{_study_area_config['work_dir']}/geo/{study_area}" + census_year = _study_area_config["census_year"] + utm_epsg = _study_area_config["utm_epsg"] + state_fips_code = _study_area_config["state_fips"] + county_fips_codes = _study_area_config["county_fips"] + tolerance = _study_area_config["tolerance"] + + print(f"Collecting {study_area} boundaries...") + + # Process each layer defined in the configuration + for layer_name, layer_config in _study_area_config["graph_layers"].items(): + # Get layer configuration + geo_level = layer_config["geo_level"] + min_density = layer_config.get("min_density_per_km2", 0) + custom_filter = layer_config["custom_filter"] + buffer_in_meters = layer_config["buffer_zone_in_meters"] + + # Create the region boundary GeoDataFrame + region_boundary_wgs84 = collect_geographic_boundaries( + state_fips_code=state_fips_code, + county_fips_codes=county_fips_codes, + year=census_year, + study_area_boundary_geo_path=f"{base_name}_{geo_level}_{census_year}_wgs84.geojson", + geo_level=geo_level + ) + + # Process specific layer types + if layer_name == "main": + print(f"Processing {layer_name} layer") + graph_layer = to_convex_hull(region_boundary_wgs84, utm_epsg, buffer_in_meters) + network_type = "drive" + simplify = False + retain_all = True + truncate_by_edge = True + + elif layer_name == "residential": + density_info = f" with minimum density: {min_density} pop/km²" if min_density > 0 else "" + print(f"Processing {layer_name} layer{density_info}") + + # Get population data + pop_data = collect_census_data( + state_fips_code, + county_fips_codes, + census_year, + census_data_file=f"{base_name}_acs_census_{geo_level}_{census_year}.csv", + geo_level=geo_level + ) + + filtered_boundaries = filter_boundaries_by_density( + region_boundary_wgs84, + pop_data, + utm_epsg, + geo_level, + min_density, + density_geo_file=f"{base_name}_{geo_level}_{census_year}_{min_density}ppsk_wgs84.geojson", + ) + + graph_layer = shapely.ops.unary_union([ + to_convex_hull(geom, utm_epsg, buffer_in_meters) for geom in filtered_boundaries.geometry + ]) + + network_type = "drive" + simplify = False + retain_all = True + truncate_by_edge = True + + elif layer_name == "ferry": + print(f"Processing ferry layer to connect islands...") + graph_layer = to_convex_hull(region_boundary_wgs84, utm_epsg, buffer_in_meters) + network_type = "all" + simplify = True + retain_all = True + truncate_by_edge = False + + else: + raise ValueError(f"Invalid layer name: {layer_name}") + + print("✓ Boundaries collected and unified") + + # Download OSM Network + print(f"Downloading OSM network with filter: {custom_filter}") + g = ox.graph_from_polygon( + graph_layer, + network_type=network_type, + simplify=simplify, + retain_all=retain_all, + truncate_by_edge=truncate_by_edge, + custom_filter=custom_filter + ) + print(f"✓ Downloaded network with {g.number_of_nodes()} nodes and {g.number_of_edges()} edges") + + # Special processing for ferry network + if layer_name == "ferry": + g = process_ferry_edges(g) + if g.number_of_edges() > 0: + print(f"✓ Processed {g.number_of_edges()} ferry connections") + else: + print("✗ No suitable ferry connections found") + continue # Skip adding this empty graph + + # Add the graph to the list if it has edges + adjust_and_add_graph(graphs, g) + + # Combine all graphs + print("=== Processing Combined Network ===") + g_combined = nx.compose_all(graphs) + print(f"✓ Combined network has {g_combined.number_of_nodes()} nodes and {g_combined.number_of_edges()} edges") + + # Project to UTM for processing + print("Projecting graph to UTM...") + g_projected = project_graph(g_combined, to_crs=utm_epsg) + print("✓ Network projected to UTM") + + # Add edge speeds + print("Adding edge speeds...") + g_with_speeds = ox.add_edge_speeds(g_projected) + print("✓ Edge speeds added") + + # Process tags for vehicle types + print("Processing tags...") + g_processed_tags = process_tags(g_with_speeds, _study_area_config) + print("✓ Edge tags processed") + + # Consolidate intersections + print("Consolidating intersections...") + g_consolidated = ox.consolidate_intersections( + g_processed_tags, + tolerance=tolerance, + rebuild_graph=True, + dead_ends=True, + reconnect_edges=True + ) + print("✓ Intersections consolidated") + + # Simplify the graph + print("Simplifying graph...") + g_simplified = ox.simplification.simplify_graph( + g_consolidated, + edge_attrs_differ=["highway", "lanes", "maxspeed"], + remove_rings=False, + track_merged=True, + edge_attr_aggs={ + "length": sum, + "travel_time": sum, + "hgv": bool_all, + "mdv": bool_all, + "lanes": median_lanes, + "speed_kph": mean, + "maxspeed": mean_maxspeed, + "oneway": yes_no_all, + "access": yes_no_all, + "reversed": bool_all, + "maxweight": min + } + ) + print("✓ Network simplified") + + # Create unique edge IDs + nodes, edges = ox.graph_to_gdfs(g_simplified) + edges['edge_id'] = edges.apply( + lambda row: create_unique_edge_id(row['u_original'], row['v_original'], row['osmid'], row.get('key', None)), + axis=1 + ) + g_hashed = ox.graph_from_gdfs(nodes, edges) + print("✓ Unique edge IDs created") + + # Project back to WGS84 + print("Projecting to WGS84...") + g_wgs84 = project_graph(g_hashed, to_latlong=True) + print("✓ Projected to WGS84") + + # Find largest connected component + print("Finding largest connected component...") + g_connected = ox.truncate.largest_component(g_wgs84) + print(f"✓ Final network has {g_connected.number_of_nodes()} nodes and {g_connected.number_of_edges()} edges") + + print("=== Network Download and Preparation Complete ===") + return g_connected + + +def scan_network_directories_for_ways(directory): + import csv + import subprocess + import os + + def calculate_ways(osm_file): + try: + # Use osmium to get file info with summary + result = subprocess.run(['osmium', 'fileinfo', '-e', osm_file], + capture_output=True, text=True) + # Initialize ways_count variable + ways_count = 0 + + # Extract the number of ways from the output + for line in result.stdout.splitlines(): + if "Number of ways" in line: + ways_count = line.split(":")[1].strip() # Get the number of ways + break # Stop after finding the count + + return ways_count # Return the number of ways + except Exception as e: + print(f"Error processing {osm_file}: {e}") + return 0 + + output_file = os.path.join(directory, 'ways_count.csv') + scanned_files = set() + + # Check if output file exists and load already processed files + if os.path.exists(output_file): + try: + with open(output_file, 'r', newline='') as f: + reader = csv.reader(f) + next(reader, None) # Skip header, safely + for row in reader: + if len(row) >= 3: # Ensure the row has enough columns + scanned_files.add(row[2]) # Add scanned file path to the set + except Exception as e: + print(f"Error reading existing CSV: {e}") + else: + # Create the output file and write the header + with open(output_file, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['name', 'ways', 'path']) + print(f"Created output file: {output_file}") + + print(f"Scanning directory: {directory}") # Log current directory being scanned + for root, dirs, files in os.walk(directory): + # Skip archive directories + if 'archive' in root.lower(): + print(f"Ignoring archive directory: {root}") + continue + + # Look for the first osm.pbf file using next() with a generator expression + osm_file_path = next((os.path.join(root, file) for file in files if file.endswith('.osm.pbf')), None) + + if osm_file_path is not None: + if osm_file_path in scanned_files: + print(f"PBF file already processed: {osm_file_path}") # Log already processed directory + continue + else: + # Extract network name from the file name or directory name + network_name = os.path.basename(root) # Use the directory name as the network name + number_of_ways = calculate_ways(osm_file_path) + + # Ensure file ends with newline before appending + """Ensure the file ends with a newline character.""" + if os.path.exists(output_file) and os.path.getsize(output_file) > 0: + with open(output_file, 'rb+') as f: + f.seek(-1, os.SEEK_END) # Go to the last byte + last_char = f.read(1) + if last_char != b'\n': + f.seek(0, os.SEEK_END) # Go to the end of the file + f.write(b'\n') # Add a newline if it doesn't end with one + + # Append result to the output CSV file + with open(output_file, 'a', newline='') as f: + writer = csv.writer(f) + writer.writerow([network_name, number_of_ways, osm_file_path]) # Write network name, number of ways, and path + print(f"Appended to CSV: {network_name}, {number_of_ways}, {osm_file_path}") # Log appended data + else: + print(f"No OSM file found in this directory: {root}.") # Log message if no file found + continue # Skip to the next directory if no file is found + +def check_invalid_coordinates(graph): + """ + Check for invalid coordinates in the graph nodes. + + Parameters: + ----------- + graph : networkx.MultiDiGraph + The graph to check + + Returns: + -------- + tuple + (has_invalid, invalid_nodes) where: + - has_invalid: boolean indicating if any invalid coordinates were found + - invalid_nodes: list of node IDs with invalid coordinates + """ + nodes, _ = ox.graph_to_gdfs(graph) + + # Check for NaN, infinite, or out-of-range coordinates + invalid_x = ~nodes['x'].between(-180, 180) | nodes['x'].isna() | nodes['x'].abs().eq(float('inf')) + invalid_y = ~nodes['y'].between(-90, 90) | nodes['y'].isna() | nodes['y'].abs().eq(float('inf')) + + # Combine invalid x or y + invalid_nodes = nodes[invalid_x | invalid_y] + + if len(invalid_nodes) > 0: + print(f"\nWARNING: Found {len(invalid_nodes)} nodes with invalid coordinates:") + for idx, node in invalid_nodes.iterrows(): + print(f" Node ID: {idx}, x: {node['x']}, y: {node['y']}") + return True, invalid_nodes.index.tolist() + + return False, [] + + +class OSMTagHandler(osmium.SimpleHandler): + def __init__(self): + osmium.SimpleHandler.__init__(self) + # Create separate counters for different element types + self.way_tag_counters = defaultdict(Counter) + self.node_tag_counters = defaultdict(Counter) + self.relation_tag_counters = defaultdict(Counter) + self.other_tags_counters = defaultdict(Counter) + self.records = [] + self.unique_tags = set() + self.total_ways = 0 + self.total_nodes = 0 + self.total_relations = 0 + + def process_other_tags(self, other_tags_str): + """Parse hstore-formatted other_tags string into a dictionary""" + if not other_tags_str: + return {} + + parsed_tags = {} + try: + # Handle the format: "key"=>"value","key2"=>"value2",... + current = "" + in_quotes = False + key = None + parts = [] + + # First split into key=>value parts + for char in other_tags_str: + if char == '"' and (not current or current[-1] != '\\'): + in_quotes = not in_quotes + + current += char + + if char == ',' and not in_quotes: + parts.append(current[:-1]) # Remove the trailing comma + current = "" + + if current: # Add the last part if there is one + parts.append(current) + + # Now process each part to extract key and value + for part in parts: + if "=>" in part: + key_val = part.split("=>") + if len(key_val) == 2: + k = key_val[0].strip().strip('"') + v = key_val[1].strip().strip('"') + parsed_tags[k] = v + + # Update counter for this key-value pair + self.other_tags_counters[k][v] += 1 + except Exception as e: + print(f"Error parsing other_tags: {e}, value: {other_tags_str[:100]}") + + return parsed_tags + + def way(self, w): + """Process a way and its tags""" + self.total_ways += 1 + + # Extract all tags into a dictionary + tags_dict = {} + other_tags_dict = {} + + for tag in w.tags: + tag_key = tag.k + tag_value = tag.v + + # Add to our unique tags set + self.unique_tags.add(tag_key) + + # Store the tag and update its counter for ways + tags_dict[tag_key] = tag_value + self.way_tag_counters[tag_key][tag_value] += 1 + + # Check if this is an other_tags field that needs parsing + if tag_key == 'other_tags': + other_tags_dict = self.process_other_tags(tag_value) + + # Store the record with all its tags + record = { + 'id': w.id, + **tags_dict, + 'other_tags_parsed': other_tags_dict + } + + self.records.append(record) + + # Also handle nodes and relations if needed + def node(self, n): + self.total_nodes += 1 + for tag in n.tags: + self.unique_tags.add(tag.k) + self.node_tag_counters[tag.k][tag.v] += 1 + + def relation(self, r): + self.total_relations += 1 + for tag in r.tags: + self.unique_tags.add(tag.k) + self.relation_tag_counters[tag.k][tag.v] += 1 + + +def analyze_osm_pbf(file_path, num_top_values=10): + """ + Analyze an OSM PBF file and return statistics about all tags, + separated by element type (way, node, relation) + + Args: + file_path: Path to the OSM PBF file + num_top_values: Optional, Number of top values to report for each tag + + Returns: + Dictionary of statistics and DataFrame of records + """ + print(f"Analyzing OSM PBF file: {file_path}") + handler = OSMTagHandler() + + # Process the file + handler.apply_file(file_path) + + print(f"Processed {handler.total_ways} ways, {handler.total_nodes} nodes, and {handler.total_relations} relations") + print(f"Found {len(handler.unique_tags)} unique tag keys") + + # Create summary statistics for ways + way_stats = {} + for tag_key, counter in handler.way_tag_counters.items(): + total = sum(counter.values()) + way_stats[tag_key] = { + 'count': total, + 'unique_values': len(counter), + 'top_values': dict(counter.most_common(num_top_values)), + 'percent_present': round(total / handler.total_ways * 100, 2) if handler.total_ways > 0 else 0 + } + + # Sort way stats by frequency + way_stats = {k: v for k, v in sorted( + way_stats.items(), + key=lambda item: item[1]['count'], + reverse=True + )} + + # Create summary statistics for nodes + node_stats = {} + for tag_key, counter in handler.node_tag_counters.items(): + total = sum(counter.values()) + node_stats[tag_key] = { + 'count': total, + 'unique_values': len(counter), + 'top_values': dict(counter.most_common(num_top_values)), + 'percent_present': round(total / handler.total_nodes * 100, 2) if handler.total_nodes > 0 else 0 + } + + # Sort node stats by frequency + node_stats = {k: v for k, v in sorted( + node_stats.items(), + key=lambda item: item[1]['count'], + reverse=True + )} + + # Create summary statistics for relations + relation_stats = {} + for tag_key, counter in handler.relation_tag_counters.items(): + total = sum(counter.values()) + relation_stats[tag_key] = { + 'count': total, + 'unique_values': len(counter), + 'top_values': dict(counter.most_common(num_top_values)), + 'percent_present': round(total / handler.total_relations * 100, 2) if handler.total_relations > 0 else 0 + } + + # Sort relation stats by frequency + relation_stats = {k: v for k, v in sorted( + relation_stats.items(), + key=lambda item: item[1]['count'], + reverse=True + )} + + # Create similar statistics for other_tags fields + other_tags_stats = {} + for tag_key, counter in handler.other_tags_counters.items(): + total = sum(counter.values()) + other_tags_stats[tag_key] = { + 'count': total, + 'unique_values': len(counter), + 'top_values': dict(counter.most_common(num_top_values)), + 'percent_present': round(total / (handler.total_ways + handler.total_nodes + handler.total_relations) * 100, 2) + } + + # Sort other_tags stats by frequency + other_tags_stats = {k: v for k, v in sorted( + other_tags_stats.items(), + key=lambda item: item[1]['count'], + reverse=True + )} + + # Create a DataFrame from the records + records_df = pd.DataFrame(handler.records) if handler.records else pd.DataFrame() + + # Return the summary statistics and records + return { + 'total_ways': handler.total_ways, + 'total_nodes': handler.total_nodes, + 'total_relations': handler.total_relations, + 'unique_tags': list(handler.unique_tags), + 'way_stats': way_stats, + 'node_stats': node_stats, + 'relation_stats': relation_stats, + 'other_tags_stats': other_tags_stats + }, records_df + + +def print_tag_stats(stats, category_name="Tags", element_type="Elements", limit=None): + """Print tag statistics in a formatted way""" + print(f"\n=== {category_name} Statistics for {element_type} ===") + print(f"Total unique {category_name.lower()}: {len(stats)}") + + for i, (tag, data) in enumerate(stats.items()): + if limit and i >= limit: + print(f"\n... and {len(stats) - limit} more {category_name.lower()}.") + break + + print(f"\n{i + 1}. {tag}: {data['count']} instances ({data['percent_present']}% of {element_type.lower()})") + print(f" Unique values: {data['unique_values']}") + print(" Top values:") + + # Print top values with their counts + for val, count in data['top_values'].items(): + # Truncate very long values + display_val = val[:50] + "..." if len(val) > 50 else val + print(f" - {display_val}: {count}") + + +def check_duplicate_edge_ids(edges_gdf, id_column='edge_id'): + """ + Check for duplicate edge IDs in an OSMnx edges GeoDataFrame. + + Parameters: + ----------- + edges_gdf : GeoDataFrame + The edges GeoDataFrame from ox.graph_to_gdfs() + id_column : str, default 'edge_id' + The column name containing the edge IDs to check + + Returns: + -------- + tuple + (has_duplicates, duplicate_info) where: + - has_duplicates: Boolean indicating if duplicates were found + - duplicate_info: DataFrame containing the duplicate IDs and their counts + """ + # Count occurrences of each edge_id + id_counts = edges_gdf[id_column].value_counts() + + # Filter to only those with count > 1 (duplicates) + duplicates = id_counts[id_counts > 1] + + if len(duplicates) > 0: + # Create a DataFrame with duplicate IDs and their counts + duplicate_info = duplicates.reset_index() + duplicate_info.columns = ['edge_id', 'count'] + + # Get examples of each duplicate + examples = [] + for dup_id in duplicate_info['edge_id']: + # Get the first few examples of this duplicate ID + example_edges = edges_gdf[edges_gdf[id_column] == dup_id].head(3) + examples.append(example_edges) + + if examples: + # Concatenate all example edges into one DataFrame + examples_df = pd.concat(examples) + duplicate_info = (duplicate_info, examples_df) + + print(f"Found {len(duplicates)} duplicate edge IDs out of {len(edges_gdf)} total edges") + return True, duplicate_info + else: + print(f"No duplicate edge IDs found in {len(edges_gdf)} edges") + return False, None + + +def main(file_path=None): + """Main function to analyze an OSM PBF file""" + if not file_path: + print("\nNo file provided. To analyze a file, run: python osm_analyzer.py ") + return + + # Analyze the PBF file + stats, records_df = analyze_osm_pbf(file_path, 30) + + print(f"\n=== OSM PBF Analysis Summary ===") + print(f"Total ways processed: {stats['total_ways']}") + print(f"Total nodes processed: {stats['total_nodes']}") + print(f"Total relations processed: {stats['total_relations']}") + print(f"Total unique tags found: {len(stats['unique_tags'])}") + + # Print way tag statistics + print_tag_stats(stats['way_stats'], "Way Tags", "Ways", limit=20) + + # Print node tag statistics + print_tag_stats(stats['node_stats'], "Node Tags", "Nodes", limit=20) + + # Print relation tag statistics + print_tag_stats(stats['relation_stats'], "Relation Tags", "Relations", limit=20) + + # Print other_tags statistics + print_tag_stats(stats['other_tags_stats'], "other_tags Keys", "All Elements", limit=20) + + # Show column names in the data + if not records_df.empty: + print("\n=== DataFrame Columns ===") + columns = list(records_df.columns) + for i, col in enumerate(columns): + print(f"{i + 1}. {col}") + + return stats, records_df + + +if __name__ == "__main__": + if len(sys.argv) < 2: + main() + else: + main(sys.argv[1]) + + + diff --git a/src/main/python/network_validation/osm_xml.py b/src/main/python/network_validation/osm_xml.py new file mode 100644 index 00000000000..cc0b2f27f2a --- /dev/null +++ b/src/main/python/network_validation/osm_xml.py @@ -0,0 +1,476 @@ +"""Read/write .osm formatted XML files.""" + +import bz2 +import xml.sax +from pathlib import Path +from warnings import warn +from xml.etree import ElementTree as ET +import osmnx as ox +from osmnx import settings +from osmnx import truncate +import networkx as nx +import numpy as np +import pandas as pd + +class _OSMContentHandler(xml.sax.handler.ContentHandler): + """ + SAX content handler for OSM XML. + + Used to build an Overpass-like response JSON object in self.object. For + format notes, see https://wiki.openstreetmap.org/wiki/OSM_XML and + https://overpass-api.de + """ + + def __init__(self): + self._element = None + self.object = {"elements": []} + + def startElement(self, name, attrs): + if name == "osm": + self.object.update({k: v for k, v in attrs.items() if k in {"version", "generator"}}) + + elif name in {"node", "way"}: + self._element = dict(type=name, tags={}, nodes=[], **attrs) + self._element.update({k: float(v) for k, v in attrs.items() if k in {"lat", "lon"}}) + self._element.update( + {k: int(v) for k, v in attrs.items() if k in {"id", "uid", "version", "changeset"}} + ) + + elif name == "relation": + self._element = dict(type=name, tags={}, members=[], **attrs) + self._element.update( + {k: int(v) for k, v in attrs.items() if k in {"id", "uid", "version", "changeset"}} + ) + + elif name == "tag": + self._element["tags"].update({attrs["k"]: attrs["v"]}) + + elif name == "nd": + self._element["nodes"].append(int(attrs["ref"])) + + elif name == "member": + self._element["members"].append( + {k: (int(v) if k == "ref" else v) for k, v in attrs.items()} + ) + + def endElement(self, name): + if name in {"node", "way", "relation"}: + self.object["elements"].append(self._element) + + +def _overpass_json_from_file(filepath, encoding): + """ + Read OSM XML from file and return Overpass-like JSON. + + Parameters + ---------- + filepath : string or pathlib.Path + path to file containing OSM XML data + encoding : string + the XML file's character encoding + + Returns + ------- + OSMContentHandler object + """ + + # open the XML file, handling bz2 or regular XML + def _opener(filepath, encoding): + if filepath.suffix == ".bz2": + return bz2.open(filepath, mode="rt", encoding=encoding) + + # otherwise just open it if it's not bz2 + return filepath.open(encoding=encoding) + + # warn if this XML file was generated by OSMnx itself + with _opener(Path(filepath), encoding) as f: + root_attrs = ET.parse(f).getroot().attrib + if "generator" in root_attrs and "OSMnx" in root_attrs["generator"]: + warn( + "The XML file you are loading appears to have been generated " + "by OSMnx: this use case is not supported and may not behave " + "as expected. To save/load graphs to/from disk for later use " + "in OSMnx, use the `io.save_graphml` and `io.load_graphml` " + "functions instead. Refer to the documentation for details.", + stacklevel=2, + ) + + # parse the XML to Overpass-like JSON + with _opener(Path(filepath), encoding) as f: + handler = _OSMContentHandler() + xml.sax.parse(f, handler) + return handler.object + + +def save_graph_xml( + data, + filepath=None, + edge_tags=None, + edge_tag_aggs=None +): + """ + Parameters + ---------- + data : networkx.MultiDiGraph + do not use, deprecated + filepath : string or pathlib.Path + do not use, deprecated + edge_tags : list + do not use, deprecated + edge_tag_aggs : tuple + do not use, deprecated + + Returns + ------- + None + """ + _save_graph_xml( + data, + filepath, + edge_tags, + edge_tag_aggs + ) + + +def _save_graph_xml( # noqa: C901 + data, + filepath, + edge_tags, + edge_tag_aggs +): + """ + Save graph to disk as an OSM-formatted UTF-8 encoded XML .osm file. + + Parameters + ---------- + data : networkx.MultiDiGraph + the input graph + filepath : string or pathlib.Path + do not use, deprecated + edge_tags : list + do not use, deprecated + edge_tag_aggs : tuple + do not use, deprecated + + Returns + ------- + None + """ + if edge_tags is None: + edge_tags = ["highway", "lanes", "maxspeed", "name", "oneway"] + oneway = False + merge_edges = True + api_version = 0.6 + precision = 6 + edge_attrs = ["id", "timestamp", "uid", "user", "version", "changeset"] + node_tags = ["highway"] + node_attrs = [ + "id", + "timestamp", + "uid", + "user", + "version", + "changeset", + "lat", + "lon", + ] + + # default filepath if none was provided + filepath = Path(settings.data_folder) / "graph.osm" if filepath is None else Path(filepath) + + # if save folder does not already exist, create it + filepath.parent.mkdir(parents=True, exist_ok=True) + + if not settings.all_oneway: # pragma: no cover + warn( + "For the `save_graph_xml` function to behave properly, the graph " + "must have been created with `ox.settings.all_oneway=True`.", + stacklevel=2, + ) + + try: + gdf_nodes, gdf_edges = data + except ValueError: + gdf_nodes, gdf_edges = ox.convert.graph_to_gdfs( + data, node_geometry=False, fill_edge_geometry=False + ) + + # rename columns per osm specification + gdf_nodes = gdf_nodes.rename(columns={"x": "lon", "y": "lat"}) + gdf_nodes["lon"] = gdf_nodes["lon"].round(precision) + gdf_nodes["lat"] = gdf_nodes["lat"].round(precision) + gdf_nodes = gdf_nodes.reset_index().rename(columns={"osmid": "id"}) + if "id" in gdf_edges.columns: + gdf_edges = gdf_edges[[col for col in gdf_edges if col != "id"]] + if "uniqueid" in gdf_edges.columns: + gdf_edges = gdf_edges.rename(columns={"uniqueid": "id"}) + else: + gdf_edges = gdf_edges.reset_index().reset_index().rename(columns={"index": "id"}) + + # add default values for required attributes + for table in (gdf_nodes, gdf_edges): + table["uid"] = "1" + table["user"] = "OSMnx" + table["version"] = "1" + table["changeset"] = "1" + table["timestamp"] = ox.utils.ts(template="{:%Y-%m-%dT%H:%M:%SZ}") + + # misc. string replacements to meet OSM XML spec + if "oneway" in gdf_edges.columns: + # fill blank oneway tags with default (False) + gdf_edges.loc[pd.isna(gdf_edges["oneway"]), "oneway"] = oneway + gdf_edges.loc[:, "oneway"] = gdf_edges["oneway"].astype(str) + gdf_edges.loc[:, "oneway"] = ( + gdf_edges["oneway"].str.replace("False", "no").replace("True", "yes") + ) + + # initialize XML tree with an OSM root element then append nodes/edges + root = ET.Element( + "osm", attrib={"version": str(api_version), "generator": f"OSMnx {ox.__version__}"} + ) + root = _append_nodes_xml_tree(root, gdf_nodes, node_attrs, node_tags) + root = _append_edges_xml_tree( + root, gdf_edges, edge_attrs, edge_tags, edge_tag_aggs, merge_edges + ) + + # write to disk + ET.ElementTree(root).write(filepath, encoding="utf-8", xml_declaration=True) + ox.utils.log(f"Saved graph as .osm file at {filepath!r}") + + +def _append_nodes_xml_tree(root, gdf_nodes, node_attrs, node_tags): + """ + Append nodes to an XML tree. + + Parameters + ---------- + root : ElementTree.Element + xml tree + gdf_nodes : geopandas.GeoDataFrame + GeoDataFrame of graph nodes + node_attrs : list + osm way attributes to include in output OSM XML + node_tags : list + osm way tags to include in output OSM XML + + Returns + ------- + root : ElementTree.Element + xml tree with nodes appended + """ + for _, row in gdf_nodes.iterrows(): + row_str = row.dropna().astype(str) + node = ET.SubElement(root, "node", attrib=row_str[node_attrs].to_dict()) + + for tag in node_tags: + if tag in row_str: + ET.SubElement(node, "tag", attrib={"k": tag, "v": row_str[tag]}) + return root + + +def _create_way_for_each_edge(root, gdf_edges, edge_attrs, edge_tags): + """ + Append a new way to an empty XML tree graph for each edge in way. + + This will generate separate OSM ways for each network edge, even if the + edges are all part of the same original OSM way. As such, each way will be + composed of two nodes, and there will be many ways with the same OSM ID. + This does not conform to the OSM XML schema standard, but the data will + still comprise a valid network and will be readable by most OSM tools. + + Parameters + ---------- + root : ElementTree.Element + an empty XML tree + gdf_edges : geopandas.GeoDataFrame + GeoDataFrame of graph edges + edge_attrs : list + osm way attributes to include in output OSM XML + edge_tags : list + osm way tags to include in output OSM XML + """ + for _, row in gdf_edges.iterrows(): + row_str = row.dropna().astype(str) + edge = ET.SubElement(root, "way", attrib=row_str[edge_attrs].to_dict()) + ET.SubElement(edge, "nd", attrib={"ref": row_str["u"]}) + ET.SubElement(edge, "nd", attrib={"ref": row_str["v"]}) + for tag in edge_tags: + if tag in row_str: + ET.SubElement(edge, "tag", attrib={"k": tag, "v": row_str[tag]}) + + +def _append_merged_edge_attrs(xml_edge, sample_edge, all_edges_df, edge_tags, edge_tag_aggs): + """ + Extract edge attributes and append to XML edge. + + Parameters + ---------- + xml_edge : ElementTree.SubElement + XML representation of an output graph edge + sample_edge: pandas.Series + sample row from the the dataframe of way edges + all_edges_df: pandas.DataFrame + a dataframe with one row for each edge in an OSM way + edge_tags : list + osm way tags to include in output OSM XML + edge_tag_aggs : list of length-2 string tuples + useful only if merge_edges is True, this argument allows the user to + specify edge attributes to aggregate such that the merged OSM way + entry tags accurately represent the sum total of their component edge + attributes. For example if the user wants the OSM way to have a length + attribute, the user must specify `edge_tag_aggs=[('length', 'sum')]` + to tell this method to aggregate the lengths of the individual + component edges. Otherwise, the length attribute will simply reflect + the length of the first edge associated with the way. + + """ + if edge_tag_aggs is None: + for tag in edge_tags: + if tag in sample_edge: + ET.SubElement(xml_edge, "tag", attrib={"k": tag, "v": sample_edge[tag]}) + else: + for tag in edge_tags: + if (tag in sample_edge) and (tag not in (t for t, agg in edge_tag_aggs)): + ET.SubElement(xml_edge, "tag", attrib={"k": tag, "v": sample_edge[tag]}) + + for tag, agg in edge_tag_aggs: + if tag in all_edges_df.columns: + ET.SubElement( + xml_edge, + "tag", + attrib={ + "k": tag, + "v": str(all_edges_df[tag].aggregate(agg)), + }, + ) + + +def _append_nodes_as_edge_attrs(xml_edge, sample_edge, all_edges_df): + """ + Extract list of ordered nodes and append as attributes of XML edge. + + Parameters + ---------- + xml_edge : ElementTree.SubElement + XML representation of an output graph edge + sample_edge: pandas.Series + sample row from the the dataframe of way edges + all_edges_df: pandas.DataFrame + a dataframe with one row for each edge in an OSM way + """ + if len(all_edges_df) == 1: + ET.SubElement(xml_edge, "nd", attrib={"ref": sample_edge["u"]}) + ET.SubElement(xml_edge, "nd", attrib={"ref": sample_edge["v"]}) + else: + # topological sort + all_edges_df = all_edges_df.reset_index() + try: + ordered_nodes = _get_unique_nodes_ordered_from_way(all_edges_df) + except nx.NetworkXUnfeasible: + first_node = all_edges_df.iloc[0]["u"] + ordered_nodes = _get_unique_nodes_ordered_from_way(all_edges_df.iloc[1:]) + ordered_nodes = [first_node] + ordered_nodes + for node in ordered_nodes: + ET.SubElement(xml_edge, "nd", attrib={"ref": str(node)}) + + +def _append_edges_xml_tree(root, gdf_edges, edge_attrs, edge_tags, edge_tag_aggs, merge_edges): + """ + Append edges to an XML tree. + + Parameters + ---------- + root : ElementTree.Element + xml tree + gdf_edges : geopandas.GeoDataFrame + GeoDataFrame of graph edges + edge_attrs : list + osm way attributes to include in output OSM XML + edge_tags : list + osm way tags to include in output OSM XML + edge_tag_aggs : list of length-2 string tuples + useful only if merge_edges is True, this argument allows the user + to specify edge attributes to aggregate such that the merged + OSM way entry tags accurately represent the sum total of + their component edge attributes. For example, if the user + wants the OSM way to have a "length" attribute, the user must + specify `edge_tag_aggs=[('length', 'sum')]` in order to tell + this method to aggregate the lengths of the individual + component edges. Otherwise, the length attribute will simply + reflect the length of the first edge associated with the way. + merge_edges : bool + if True merges graph edges such that each OSM way has one entry + and one entry only in the OSM XML. Otherwise, every OSM way + will have a separate entry for each node pair it contains. + + Returns + ------- + root : ElementTree.Element + XML tree with edges appended + """ + gdf_edges = gdf_edges.reset_index() + if merge_edges: + for _, all_way_edges in gdf_edges.groupby("id"): + first = all_way_edges.iloc[0].dropna().astype(str) + edge = ET.SubElement(root, "way", attrib=first[edge_attrs].dropna().to_dict()) + _append_nodes_as_edge_attrs( + xml_edge=edge, sample_edge=first, all_edges_df=all_way_edges + ) + _append_merged_edge_attrs( + xml_edge=edge, + sample_edge=first, + edge_tags=edge_tags, + edge_tag_aggs=edge_tag_aggs, + all_edges_df=all_way_edges, + ) + + else: + _create_way_for_each_edge( + root=root, + gdf_edges=gdf_edges, + edge_attrs=edge_attrs, + edge_tags=edge_tags, + ) + + return root + + +def _get_unique_nodes_ordered_from_way(df_way_edges): + """ + Recover original node order from edges associated with a single OSM way. + + Parameters + ---------- + df_way_edges : pandas.DataFrame + Dataframe containing columns 'u' and 'v' corresponding to + origin/destination nodes. + + Returns + ------- + unique_ordered_nodes : list + An ordered list of unique node IDs. If the edges do not all connect + (e.g. [(1, 2), (2,3), (10, 11), (11, 12), (12, 13)]), then this method + will return only those nodes associated with the largest component of + connected edges, even if subsequent connected chunks are contain more + total nodes. This ensures a proper topological representation of nodes + in the XML way records because if there are unconnected components, + the sorting algorithm cannot recover their original order. We would + not likely ever encounter this kind of disconnected structure of nodes + within a given way, but it is not explicitly forbidden in the OSM XML + design schema. + """ + G = nx.MultiDiGraph() + all_nodes = list(df_way_edges["u"].to_numpy()) + list(df_way_edges["v"].to_numpy()) + + G.add_nodes_from(all_nodes) + G.add_edges_from(df_way_edges[["u", "v"]].to_numpy()) + + # copy nodes into new graph + H = ox.truncate.largest_component(G, strongly=False) + unique_ordered_nodes = list(nx.topological_sort(H)) + num_unique_nodes = len(np.unique(all_nodes)) + + if len(unique_ordered_nodes) < num_unique_nodes: + ox.utils.log(f"Recovered order for {len(unique_ordered_nodes)} of {num_unique_nodes} nodes") + + return unique_ordered_nodes diff --git a/src/main/python/network_validation/prepare_npmrds_data_and_stations.py b/src/main/python/network_validation/prepare_npmrds_data_and_stations.py index 604ff3146f6..bca9dadc887 100644 --- a/src/main/python/network_validation/prepare_npmrds_data_and_stations.py +++ b/src/main/python/network_validation/prepare_npmrds_data_and_stations.py @@ -1,24 +1,41 @@ from validation_utils import * +from _data_collection_utils import collect_geographic_boundaries +import sys + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +from python.utils.study_area_config import get_area_config +from python.utils.study_area_config import generate_network_name # In Mac, you might need to cd to folder '/Applications/Python {version}' # and run ./Install\ Certificates.command # # To prepare data for a new study area, make sure to change the following configuration variables # Example of preparing SFBay data (9 counties + Santa Cruz and Yolo) -census_year = 2018 -state_fips = '06' study_area = "sfbay" -study_area_crs = 26910 -study_area_fips = ['001', '013', '041', '055', '075', '081', '085', '095', '097', '087', '113'] - -"beam/runs/calibration-jdeqsim" -study_area_dir = os.path.expanduser("~/Workspace/Data/Simulation") + "/" + study_area -study_area_taz_geo = study_area_dir + "/geo/shp/sfbay-tazs-epsg-26910.shp" -study_area_taz_id = "taz1454" -study_area_beam_network_csv = study_area_dir + '/validation/beam/sfbay_residential_psimpl_network.csv.gz' -npmrds_data_label = "NPMRDS_2018" -npmrds_raw_geo = study_area_dir + "/validation/npmrds/California.shp" -npmrds_raw_data_csv = study_area_dir + '/validation/npmrds/al_ca_oct2018_1hr_trucks_pax.csv' +batch = "20240123" +scenario = "2018-Baseline-FC12-Bis2" +config = get_area_config(study_area) +config["network"]["graph_layers"]["residential"]["min_density_per_km2"] = 5500 + +config_network = config["network"] +config_npmrds = config_network["validation"]["npmrds"] +config_geo = config["geo"] + +network_name = generate_network_name(config) +network_dir = f'{config["work_dir"]}/network/{network_name}' +osm_pbf_path = os.path.expanduser(f"{network_dir}/{network_name}.osm.pbf") + +output_dir = f"{config["work_dir"]}/beam-runs/{batch}/{scenario}" + +# census_year = 2018 +# state_fips = '06' +# study_area_crs = 26910 +# study_area_fips = ['001', '013', '041', '055', '075', '081', '085', '095', '097', '087', '113'] + # # The following need to be set/added manually # census_year = 2018 @@ -35,37 +52,34 @@ # npmrds_raw_data_csv = study_area_dir + '/validation_data/NPMRDS/vt_wi_2018_1hr.csv' # # -# -# -# -# -# The following will be generated automatically -study_area_county_geo = study_area_dir + "/geo/" + study_area + "_counties.geojson" -study_area_cbg_geo = study_area_dir + "/geo/" + study_area + "_cbgs.geojson" -study_area_cbg_id = "GEOID" -# study_area_taz_geo = study_area_dir + "/geo/" + study_area + "_tazs.geojson" -# study_area_taz_id = "TAZCE10" -study_area_cbg_taz_map_csv = study_area_dir + "/geo/" + study_area + "_cbg_taz_map.csv" -# -npmrds_station_geo = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_station.geojson" -npmrds_data_csv = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_data.csv" -npmrds_hourly_speed_csv = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_hourly_speeds.csv" -npmrds_hourly_speed_by_road_class_csv = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_hourly_speed_by_road_class.csv" -# -first_dot_index = study_area_beam_network_csv.find('.') -beam_network_prefix = study_area_beam_network_csv[:first_dot_index] if first_dot_index != -1 else study_area_beam_network_csv -beam_network_car_links_geo = beam_network_prefix + '_car_only.geojson' -beam_network_mapped_to_npmrds_geo = beam_network_prefix + '_mapped_to_npmrds.geojson' +# # The following will be generated automatically +# study_area_county_geo = study_area_dir + "/geo/" + study_area + "_counties.geojson" +# study_area_cbg_geo = study_area_dir + "/geo/" + study_area + "_cbgs.geojson" +# # study_area_taz_geo = study_area_dir + "/geo/" + study_area + "_tazs.geojson" +# # study_area_taz_id = "TAZCE10" +# study_area_cbg_taz_map_csv = study_area_dir + "/geo/" + study_area + "_cbg_taz_map.csv" +# # +# npmrds_station_geo = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_station.geojson" +# npmrds_data_csv = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_data.csv" +# npmrds_hourly_speed_csv = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_hourly_speeds.csv" +# npmrds_hourly_speed_by_road_class_csv = study_area_dir + '/validation/npmrds/' + study_area + "_npmrds_hourly_speed_by_road_class.csv" +# # +# first_dot_index = study_area_beam_network_csv.find('.') +# beam_network_prefix = study_area_beam_network_csv[ +# :first_dot_index] if first_dot_index != -1 else study_area_beam_network_csv +# beam_network_car_links_geo = beam_network_prefix + '_car_only.geojson' +# beam_network_mapped_to_npmrds_geo = beam_network_prefix + '_mapped_to_npmrds.geojson' st = time.time() -if os.path.exists(study_area_county_geo): - print("Loading county boundaries...") - region_boundary_wgs84 = gpd.read_file(study_area_county_geo) -else: - print("Downloading county boundaries...") - region_boundary_wgs84 = collect_geographic_boundaries(state_fips, study_area_fips, census_year, study_area_county_geo, - study_area_crs, geo_level='county') +region_boundary_wgs84 = collect_geographic_boundaries( + config["state_fips"], + config["county_fips"], + config["census_year"], + study_area, + geo_level='county', + work_dir=f'{config["work_dir"]}/geo' + ) # sf_cbg_geo = study_area_dir + "/zones/sf_cbgs.geojson" # if os.path.exists(sf_cbg_geo): @@ -76,45 +90,42 @@ # region_boundary_wgs84 = collect_geographic_boundaries(state_fips, ['075'], cbg_year, sf_cbg_geo, # projected_coordinate_system, geo_level='cbg') -if os.path.exists(study_area_cbg_geo): - print("Loading block groups boundaries...") - cbg_boundary_wgs84 = gpd.read_file(study_area_cbg_geo) -else: - print("Downloading block groups boundaries...") - cbg_boundary_wgs84 = collect_geographic_boundaries(state_fips, study_area_fips, census_year, study_area_cbg_geo, - study_area_crs, geo_level='cbg') - -if os.path.exists(study_area_taz_geo): - print("Loading taz boundaries...") - taz_boundary_wgs84 = gpd.read_file(study_area_taz_geo).to_crs(epsg=4326) -else: - print("Downloading taz boundaries...") - taz_boundary_wgs84 = None - # TODO We need to fix the source of the TAZ data - # taz_boundary_wgs84 = collect_geographic_boundaries(state_fips, study_area_fips, 2011, study_area_taz_geo, - # projected_coordinate_system, geo_level='taz') - -if taz_boundary_wgs84 is not None: - print("Mapping block groups to taz boundaries.") - map_cbg_to_taz(cbg_boundary_wgs84, study_area_cbg_id, taz_boundary_wgs84, study_area_taz_id, study_area_crs, study_area_cbg_taz_map_csv) +cbg_boundary_wgs84 = collect_geographic_boundaries( + config["state_fips"], + config["county_fips"], + config["census_year"], + study_area, + geo_level='county', + work_dir=f'{config["work_dir"]}/geo' +) + +# taz_boundary_wgs84 = gpd.read_file(f"{config['work_dir']}/{config_geo["taz_shp"]}").to_crs(epsg=4326) +# map_cbg_to_taz( +# cbg_boundary_wgs84, +# config_geo["cbg_id"], +# taz_boundary_wgs84, +# config_geo["taz_id"], +# config_geo["utm_epsg"], +# study_area_cbg_taz_map_csv +# ) regional_npmrds_station, _, beam_npmrds_network_map, _ = prepare_npmrds_data( # input - npmrds_label=npmrds_data_label, - npmrds_raw_geo=npmrds_raw_geo, - npmrds_raw_data_csv=npmrds_raw_data_csv, + npmrds_label=f"NPMRDS_{config_npmrds["year"]}", + npmrds_raw_geo=f"{config['work_dir']}/{config_npmrds["geo"]}", + npmrds_raw_data_csv=f'{config['work_dir']}/{config_npmrds["data"]}', npmrds_observed_speed_weight=0.5, region_boundary=region_boundary_wgs84, - beam_network_csv_input=study_area_beam_network_csv, - projected_crs_epsg=study_area_crs, + beam_network_csv_input=f"{network_dir}/network.csv.gz", + projected_crs_epsg=config_geo["utm_epsg"], distance_buffer_m=20, # output - npmrds_station_geo=npmrds_station_geo, - npmrds_data_csv=npmrds_data_csv, - npmrds_hourly_speed_csv=npmrds_hourly_speed_csv, - npmrds_hourly_speed_by_road_class_csv=npmrds_hourly_speed_by_road_class_csv, - beam_network_car_links_geo=beam_network_car_links_geo, - beam_npmrds_network_map_geo=beam_network_mapped_to_npmrds_geo) + npmrds_station_geo=f"{output_dir}/{study_area}_npmrds_station.geojson", + npmrds_data_csv=f"{output_dir}/{study_area}_npmrds_data.csv", + npmrds_hourly_speed_csv=f"{output_dir}/{study_area}_npmrds_hourly_speeds.csv", + npmrds_hourly_speed_by_road_class_csv=f"{output_dir}/{study_area}_npmrds_hourly_speed_by_road_class.csv", + beam_network_car_links_geo=f"{output_dir}/{study_area}_network_car_only.geojson", + beam_npmrds_network_map_geo=f"{output_dir}/{study_area}_network_mapped_to_npmrds.geojson") # ########## Checking Network print("Plotting region boundaries and stations") @@ -123,7 +134,7 @@ region_boundary_wgs84.boundary.plot(ax=ax, color='black') regional_npmrds_station.plot(ax=ax, color='blue') plt.title("Region Boundaries and NPMRDS Stations") -fig.savefig(os.path.splitext(npmrds_station_geo)[0] + ".png", dpi=300) # Adjust dpi for resolution +fig.savefig(f"{output_dir}/{study_area}_npmrds_station.png", dpi=300) # Adjust dpi for resolution plt.show(block=False) print("Plotting BEAM Network and NPMRDS stations") @@ -132,7 +143,7 @@ regional_npmrds_station.plot(ax=ax, color='blue', linewidth=2, label='NPMRDS') beam_npmrds_network_map.plot(ax=ax, color='red', linewidth=0.5, label='BEAM') plt.title("BEAM Network and NPMRDS Stations") -fig.savefig(os.path.splitext(beam_network_mapped_to_npmrds_geo)[0] + ".png", dpi=300) # Adjust dpi for resolution +fig.savefig(f"{output_dir}/{study_area}_network_mapped_to_npmrds.png", dpi=300) # Adjust dpi for resolution plt.show(block=False) -print(f"Execution time of prepare_npmrds_data: {(time.time() - st) / 60.0}min") +print(f"Execution time of prepare_npmrds_data: {((time.time() - st) / 60.0):.2f}min") \ No newline at end of file diff --git a/src/main/python/network_validation/process_isrm_network_intersection.py b/src/main/python/network_validation/process_isrm_network_intersection.py new file mode 100644 index 00000000000..e281f038a10 --- /dev/null +++ b/src/main/python/network_validation/process_isrm_network_intersection.py @@ -0,0 +1,396 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +""" +Script to map ISRM grid polygons to OSM edge geometries. +The result splits each OSM edge by ISRM polygon and calculates the proportion +of the edge length in each polygon, starting from the ISRM grid. +All operations are performed in UTM projection and results are converted back to WGS84. +""" + +import logging +import os +import re +import sys + +import geopandas as gpd +import pandas as pd +from tqdm import tqdm + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +# Now use absolute import +from python.utils.study_area_config import get_area_config +from python.utils.study_area_config import generate_network_name + +# Set up logging +logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' +) +logger = logging.getLogger(__name__) + +# Define WGS84 EPSG code +WGS84_EPSG = 4326 + + +def parse_other_tags(other_tags): + """Parse the 'other_tags' column from OSM PBF file to extract key-value pairs.""" + if not other_tags or pd.isna(other_tags): + return {} + + # Extract key-value pairs using regex + pattern = r'"([^"]+)"=>"([^"]+)"' + matches = re.findall(pattern, other_tags) + return {key: value for key, value in matches} + + +def extract_edge_length(tags_dict): + """Extract the edge length from the tags dictionary.""" + length_str = tags_dict.get('length', None) + if length_str is None: + return None + try: + return float(length_str) + except (ValueError, TypeError): + return None + + +def process_isrm_osm_intersection(isrm_grid_path, osm_geojson_path, osm_gpkg_path, epsg_utm, output_path): + """ + Process the intersection of ISRM grid polygons with OSM edge geometries. + All operations are performed in UTM projection and results are converted back to WGS84. + + Args: + isrm_grid_path (str): Path to ISRM grid shapefile with isrm column + osm_geojson_path (str): Path to OSM GEOJSON file with osm_id and other_tags + osm_gpkg_path (str): Path to OSM GPKG network with edge_id and geometry + epsg_utm (int): EPSG code for UTM projection to use for geometric operations + output_path (str): Path to output file + + Returns: + gpd.GeoDataFrame: The resulting GeoDataFrame with intersection results + """ + # 1. Load ISRM grid + logger.info(f"Loading ISRM grid from {isrm_grid_path}") + try: + isrm_gdf = gpd.read_file(isrm_grid_path) + if 'isrm' not in isrm_gdf.columns: + logger.error("ISRM grid file is missing 'isrm' column") + sys.exit(1) + except Exception as e: + logger.error(f"Failed to load ISRM grid: {e}") + sys.exit(1) + + # 2. Load OSM GPKG network + logger.info(f"Loading OSM GPKG network from {osm_gpkg_path}") + try: + gpkg_gdf = gpd.read_file(osm_gpkg_path, layer='edges') + if 'edge_id' not in gpkg_gdf.columns: + logger.error("OSM GPKG file is missing 'edge_id' column") + sys.exit(1) + except Exception as e: + logger.error(f"Failed to load OSM GPKG: {e}") + sys.exit(1) + + # 3. Load OSM GeoJSON + logger.info(f"Loading OSM GEOJSON from {osm_geojson_path}") + try: + osm_gdf = gpd.read_file(osm_geojson_path) + if 'osm_id' not in osm_gdf.columns or 'other_tags' not in osm_gdf.columns: + logger.error("OSM file is missing 'osm_id' or 'other_tags' columns") + sys.exit(1) + except Exception as e: + logger.error(f"Failed to load OSM GeoJSON: {e}") + sys.exit(1) + + # Convert osm_id to int and parse other_tags + osm_gdf['osm_id'] = osm_gdf['osm_id'].astype(int) + + # Parse other_tags to extract edge_id and length + osm_gdf['parsed_tags'] = osm_gdf['other_tags'].apply(parse_other_tags) + osm_gdf['edge_id'] = osm_gdf['parsed_tags'].apply(lambda x: x.get('edge_id', None)) + osm_gdf['edge_length'] = osm_gdf['parsed_tags'].apply(extract_edge_length) + + # Filter out edges without length information + valid_osm_gdf = osm_gdf.dropna(subset=['edge_length']) + logger.info(f"Found {len(valid_osm_gdf)} edges with valid length information") + + # Connect OSM data to geometries + edge_geom_map = pd.merge( + valid_osm_gdf[['osm_id', 'edge_id', 'edge_length']], + gpkg_gdf[['edge_id', 'geometry']], + on='edge_id', + how='inner' + ) + + # Convert to GeoDataFrame + edge_geom_gdf = gpd.GeoDataFrame(edge_geom_map, geometry='geometry', crs=gpkg_gdf.crs) + logger.info(f"Successfully mapped {len(edge_geom_gdf)} edges to OSM geometries") + + # Project all geometries to UTM for accurate calculations + logger.info(f"Projecting geometries to UTM EPSG:{epsg_utm}") + edge_geom_gdf = edge_geom_gdf.to_crs(epsg=epsg_utm) + isrm_gdf = isrm_gdf.to_crs(epsg=epsg_utm) + + # Create a spatial index for OSM geometries to speed up intersection queries + edge_geom_sindex = edge_geom_gdf.sindex + + # Process ISRM polygons and find intersections + intersection_results = [] + + logger.info("Finding intersections between ISRM polygons and OSM edges") + for idx, isrm_row in tqdm(isrm_gdf.iterrows(), total=len(isrm_gdf), desc="Processing ISRM polygons"): + isrm_id = isrm_row['isrm'] + isrm_geom = isrm_row.geometry + + # Find potential edge geometries that intersect this ISRM polygon + possible_matches_idx = list(edge_geom_sindex.intersection(isrm_geom.bounds)) + if not possible_matches_idx: + continue + + possible_matches = edge_geom_gdf.iloc[possible_matches_idx] + + # Further filter to only those that actually intersect + intersecting_edges = possible_matches[possible_matches.geometry.intersects(isrm_geom)] + + if len(intersecting_edges) == 0: + continue + + # For each intersecting edge, calculate intersection + for edge_idx, edge_row in intersecting_edges.iterrows(): + osm_id = edge_row['osm_id'] + edge_geom = edge_row.geometry + original_length = edge_row['edge_length'] + + # Get the actual edge length from geometry for proportion calculation + edge_geom_length = edge_geom.length + + # Get the actual intersection geometry + intersection_geom = edge_geom.intersection(isrm_geom) + + # Skip empty geometries + if intersection_geom.is_empty: + continue + + # Calculate the proportion of the edge length in this ISRM polygon + intersection_length = intersection_geom.length + proportion = round(intersection_length / edge_geom_length, 2) if edge_geom_length > 0 else 0 + proportional_length = original_length * proportion + + # Create a record for this intersection + result = { + 'isrm_id': isrm_id, + 'osm_id': osm_id, + 'edge_id': edge_row['edge_id'], + 'original_edge_length': original_length, + 'proportion': proportion, + 'proportional_length': proportional_length, + 'isrm_osm_id': f"{isrm_id}-{osm_id}", + 'geometry': intersection_geom + } + + # Copy all attributes from edge + for key, value in edge_row.items(): + if key not in ['geometry', 'osm_id', 'edge_length', 'edge_id'] and key not in result: + result[f'edge_{key}'] = value + + # Copy all attributes from ISRM polygon + for key, value in isrm_row.items(): + if key not in ['geometry', 'isrm'] and key not in result: + result[f'isrm_{key}'] = value + + intersection_results.append(result) + + logger.info(f"Intersection produced {len(intersection_results)} results") + + # Create a GeoDataFrame from results + if not intersection_results: + logger.error("No intersections found") + sys.exit(1) + + result_gdf = gpd.GeoDataFrame(intersection_results, geometry='geometry', crs=epsg_utm) + + # Convert results back to WGS84 for output + logger.info(f"Converting results back to WGS84 (EPSG:{WGS84_EPSG})") + result_gdf = result_gdf.to_crs(epsg=WGS84_EPSG) + + # Save results + logger.info(f"Saving results to {output_path}") + output_dir = os.path.dirname(output_path) + if output_dir and not os.path.exists(output_dir): + os.makedirs(output_dir) + + # Determine output format based on file extension + extension = os.path.splitext(output_path)[1].lower() + if extension == '.gpkg': + result_gdf.to_file(output_path, driver='GPKG') + elif extension == '.shp': + result_gdf.to_file(output_path) + elif extension == '.geojson': + result_gdf.to_file(output_path, driver='GeoJSON') + elif extension == '.csv': + # For CSV, we need to export geometry as WKT + result_gdf['geometry_wkt'] = result_gdf.geometry.apply(lambda geom: geom.wkt) + result_df = pd.DataFrame(result_gdf.drop(columns='geometry')) + result_df.to_csv(output_path, index=False) + else: + logger.info(f"Unrecognized output format: {extension}, using GPKG format") + result_gdf.to_file(output_path, driver='GPKG') + + logger.info("Processing complete") + return result_gdf + + +def map_beam_network_to_isrm_osm_intersection(network_path, isrm_osm_path, output_path): + """ + Map network data to ISRM-OSM intersection data using attributeOrigId to match osm_id. + + Args: + network_path (str): Path to the network.csv.gz file + isrm_osm_path (str): Path to the ISRM-OSM intersection GeoJSON file + output_path (str): Path to save the output file + + Returns: + pd.DataFrame: The resulting DataFrame with mapping results + """ + # 1. Load network data + logger.info(f"Loading network data from {network_path}") + try: + network_df = pd.read_csv(network_path) + logger.info(f"Loaded network data with {len(network_df)} rows") + + # Check if attributeOrigId column exists + if 'attributeOrigId' not in network_df.columns: + logger.error("Network file is missing 'attributeOrigId' column") + return None + except Exception as e: + logger.error(f"Failed to load network data: {e}") + return None + + # Filter out rows with empty or NaN attributeOrigId + network_df = network_df.dropna(subset=['attributeOrigId']) + # 2. Load ISRM-OSM intersection data + logger.info(f"Loading ISRM-OSM intersection data from {isrm_osm_path}") + try: + isrm_osm_gdf = gpd.read_file(isrm_osm_path) + logger.info(f"Loaded ISRM-OSM data with {len(isrm_osm_gdf)} rows") + + # Check if osm_id column exists + if 'osm_id' not in isrm_osm_gdf.columns: + logger.error("ISRM-OSM file is missing 'osm_id' column") + return None + except Exception as e: + logger.error(f"Failed to load ISRM-OSM data: {e}") + return None + + # 3. Convert osm_id to the same type as attributeOrigId for proper joining + logger.info("Preparing data for mapping") + + # Make sure both ID columns are of the same type + network_df['attributeOrigId'] = network_df['attributeOrigId'].astype(int) + isrm_osm_gdf['osm_id'] = isrm_osm_gdf['osm_id'].astype(int) + + # 4. Merge the network and ISRM-OSM data + logger.info("Merging network data with ISRM-OSM data") + merged_df = pd.merge( + network_df, + isrm_osm_gdf, + left_on='attributeOrigId', + right_on='osm_id', + how='inner' + ) + + logger.info(f"Merged result has {len(merged_df)} rows") + + # 5. Calculate the proportional network values based on the ISRM-OSM proportion + logger.info("Calculating proportional values") + + # Apply proportion to network length + merged_df['proportional_network_length'] = merged_df['linkLength'] * merged_df['proportion'] + + # 6. Create a unique identifier combining network linkId and ISRM id + merged_df['network_isrm_id'] = merged_df['linkId'].astype(str) + '-' + merged_df['isrm_id'].astype(str) + + # 7. Save the result + logger.info(f"Saving mapped results to {output_path}") + output_dir = os.path.dirname(output_path) + if output_dir and not os.path.exists(output_dir): + os.makedirs(output_dir) + + # Determine output format based on file extension + extension = os.path.splitext(output_path)[1].lower() + if extension == '.gpkg': + if isinstance(merged_df, gpd.GeoDataFrame): + merged_df.to_file(output_path, driver='GPKG') + else: + # Convert to GeoDataFrame if it's just a DataFrame + logger.warning("Converting DataFrame to GeoDataFrame for GPKG output") + geo_merged_df = gpd.GeoDataFrame(merged_df, geometry='geometry') + geo_merged_df.to_file(output_path, driver='GPKG') + elif extension == '.geojson': + if isinstance(merged_df, gpd.GeoDataFrame): + merged_df.to_file(output_path, driver='GeoJSON') + else: + # Convert to GeoDataFrame if it's just a DataFrame + logger.warning("Converting DataFrame to GeoDataFrame for GeoJSON output") + geo_merged_df = gpd.GeoDataFrame(merged_df, geometry='geometry') + geo_merged_df.to_file(output_path, driver='GeoJSON') + elif extension == '.csv': + # For CSV, we drop the geometry column if it exists + if 'geometry' in merged_df.columns: + # Save the WKT representation of geometry + merged_df['geometry_wkt'] = merged_df['geometry'].apply(lambda geom: geom.wkt if geom else None) + merged_df = merged_df.drop(columns='geometry') + merged_df.to_csv(output_path, index=False) + else: + logger.warning(f"Unrecognized output format: {extension}, using CSV format") + merged_df.to_csv(output_path, index=False) + + logger.info("Mapping complete") + return merged_df + + +def main(): + """Main execution function with hardcoded paths.""" + area = "seattle" + study_area_config = get_area_config(area) + study_area_config["graph_layers"]["residential"]["min_density_per_km2"] = 412 + + network_name = generate_network_name(study_area_config) + work_dir = study_area_config["work_dir"] + network_dir = f'{work_dir}/network/{network_name}' + + # Input/output paths + isrm_grid_path = os.path.expanduser(f"{work_dir}/inmap/ISRM/isrm_polygon.shp") + osm_geojson_path = os.path.expanduser(f"{network_dir}/{network_name}.osm.geojson") + osm_gpkg_path = os.path.expanduser(f"{network_dir}/{network_name}.gpkg") + isrm_osm_dir = os.path.expanduser(f"{work_dir}/inmap/isrm-{network_name}") + os.makedirs(isrm_osm_dir, exist_ok=True) + isrm_osm_geojson_path = os.path.expanduser(f"{isrm_osm_dir}/isrm-{network_name}.geojson") + beam_network = os.path.expanduser(f"{network_dir}/network.csv.gz") + output2_path = os.path.expanduser(f"{isrm_osm_dir}/isrm-beam--network-intersection.geojson") + + if not os.path.exists(isrm_osm_geojson_path): + # Process the intersection + process_isrm_osm_intersection( + isrm_grid_path=isrm_grid_path, + osm_geojson_path=osm_geojson_path, + osm_gpkg_path=osm_gpkg_path, + epsg_utm=study_area_config["utm_epsg"], + output_path=isrm_osm_geojson_path + ) + + # Map BEAM Network with isrm osm intersection + map_beam_network_to_isrm_osm_intersection( + beam_network, + isrm_osm_geojson_path, + output2_path + ) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/main/python/network_validation/run_beam_network_validation_against_npmrds.py b/src/main/python/network_validation/run_beam_network_validation_against_npmrds.py index c459082118c..1d0065bbb2f 100644 --- a/src/main/python/network_validation/run_beam_network_validation_against_npmrds.py +++ b/src/main/python/network_validation/run_beam_network_validation_against_npmrds.py @@ -1,16 +1,46 @@ -import seaborn as sns -from pathlib import Path from validation_utils import * +from pathlib import Path +import sys + +# Get the absolute path to the directory containing this script +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(os.path.dirname(current_dir)) +sys.path.insert(0, parent_dir) + +from python.utils.study_area_config import get_area_config +from python.utils.study_area_config import generate_network_name -work_dir = os.path.expanduser("~/Workspace/Simulation") # beam run i.e. link stats and events file # study_area = "seattle" study_area = "sfbay" +batch = "calibration" +scenario = "2018-Baseline-20250702-FC05-0" +run_link_speed_validation = True +run_network_speed_validation = True +run_vmt_validation = False + + +config = get_area_config(study_area) +config["network"]["graph_layers"]["residential"]["min_density_per_km2"] = 5500 +study_area_dir = config["work_dir"] +network_name = generate_network_name(config) +network_dir = f'{config["work_dir"]}/network/{network_name}' +run_dir = f"{config["work_dir"]}/beam-runs/{batch}/{scenario}" + +# run_dir = os.path.expanduser("~/Workspace/Simulation/seattle/beam/runs/2024-04-20/Baseline") +batch_label = batch.replace("-", "") +scenario_label = scenario.replace("_", "-") +link_stats = [ + LinkStats(scenario=f"{batch}_{scenario_label}", demand_fraction=0.1, + file_path=os.path.join(run_dir, "3.linkstats.csv.gz")) +] +vehicle_types_files = [( + batch_label, + scenario_label, + study_area_dir + f"/beam-runs/{batch}/{scenario}/0.events.csv.gz", + study_area_dir + f"/beam-freight/{batch}/{scenario}/vehicle-tech/ft-vehicletypes--{batch_label}--{scenario_label}.csv" +)] -study_area_dir = work_dir + "/" + study_area - -# beam_network_mapped_to_npmrds_geo = study_area_dir + '/validation/beam/' + study_area + '_unclassified_simplified_network_mapped_to_npmrds.geojson' -beam_network_mapped_to_npmrds_geo = study_area_dir + '/validation/beam/' + study_area + '_residential_simpl_network_mapped_to_npmrds.geojson' # validation data @@ -18,72 +48,50 @@ # npmrds_data_csv = study_area_dir + '/validation/npmrds/seattle_npmrds_data.csv' # npmrds_hourly_speed_csv = study_area_dir + '/validation/npmrds/seattle_npmrds_hourly_speeds.csv' # npmrds_hourly_speed_by_road_class_csv = study_area_dir + '/validation/npmrds/' + study_area + '_npmrds_hourly_speed_by_road_class.csv' -npmrds_station_geo = study_area_dir + '/validation/npmrds/' + study_area + '_npmrds_station.geojson' -npmrds_data_csv = study_area_dir + '/validation/npmrds/' + study_area + '_npmrds_data.csv' -npmrds_hourly_speed_csv = study_area_dir + '/validation/npmrds/' + study_area + '_npmrds_hourly_speeds.csv' -npmrds_hourly_speed_by_road_class_csv = study_area_dir + '/validation/npmrds/' + study_area + '_npmrds_hourly_speed_by_road_class.csv' - - # ########## Initialize -setup = SpeedValidationSetup(npmrds_hourly_speed_csv=npmrds_hourly_speed_csv, - npmrds_hourly_speed_by_road_class_csv=npmrds_hourly_speed_by_road_class_csv, - beam_network_mapped_to_npmrds_geo=beam_network_mapped_to_npmrds_geo) - - -run_link_speed_validation = False -run_network_speed_validation = False +setup = SpeedValidationSetup(npmrds_hourly_speed_csv=f"{run_dir}/{study_area}_npmrds_hourly_speeds.csv", + npmrds_hourly_speed_by_road_class_csv=f"{run_dir}/{study_area}_npmrds_hourly_speed_by_road_class.csv", + beam_network_mapped_to_npmrds_geo=f"{run_dir}/{study_area}_network_mapped_to_npmrds.geojson") -if run_link_speed_validation or run_network_speed_validation: +if run_link_speed_validation or run_network_speed_validation or run_vmt_validation: # The rest is automatically generated - # run_dir = os.path.expanduser("~/Workspace/Simulation/seattle/beam/runs/2024-04-20/Baseline") - run_dir = study_area_dir + "/beam-runs/calibration-jdeqsim/sfbay-calib--rs-101010-netset5__2024-07-09_04-48-50_tww" output_dir = run_dir + '/validation_output' plots_dir = output_dir + '/plots' Path(output_dir).mkdir(parents=True, exist_ok=True) Path(plots_dir).mkdir(parents=True, exist_ok=True) - link_stats = [ - LinkStats(scenario="BEAM_netset1", demand_fraction=0.1, file_path=run_dir + "/12.linkstats.csv.gz") - ] # link_stats = [LinkStats(scenario="BEAM", demand_fraction=0.3, file_path=run_dir + "/0.linkstats.csv.gz")] print("Run: " + str(link_stats)) processed_link_stats = setup.process_these_link_stats(link_stats=link_stats, assume_daylight_saving=True) else: processed_link_stats = None + output_dir = '' + plots_dir = '' # ######################################### # ########## Network-level speed validation # ######################################### if run_network_speed_validation: - hourly_speed = setup.get_hourly_average_speed(processed_link_stats) - - # Plot hourly network speed - plt.figure() - sns.lineplot(x='hour', y='speed', hue='scenario', data=hourly_speed, errorbar=('ci', 95)) - plt.ylim([0, 70]) - plt.title("Network-level Speed Validation") - plt.savefig(plots_dir + '/' + study_area + '_beam_npmrds_network_speed_validation.png', dpi=200) - plt.show(block=False) - hourly_speed_by_road_class = setup.get_hourly_average_speed_by_road_class(processed_link_stats) + hourly_speed_by_road_class_no_npmrds = hourly_speed_by_road_class[~hourly_speed_by_road_class['scenario'].str.contains("npmrds", case=False, na=False)] # plot hourly network speed by road class plt.figure() g = sns.relplot(x='hour', y='speed', hue='road_class', col='scenario', kind="line", - data=hourly_speed_by_road_class, + data=hourly_speed_by_road_class_no_npmrds, errorbar=('ci', 95), facet_kws={'sharey': True, 'sharex': True}) g.set_titles("{col_name}") g.fig.suptitle('Network-level Speed Validation by Road Class', fontsize=16, y=0.98) g.set_xlabels("Hour") g.set_ylabels("Speed (mph)") - g._legend.set_title("Road Category") + g.legend.set_title("Road Category") plt.subplots_adjust(top=0.85) plt.ylim([0, 70]) plt.savefig(plots_dir + '/' + study_area + '_beam_npmrds_network_speed_road_class_validation.png', dpi=200) plt.show(block=False) - hourly_speed_by_road_class.to_csv(output_dir + '/' + study_area + '_beam_npmrds_network_speed_road_class_validation.csv', index=False) - + hourly_speed_by_road_class_no_npmrds.to_csv( + output_dir + '/' + study_area + '_beam_npmrds_network_speed_road_class_validation.csv', index=False) # ###################################### # ########## Link-level speed validation # ###################################### @@ -110,17 +118,49 @@ g.fig.suptitle('Link-Level Speed Validation by Road Class', fontsize=16, y=0.98) g.set_xlabels("Hour") g.set_ylabels("Speed (mph)") - g._legend.set_title("Road Category") + g.legend.set_title("Road Category") plt.subplots_adjust(top=0.85) plt.ylim([0, 70]) plt.savefig(plots_dir + '/' + study_area + '_beam_npmrds_link_speed_road_class_validation.png', dpi=200) plt.show(block=False) - hourly_link_speed_by_road_class.to_csv(output_dir + '/' + study_area + '_beam_npmrds_link_speed_road_class_validation.csv', index=False) - + hourly_link_speed_by_road_class.to_csv( + output_dir + '/' + study_area + '_beam_npmrds_link_speed_road_class_validation.csv', index=False) # Plot average link speed by link # average_link_speed = setup.get_average_link_speed() # average_link_speed.to_csv(output_dir + '/' + study_area + '_average_link_speed.csv', index=False) + +# if run_vmt_validation: +# pts = pd.DataFrame() +# # Read vehicle types +# for (batch, scenario, events_file, veh_types_file) in vehicle_types_files: +# # Read and process freight events +# run = read_events( +# events_file, +# veh_types_file, +# batch, +# scenario +# ) +# pt = get_ft_path_traversals(run) +# pts = pd.concat([pts, pt]) +# +# # Process baseline data +# baseline_summary, baseline_summary_levels, baseline_summary_colors = process_ft_path_traversals(baseline_runs, +# baseline_runs_name, +# baseline_output_dir) +# +# # Validate VMT +# validation = validate_vmt(baseline_summary, WORK_DIR) +# +# # Create plots +# plot_results( +# baseline_summary, +# validation, +# baseline_summary_colors, +# baseline_output_dir, +# "2024-08-07" +# ) + print("END") diff --git a/src/main/python/network_validation/validation_utils.py b/src/main/python/network_validation/validation_utils.py index 42ffa479c61..8117c092a87 100644 --- a/src/main/python/network_validation/validation_utils.py +++ b/src/main/python/network_validation/validation_utils.py @@ -1,11 +1,18 @@ +import json +import os import time +import zipfile +from urllib.request import urlretrieve +import contextily as ctx import geopandas as gpd import matplotlib.pyplot as plt import numpy as np +import osmnx as ox import pandas as pd import pyarrow.csv as pv -import os +import requests +import seaborn as sns plt.style.use('ggplot') meter_to_mile = 0.000621371 @@ -20,20 +27,18 @@ 7.0: 'Local'} roadclass_to_fsystem_lookup = {value: key for key, value in fsystem_to_roadclass_lookup.items()} beam_to_roadclass_lookup = {'motorway': fsystem_to_roadclass_lookup[1.0], - 'motorway_link': fsystem_to_roadclass_lookup[2.0], + 'motorway_link': fsystem_to_roadclass_lookup[2.0], # Links connect to lower classes 'trunk': fsystem_to_roadclass_lookup[2.0], - 'trunk_link': fsystem_to_roadclass_lookup[2.0], + 'trunk_link': fsystem_to_roadclass_lookup[3.0], # One class down 'primary': fsystem_to_roadclass_lookup[3.0], - 'primary_link': fsystem_to_roadclass_lookup[4.0], + 'primary_link': fsystem_to_roadclass_lookup[4.0], # One class down 'secondary': fsystem_to_roadclass_lookup[4.0], - 'secondary_link': fsystem_to_roadclass_lookup[5.0], + 'secondary_link': fsystem_to_roadclass_lookup[5.0], # One class down 'tertiary': fsystem_to_roadclass_lookup[5.0], - 'tertiary_link': fsystem_to_roadclass_lookup[6.0], + 'tertiary_link': fsystem_to_roadclass_lookup[6.0], # One class down 'unclassified': fsystem_to_roadclass_lookup[6.0], - 'residential': fsystem_to_roadclass_lookup[7.0], - 'living_street': fsystem_to_roadclass_lookup[7.0], - 'road': fsystem_to_roadclass_lookup[7.0], - np.nan: fsystem_to_roadclass_lookup[7.0]} + 'residential': fsystem_to_roadclass_lookup[7.0] + } state_fips_to_code = { '01': 'AL', '02': 'AK', '04': 'AZ', '05': 'AR', '06': 'CA', '08': 'CO', '09': 'CT', '10': 'DE', '11': 'DC', '12': 'FL', @@ -91,7 +96,6 @@ def agg_npmrds_to_hourly_speed(npmrds_data, observed_speed_weight): def process_and_extend_link_stats(model_network, link_stats, assume_daylight_savings): - dfs = [] for link_stat in link_stats: df = pv.read_csv(link_stat.file_path).to_pandas() @@ -199,7 +203,8 @@ def process_regional_npmrds_station(region_boundary, npmrds_geo_file, npmrds_sce print(">> Select TMC within region boundaries") regional_npmrds_station_out = gpd.overlay(npmrds_station_proj, region_boundary, how='intersection') regional_npmrds_station_out['scenario'] = npmrds_scenario_label - regional_npmrds_station_out.loc[:, 'road_class'] = regional_npmrds_station_out.loc[:, 'F_System'].map(fsystem_to_roadclass_lookup) + regional_npmrds_station_out.loc[:, 'road_class'] = regional_npmrds_station_out.loc[:, 'F_System'].map( + fsystem_to_roadclass_lookup) regional_npmrds_station_out.rename(columns={'Tmc': 'tmc'}, inplace=True) return regional_npmrds_station_out @@ -261,127 +266,238 @@ def run_hourly_speed_mapping_by_road_class(npmrds_hourly_link_speed, link_stats) return pd.concat([beam_hourly_speed, npmrds_hourly_speed], axis=0) -def download_taz_shapefile(state_fips_code, year, output_dir): - import requests +def download_nhts_data(nhts_output_file, area_name, state_fips_code=None, + cbsa_codes=None, year=2017, download=True, extract=True, process=True): """ - Download TAZ shapefiles for a given state-level FIPS code. + Download, extract, and process NHTS data with filtering by state FIPS code + and/or CBSA codes. + Stores filtered data under directory with area name: data_nhts_dir/area_name/ Parameters: - - fips_code: String or integer representing the state-level FIPS code. - - output_dir: Directory to save the downloaded ZIP file. + - nhts_output_file: Path to save the downloaded NHTS zip file + - area_name: Name of the area for organizing filtered data + - state_fips_code: String representing the state FIPS code (e.g., '06' for California) + - cbsa_codes: List of CBSA codes (e.g., [41860] for San Francisco-Oakland-Hayward, CA) + - year: NHTS survey year (default: 2017) + - download: Boolean to control if download should occur + - extract: Boolean to control if extraction should occur + - process: Boolean to control if processing should occur + + Returns: + - Dictionary of filtered DataFrames """ - # Ensure the FIPS code is a string, padded to 2 characters - fips_code_str = str(state_fips_code).zfill(2) - - # Construct the download URL - base_url = f"https://www2.census.gov/geo/tiger/TIGER2010/TAZ/2010/" - filename = f"tl_{year}_{fips_code_str}_taz10.zip" - download_url = base_url + filename - - # Make the output directory if it doesn't exist - if not os.path.exists(output_dir): - os.makedirs(output_dir) - - # Full path for saving the file - output_path = os.path.join(output_dir, filename) - - # Start the download - print(f"Downloading TAZ shapefile for FIPS code {state_fips_code} from {download_url}") - try: - response = requests.get(download_url) - response.raise_for_status() # This will check for errors - - # Write the content of the response to a ZIP file - with open(output_path, 'wb') as file: - file.write(response.content) - - print(f"File saved to {output_path}") - - except requests.RequestException as e: - print(f"Error downloading the file: {e}") - - return output_path - - -def collect_taz_boundaries(state_fips_code, year, output_dir): - from zipfile import ZipFile - state_geo_zip = output_dir + f"/tl_{year}_{state_fips_code}_taz10.zip" - if not os.path.exists(state_geo_zip): - state_geo_zip = download_taz_shapefile(state_fips_code, year, output_dir) - """ - Read a shapefile from a ZIP archive, filter geometries by county FIPS codes, - and write the result to a GeoJSON file. - - Parameters: - - zip_file_path: Path to the ZIP file containing the shapefile. - - county_fips_codes: List of county FIPS codes to filter by. - - output_geojson_path: Path to save the filtered data as a GeoJSON file. - """ - # Extract the shapefile from the ZIP archive - with ZipFile(state_geo_zip, 'r') as zip_ref: - # Extract all files to a temporary directory - temp_dir = "temp_shp" - zip_ref.extractall(temp_dir) - - # Find the .shp file in the extracted files - shapefile_name = [f for f in os.listdir(temp_dir) if f.endswith('.shp')][0] - shapefile_path = os.path.join(temp_dir, shapefile_name) - - # Read the shapefile into a GeoDataFrame - gdf = gpd.read_file(shapefile_path) - - # Clean up the temporary directory - for filename in os.listdir(temp_dir): - os.remove(os.path.join(temp_dir, filename)) - os.rmdir(temp_dir) - - return gdf - - -def collect_geographic_boundaries(state_fips_code, county_fips_codes, year, study_area_geo_path, projected_coordinate_system, geo_level): - from pygris import counties, block_groups - - if geo_level == 'county': - # Define fips code for selected counties - geo_data = counties(state=state_fips_code, year=year, cb=True, cache=True) - elif geo_level == 'cbg': - # Define fips code for selected counties - geo_data = block_groups(state=state_fips_code, year=year, cb=True, cache=True) - elif geo_level == 'taz': - geo_data = collect_taz_boundaries(state_fips_code, year, os.path.dirname(study_area_geo_path)) + # Set URL based on year + if year >= 2016: + url = "https://nhts.ornl.gov/assets/2016/download/csv.zip" else: - raise ValueError("Unsupported geographic level. Choose 'counties' or 'cbgs'.") - - countyfp_columns = [col for col in geo_data.columns if col.startswith('COUNTYFP')] - mask = geo_data[countyfp_columns].apply(lambda x: x.isin(county_fips_codes)).any(axis=1) - selected_geo = geo_data[mask] - - # def string_to_double(s): - # return float(s if s != "" else "0") - # - # # Prepare columns and mask - # aland_columns = [col for col in selected_geo.columns if col.startswith('ALAND')] - # awater_columns = [col for col in selected_geo.columns if col.startswith('AWATER')] - # for col in aland_columns + awater_columns: - # selected_geo.loc[:, col] = selected_geo[col].apply(string_to_double) - # mask = pd.Series([False] * len(selected_geo), index=selected_geo.index) - # - # for aland_col, awater_col in zip(aland_columns, awater_columns): - # # AWATER should not be more than three times ALAND - # mask |= (selected_geo[aland_col] > 0) & (selected_geo[awater_col] < 3 * selected_geo[aland_col]) - # - # # Apply the mask to filter selected_geo - # selected_geo = selected_geo[mask] - - base_name, extension = os.path.splitext(study_area_geo_path) - - study_area_geo_projected_path = base_name+"_epsg"+str(projected_coordinate_system)+extension - selected_geo.to_crs(epsg=projected_coordinate_system).to_file(study_area_geo_projected_path, driver="GeoJSON") - - selected_geo_wgs84 = selected_geo.to_crs(epsg=4326) - selected_geo_wgs84.to_file(base_name+"_wgs84"+extension, driver="GeoJSON") - return selected_geo_wgs84 - + print(f"Error: NHTS data for year {year} is not supported.") + return None + + data_nhts_dir = os.path.dirname(nhts_output_file) + + # Create area-specific directory + area_dir = os.path.join(data_nhts_dir, area_name) + os.makedirs(area_dir, exist_ok=True) + print(f"Created directory for area: {area_dir}") + + # Create a filter description for file naming + filter_desc = "" + if state_fips_code: + filter_desc += f"fips_{state_fips_code}" + if cbsa_codes: + filter_desc += f"_cbsa_{'_'.join(map(str, cbsa_codes))}" + + # Save filter information to a JSON file for reference + filter_info = { + "area_name": area_name, + "state_fips_code": state_fips_code, + "cbsa_codes": cbsa_codes, + "year": year, + "timestamp": time.strftime("%Y-%m-%d %H:%M:%S") + } + + with open(os.path.join(area_dir, "filter_info.json"), "w") as f: + json.dump(filter_info, f, indent=2) + + # Check if the file already exists + if os.path.exists(nhts_output_file): + file_size = os.path.getsize(nhts_output_file) / (1024 * 1024) # Size in MB + print(f"File {nhts_output_file} already exists ({file_size:.1f} MB). Skipping download.") + else: + print(f"Downloading NHTS {year} data...") + # Download the file with progress reporting + response = requests.get(url, stream=True) + if response.status_code == 200: + total_size = int(response.headers.get('content-length', 0)) + downloaded = 0 + start_time = time.time() + + with open(nhts_output_file, "wb") as file: + for chunk in response.iter_content(chunk_size=1024 * 1024): # 1MB chunks + if chunk: + file.write(chunk) + downloaded += len(chunk) + + # Calculate and display progress + percent = int(100 * downloaded / total_size) if total_size > 0 else 0 + elapsed = time.time() - start_time + rate = downloaded / (1024 * 1024 * elapsed) if elapsed > 0 else 0 + + print( + f"\rDownloading: {percent}% ({downloaded / (1024 * 1024):.1f}MB of {total_size / (1024 * 1024):.1f}MB) at {rate:.1f} MB/s", + end="") + + print(f"\nDownloaded {nhts_output_file}") + else: + print(f"Failed to download. Status code: {response.status_code}") + print(f"Response: {response.text[:500]}...") + return None + + # Create a temporary directory for extraction + temp_extract_dir = os.path.join(data_nhts_dir, "temp_extract") + os.makedirs(temp_extract_dir, exist_ok=True) + + # Check if data has already been extracted to temp directory + extracted_files_exist = os.path.exists(f"{temp_extract_dir}/hhpub.csv") or os.path.exists( + f"{temp_extract_dir}/trippub.csv") + + if not extracted_files_exist and extract: + # Extract the downloaded ZIP file to temp directory + print("\nExtracting files to temporary directory...") + try: + with zipfile.ZipFile(nhts_output_file, "r") as zip_ref: + zip_ref.extractall(temp_extract_dir) + print("Files extracted successfully") + except zipfile.BadZipFile: + print("Error: The downloaded file is not a valid ZIP file.") + print("The file may be corrupted. Please try downloading again.") + return None + except Exception as e: + print(f"Error extracting files: {str(e)}") + return None + elif extract: + extract_again = input("Data files already exist in temp directory. Extract again? (y/n): ").lower() == 'y' + if extract_again: + print("\nExtracting files to temporary directory...") + try: + with zipfile.ZipFile(nhts_output_file, "r") as zip_ref: + zip_ref.extractall(temp_extract_dir) + print("Files extracted successfully") + except Exception as e: + print(f"Error extracting files: {str(e)}") + return None + else: + print("Skipping extraction.") + else: + print("Skipping extraction.") + + # List the extracted files + files = os.listdir(temp_extract_dir) + print(f"\nFiles in temporary extraction directory: {len(files)} files") + + # Process key datasets with focus on filtered areas + datasets = { + "Households": "hhpub.csv", + "Persons": "perpub.csv", + "Trips": "trippub.csv", + "Vehicles": "vehpub.csv" + } + + filtered_dfs = {} + + if not process: + print("Skipping data processing as requested.") + return None + + for dataset_name, filename in datasets.items(): + # Define output path in the area-specific directory + area_output_file = os.path.join(area_dir, filename) + + # Check if filtered file already exists in area directory + if os.path.exists(area_output_file): + process_this = input( + f"Filtered {dataset_name} data already exists in {area_name} directory. Process again? (y/n): ").lower() == 'y' + if not process_this: + filtered_dfs[dataset_name] = pd.read_csv(area_output_file) + print(f"Loaded existing filtered {dataset_name} data from {area_name} directory.") + continue + + if filename in files: + print(f"\nProcessing {dataset_name} dataset...") + file_path = os.path.join(temp_extract_dir, filename) + + # Load the CSV file + df = pd.read_csv(file_path) + print(f"Total records: {len(df)}") + + # Apply filters + filtered_df = df.copy() + + # Find columns for filtering + # 1. Find any column containing the word "FIPS" for state FIPS + state_fips_column = None + state_fips_columns = [col for col in df.columns if 'STFIPS' in col or ('FIPS' in col and 'ST' in col)] + + if state_fips_columns: + state_fips_column = state_fips_columns[0] + print(f"Found state FIPS column: {state_fips_column}") + + # 2. Find any column containing CBSA + cbsa_column = None + cbsa_columns = [col for col in df.columns if 'CBSA' in col] + + if cbsa_columns: + cbsa_column = cbsa_columns[0] + print(f"Found CBSA column: {cbsa_column}") + + # Apply filtering based on available columns and parameters + filter_applied = False + + # 1. Filter by CBSA if provided and column exists + if cbsa_codes and cbsa_column and cbsa_column in df.columns: + filtered_df = filtered_df[filtered_df[cbsa_column].isin(cbsa_codes)] + print(f"Records after CBSA filter: {len(filtered_df)}") + filter_applied = True + + # 2. Filter by state FIPS if provided and column exists + if state_fips_code and state_fips_column and state_fips_column in df.columns: + # Convert to integer for comparison if the column is numeric + if pd.api.types.is_numeric_dtype(filtered_df[state_fips_column]): + filtered_df = filtered_df[filtered_df[state_fips_column] == int(state_fips_code)] + else: + # Otherwise treat as string + filtered_df[state_fips_column] = filtered_df[state_fips_column].astype(str) + filtered_df = filtered_df[filtered_df[state_fips_column] == state_fips_code] + print(f"Records after state FIPS filter: {len(filtered_df)}") + filter_applied = True + + if not filter_applied: + print("Warning: No filters applied. No matching columns found for the provided filter criteria.") + print(f"Available columns: {', '.join(df.columns[:10])}...") + + # Save filtered data to area-specific directory + filtered_df.to_csv(area_output_file, index=False) + print(f"Filtered data saved to {area_output_file}") + + # Store in dictionary + filtered_dfs[dataset_name] = filtered_df + + # Display sample data + print("\nSample data (first 3 rows):") + print(filtered_df.head(3)) + + # Display column information + print(f"\nNumber of columns: {len(filtered_df.columns)}") + print(f"Sample columns: {filtered_df.columns[:5].tolist()}") + else: + print(f"\nWarning: {filename} not found in extracted files") + + # Optionally clean up temporary extraction directory + print("Cleaning up temporary extraction directory") + import shutil + shutil.rmtree(temp_extract_dir) + print(f"Removed temporary directory: {temp_extract_dir}") + return filtered_dfs def map_cbg_to_taz(cbg_gdf, cbg_id_col, taz_gdf, taz_id_col, projected_coordinate_system, cbg_taz_map_csv): print(f"Mapping CBG to TAZ geometries") @@ -429,7 +545,6 @@ def prepare_npmrds_data( # output npmrds_station_geo, npmrds_data_csv, npmrds_hourly_speed_csv, npmrds_hourly_speed_by_road_class_csv, beam_network_car_links_geo, beam_npmrds_network_map_geo): - if os.path.exists(npmrds_station_geo): print(f"Reading {npmrds_station_geo}") regional_npmrds_station = gpd.read_file(npmrds_station_geo) @@ -443,7 +558,8 @@ def prepare_npmrds_data( regional_npmrds_data = pv.read_csv(npmrds_data_csv).to_pandas() else: print("Process NPMRDS data") - regional_npmrds_data = process_regional_npmrds_data(npmrds_raw_data_csv, npmrds_label, regional_npmrds_station['tmc'].unique()) + regional_npmrds_data = process_regional_npmrds_data(npmrds_raw_data_csv, npmrds_label, + regional_npmrds_station['tmc'].unique()) regional_npmrds_data.to_csv(npmrds_data_csv, index=False) if os.path.exists(npmrds_hourly_speed_csv): @@ -496,7 +612,8 @@ def __repr__(self): class SpeedValidationSetup: - def __init__(self, npmrds_hourly_speed_csv, npmrds_hourly_speed_by_road_class_csv, beam_network_mapped_to_npmrds_geo): + def __init__(self, npmrds_hourly_speed_csv, npmrds_hourly_speed_by_road_class_csv, + beam_network_mapped_to_npmrds_geo): st = time.time() print("Loading data ...") self.npmrds_hourly_speed = pv.read_csv(npmrds_hourly_speed_csv).to_pandas() @@ -654,5 +771,306 @@ def save_filtered_data(df, filename): save_filtered_data(speed_param, "min_speed_all_roads") +def plot(G, name): + fig, ax = ox.plot.plot_graph( + G, + bgcolor="#FFFFFF", # Light background + # node_color="#00FFAA", # Bright teal nodes + node_color="#333333", # Bright teal nodes + node_size=0.02, + node_edgecolor='none', # Node size 2.5 + # node_alpha=0.8, # Node transparency + # node_edgecolor="#333333", # Dark edges around nodes + node_zorder=3, # Nodes above edges + edge_color="#FF5A5F", # Bright coral edges + edge_linewidth=0.2, # Edge thickness 0.5 + edge_alpha=0.8, # Edge transparency + show=False, # Do not display immediately + close=False # Keep the plot open for saving + ) + + ctx.add_basemap(ax, source=ctx.providers.CartoDB.Positron, zoom=20) + + # 3. Calculate statistics + num_nodes = len(G.nodes) + num_edges = len(G.edges) + # Total length in meters + total_length = sum(data.get('length', 0) for u, v, key, data in G.edges(keys=True, data=True)) + + # 4. Add title with statistics + title = ( + f"Nodes: {num_nodes} | Edges: {num_edges} | Total Length: {total_length / 1000:.2f} km" + ) + ax.set_title(title, fontsize=15, fontweight='bold', color='black', pad=20) + + # 5. Save the figure with 600 DPI + fig.savefig(f'{name}', dpi=600, bbox_inches='tight') + + +def download_h5_data(url: str, output_path: str) -> str: + """ + Download H5 data file if it doesn't exist locally and explore its structure. + + Parameters: + ----------- + url : str + URL to download the H5 file from + output_path : str + Local path to save the downloaded file + + Returns: + -------- + str + Path to the H5 file + """ + import h5py + # Check if file exists locally first + if not os.path.exists(output_path): + print(f"\nDownloading H5 data from {url}...") + urlretrieve(url, output_path) + print("✓ H5 data downloaded") + else: + print("\nUsing existing H5 data file") + + # Explore H5 file structure + print("\nExploring H5 file structure...") + + def print_structure(name, obj): + """Helper function to print H5 structure""" + if isinstance(obj, h5py.Dataset): + try: + shape = obj.shape + dtype = obj.dtype + print(f"Dataset: {name}") + print(f" Shape: {shape}") + print(f" Type: {dtype}") + + # Print first few items for small datasets or sample for large ones + if len(obj.shape) > 0: + if obj.shape[0] > 0: + sample_size = min(3, obj.shape[0]) + print(" Sample data:") + print(obj[:sample_size]) + except Exception as e: + print(f" Error reading dataset: {e}") + else: + print(f"Group: {name}") + + with h5py.File(output_path, 'r') as f: + print("\nFile structure:") + print("==============") + f.visititems(print_structure) + + # List all root level groups/datasets + print("\nRoot level items:") + for key in f.keys(): + print(f"- {key}") + return output_path + +#################################################################################################### +#################################################################################################### +########################################## VMT Validation ########################################## +#################################################################################################### +#################################################################################################### + +def read_events(event_file, veh_types_file, batch, scenario): + events = pd.read_csv(event_file) + events['batch'] = batch + events['scenario'] = scenario + # Merge with vehicle types + veh_types = pd.read_csv(veh_types_file) + events_veh_types = events.merge( + veh_types[['vehicleTypeId', 'vehicleCategory', 'primaryFuelType', 'secondaryFuelType']], + left_on='vehicleType', + right_on='vehicleTypeId' + ) + return events_veh_types + + +def get_ft_path_traversals(_events): + columns = ['time', 'type', 'vehicleType', 'vehicle', 'secondaryFuelLevel', + 'primaryFuelLevel', 'driver', 'mode', 'seatingCapacity', 'startX', + 'startY', 'endX', 'endY', 'capacity', 'arrivalTime', 'departureTime', + 'secondaryFuel', 'secondaryFuelType', 'primaryFuelType', + 'numPassengers', 'length', 'primaryFuel', 'runName', 'runLabel'] + + # Filter path traversals + pt = _events[_events['type'] == 'PathTraversal'].copy() + pt = pt[pt['vehicle'].str.startswith('freight', na=False)] + pt = pt[columns] + + if pt[pt['vehicle'].str.contains('-emergency-', na=False)].shape[0] > 0: + print("This is a bug") + + # Set energy type and codes + pt.loc[pt['vehicleType'].str.contains('E-PHEV', case=False, na=False), 'energyType'] = 'Electric' + pt.loc[pt['vehicleType'].str.contains('E-PHEV', case=False, na=False), 'energyTypeCode'] = 'PHEV' + pt.loc[pt['vehicleType'].str.contains('H2FC', case=False, na=False), 'energyType'] = 'Hydrogen' + pt.loc[pt['vehicleType'].str.contains('H2FC', case=False, na=False), 'energyTypeCode'] = 'H2FC' + + # Set vehicle categories + pt['vehicleCategory'] = 'Class 4-6 Vocational' + pt.loc[pt['vehicleType'].str.contains('-hdt-', na=False), 'vehicleCategory'] = 'Class 7&8 Tractor' + pt.loc[pt['vehicleType'].str.contains('-hdv-', na=False), 'vehicleCategory'] = 'Class 7&8 Vocational' + + # Set business type + pt['business'] = 'B2B' + pt.loc[pt['vehicle'].str.startswith('freightVehicle-b2c-', na=False), 'business'] = 'B2C' + + print("PT formatted") + return pt + + +def average_speed_vector(distances, speeds): + """Calculate average speed for vectors of distances and speeds""" + if any(speed == 0 for speed in speeds): + raise ValueError("Speeds must be non-zero.") + + total_distance = sum(distances) + total_time = sum(d / s for d, s in zip(distances, speeds)) + + return total_distance / total_time + + +def process_ft_path_traversals(_runs, _batch, _output_dir, _expansion_factor): + # Calculate summary statistics + runs_summary = _runs[_runs["batch"] == _batch].groupby( + ['energyTypeCode', 'vehicleClass', 'business', 'batch', 'scenario'] + ).agg({ + 'length': lambda x: _expansion_factor * sum(x / 1609.344) / 1e6, # MVMT + 'primaryFuel': lambda x: _expansion_factor * sum(x / 3.6e12) # GWH + }).reset_index() + + runs_summary.columns = ['energyTypeCode', 'vehicleClass', 'business', 'runLabel', 'MVMT', 'GWH'] + + # Create energy and vehicles types column + runs_summary['energyAndVehiclesTypes'] = runs_summary['energyTypeCode'] + ' ' + runs_summary['vehicleClass'] + + # Convert to categorical with specified order + runs_summary['energyAndVehiclesTypes'] = pd.Categorical( + runs_summary['energyAndVehiclesTypes'], + categories=[ + "Diesel Class 4-6 Vocational", + "Diesel Class 7&8 Vocational", + "Diesel Class 7&8 Tractor", + "BEV Class 7&8 Vocational" + ] + ) + + # Save summary to CSV + runs_summary.to_csv( + os.path.join(_output_dir, f"{_batch}_VMT-and-GWH-by-powertrain-class.csv"), + index=False + ) + + plot_results(runs_summary, + validation, + ["azure3", "darkgray", "azure4", "deepskyblue2"], + _output_dir, + _batch) + + return runs_summary + + +def read_vmt_frm_hpms(hpms_geo_file, study_area_geoid): + # Read and process HPMS data + link_aadt = gpd.read_file(hpms_geo_file) + link_aadt = link_aadt[link_aadt['GEOID'].str.startswith(study_area_geoid)] + """Calculate HPMS AADT statistics""" + link_aadt = link_aadt.copy() + link_aadt['Volume_hpms'] = link_aadt['AADT_Combi'] + link_aadt['AADT_Singl'] + link_aadt['VMT_hpms'] = link_aadt['Volume_hpms'] * link_aadt.geometry.length / 1609.0 + + vmt_hpms = link_aadt['VMT_hpms'].sum() + + # Calculate HPMS components + vmt_hpms_international = (vmt_hpms * 0.22) / 1e6 + vmt_hpms_through_traffic = (vmt_hpms * 0.1) / 1e6 + vmt_hpms_national = (vmt_hpms * 0.68) / 1e6 + + # Create validation DataFrame + validation = pd.DataFrame({ + 'label': ['HPMS'] * 3, + 'source': ['National', 'International', 'Through Traffic'], + 'MVMT': [vmt_hpms_national, vmt_hpms_international, vmt_hpms_through_traffic] + }) + + validation['source'] = pd.Categorical( + validation['source'], + categories=['Through Traffic', 'International', 'National'] + ) + + return validation + + +def validate_vmt(baseline_summary, work_dir): + # Read and process HPMS data + link_aadt = gpd.read_file(os.path.join(work_dir, "validation_data/HPMS/WA_HPMS_with_GEOID_LANEMILE.geojson")) + link_aadt = link_aadt[link_aadt['GEOID'].str.startswith(('53061', '53033', '53035', '53053'))] + link_aadt_dt = get_hpms_aadt(link_aadt) + + vmt_hpms = link_aadt_dt['VMT_hpms'].sum() + beam_baseline = baseline_summary[baseline_summary['runLabel'] == "Baseline"]['MVMT'].sum() + + # Calculate HPMS components + vmt_hpms_international = (vmt_hpms * 0.22) / 1e6 + vmt_hpms_through_traffic = (vmt_hpms * 0.1) / 1e6 + vmt_hpms_national = (vmt_hpms * 0.68) / 1e6 + + # Create validation DataFrame + validation = pd.DataFrame({ + 'label': ['FAMOS'] * 3 + ['HPMS'] * 3, + 'source': ['National', 'International', 'Through Traffic'] * 2, + 'MVMT': [beam_baseline, 0.0, 0.0, vmt_hpms_national, vmt_hpms_international, vmt_hpms_through_traffic] + }) + validation['source'] = pd.Categorical( + validation['source'], + categories=['Through Traffic', 'International', 'National'] + ) + + return validation + + +def plot_results(baseline_summary, validation, baseline_summary_colors, baseline_output_dir, baseline_runs_name): + # Plot VMT validation + plt.figure(figsize=(7, 4)) + sns.barplot(data=validation, x='label', y='MVMT', hue='source') + plt.title('Total VMT') + plt.xlabel('Source') + plt.ylabel('Million VMT') + plt.savefig(os.path.join(baseline_output_dir, f"{baseline_runs_name}_vmt_validation.png")) + plt.close() + + # Plot VMT by powertrain class + plt.figure(figsize=(7, 4)) + g = sns.barplot( + data=baseline_summary, + x='runLabel', + y='MVMT', + hue='energyAndVehiclesTypes', + palette=baseline_summary_colors + ) + plt.title('Total Truck Travel - Baseline') + plt.xlabel('Scenario') + plt.ylabel('VMT') + plt.xticks(rotation=0) + plt.savefig(os.path.join(baseline_output_dir, f"{baseline_runs_name}_VMT-by-powertrain-class.png")) + plt.close() + + # Plot Energy consumption + plt.figure(figsize=(7, 4)) + g = sns.barplot( + data=baseline_summary, + x='runLabel', + y='GWH', + hue='energyAndVehiclesTypes', + palette=baseline_summary_colors + ) + plt.title('Energy Consumption - Baseline') + plt.xlabel('Scenario') + plt.ylabel('GWh') + plt.xticks(rotation=0) + plt.savefig(os.path.join(baseline_output_dir, f"{baseline_runs_name}_GWH-by-powertrain-class.png")) + plt.close() diff --git a/src/main/python/utils/__init__.py b/src/main/python/utils/__init__.py new file mode 100644 index 00000000000..3341dca4bad --- /dev/null +++ b/src/main/python/utils/__init__.py @@ -0,0 +1,7 @@ +# python/utils/__init__.py + +# Import and expose the entire helper module +from . import compare_config_files +from . import log_filter_script +from . import study_area_config +from . import files_utils diff --git a/src/main/python/compare_config_files.py b/src/main/python/utils/compare_config_files.py similarity index 100% rename from src/main/python/compare_config_files.py rename to src/main/python/utils/compare_config_files.py diff --git a/src/main/python/utils/csv_data_analyzer.py b/src/main/python/utils/csv_data_analyzer.py new file mode 100644 index 00000000000..1e0450bee43 --- /dev/null +++ b/src/main/python/utils/csv_data_analyzer.py @@ -0,0 +1,262 @@ +import gzip +import sys +from collections import Counter +import pandas as pd + + +def parse_hstore_format(data_string): + """ + Parse fields that contain hstore format data + Format example: "oneway"=>"no","reversed"=>"False","length"=>"72.674",... + """ + if pd.isna(data_string) or not data_string: + return {} + + result = {} + # Handle the standard hstore format + try: + # Split by commas not inside quotes + parts = [] + in_quotes = False + current = "" + + for char in data_string: + if char == '"' and (not current or current[-1] != '\\'): + in_quotes = not in_quotes + + if char == ',' and not in_quotes: + parts.append(current) + current = "" + else: + current += char + + # Don't forget the last part + if current: + parts.append(current) + + # Process each part + for part in parts: + if "=>" in part: + key_val = part.split("=>") + if len(key_val) == 2: + key = key_val[0].strip().strip('"') + val = key_val[1].strip().strip('"') + result[key] = val + except Exception as e: + print(f"Error parsing tags: {e}") + if len(data_string) > 100: + print(f"Preview: {data_string[:100]}...") + else: + print(f"String: {data_string}") + + return result + + +def analyze_csv(file_path, sample_size=None): + """ + Analyze a CSV file (possibly gzipped) with OSM data + + Args: + file_path: Path to the CSV or CSV.GZ file + sample_size: Optional number of rows to sample (for large files) + + Returns: + Dictionary of statistics and DataFrame + """ + print(f"Analyzing file: {file_path}") + + # Determine if the file is gzipped + is_gzipped = file_path.endswith('.gz') + + try: + # Read the file (with optional sampling) + if is_gzipped: + if sample_size: + # For very large files, we use chunking + chunks = [] + with gzip.open(file_path, 'rt') as f: + # Read and process in chunks + for chunk in pd.read_csv(f, chunksize=min(100000, sample_size)): + chunks.append(chunk) + if sum(len(c) for c in chunks) >= sample_size: + break + df = pd.concat(chunks) + df = df.head(sample_size) + else: + # Read the entire file + with gzip.open(file_path, 'rt') as f: + df = pd.read_csv(f) + else: + # Regular CSV file + if sample_size: + df = pd.read_csv(file_path, nrows=sample_size) + else: + df = pd.read_csv(file_path) + + print(f"Loaded {len(df)} rows with {len(df.columns)} columns") + + # Get basic column statistics + column_stats = {} + for column in df.columns: + non_null_count = df[column].count() + unique_count = df[column].nunique() + + # Calculate top values + value_counts = df[column].value_counts().head(10).to_dict() + + column_stats[column] = { + 'count': non_null_count, + 'percent_present': round(non_null_count / len(df) * 100, 2), + 'unique_values': unique_count, + 'top_values': value_counts + } + + # Look for and parse hstore-formatted fields + other_tags_stats = {} + if 'other_tags' in df.columns: + print("Found 'other_tags' column, parsing nested data...") + + # Create a new column with parsed data + df['other_tags_parsed'] = df['other_tags'].apply(parse_hstore_format) + + # Extract all unique keys from other_tags + all_keys = set() + for tags_dict in df['other_tags_parsed'].dropna(): + if isinstance(tags_dict, dict): + all_keys.update(tags_dict.keys()) + + # For each key, collect statistics + for key in all_keys: + # Count occurrences and values + counter = Counter() + valid_entries = 0 + + for tags_dict in df['other_tags_parsed'].dropna(): + if isinstance(tags_dict, dict) and key in tags_dict: + counter[tags_dict[key]] += 1 + valid_entries += 1 + + other_tags_stats[key] = { + 'count': valid_entries, + 'percent_present': round(valid_entries / len(df) * 100, 2), + 'unique_values': len(counter), + 'top_values': dict(counter.most_common(10)) + } + + # Sort by frequency + other_tags_stats = {k: v for k, v in sorted( + other_tags_stats.items(), + key=lambda item: item[1]['count'], + reverse=True + )} + + # Create summary statistics + stats = { + 'total_rows': len(df), + 'columns': list(df.columns), + 'column_stats': column_stats, + 'other_tags_stats': other_tags_stats + } + + return stats, df + + except Exception as e: + print(f"Error analyzing CSV file: {e}") + return None, None + + +def print_column_stats(stats, limit=None): + """Print column statistics in a formatted way""" + columns = list(stats['column_stats'].keys()) + + print(f"\n=== Column Statistics ({len(columns)} columns) ===") + + for i, column in enumerate(columns): + if limit and i >= limit: + print(f"\n... and {len(columns) - limit} more columns.") + break + + data = stats['column_stats'][column] + print(f"\n{i + 1}. {column}: {data['count']} non-null values ({data['percent_present']}% filled)") + print(f" Unique values: {data['unique_values']}") + + if data['unique_values'] <= 20: # Only show all values for categorical columns + print(" Values:") + for val, count in data['top_values'].items(): + val_display = str(val) + if len(val_display) > 50: + val_display = val_display[:47] + "..." + print(f" - {val_display}: {count}") + else: + print(" Top values:") + for val, count in data['top_values'].items(): + val_display = str(val) + if len(val_display) > 50: + val_display = val_display[:47] + "..." + print(f" - {val_display}: {count}") + + +def print_nested_field_stats(stats, limit=None): + """Print statistics for keys inside hstore-formatted fields""" + if not stats.get('other_tags_stats'): + print("\n=== No hstore-formatted fields found ===") + return + + nested_keys = list(stats['other_tags_stats'].keys()) + + print(f"\n=== Nested Field Analysis ({len(nested_keys)} unique keys) ===") + + for i, key in enumerate(nested_keys): + if limit and i >= limit: + print(f"\n... and {len(nested_keys) - limit} more keys.") + break + + data = stats['other_tags_stats'][key] + print(f"\n{i + 1}. {key}: {data['count']} occurrences ({data['percent_present']}% of rows)") + print(f" Unique values: {data['unique_values']}") + + print(" Top values:") + for val, count in data['top_values'].items(): + val_display = str(val) + if len(val_display) > 50: + val_display = val_display[:47] + "..." + print(f" - {val_display}: {count}") + + +def main(file_path, sample_size=None): + """Main function to analyze a CSV file""" + # Parse sample size if provided + if sample_size and sample_size.isdigit(): + sample_size = int(sample_size) + else: + sample_size = None + + # Analyze the file + stats, df = analyze_csv(file_path, sample_size) + + if not stats: + print("Analysis failed.") + return + + print(f"\n=== CSV Analysis Summary ===") + print(f"Total rows: {stats['total_rows']}") + print(f"Total columns: {len(stats['columns'])}") + + # Print column statistics + print_column_stats(stats, limit=20) + + # Print nested field statistics + print_nested_field_stats(stats, limit=20) + + return stats, df + + +if __name__ == "__main__": + if len(sys.argv) < 2: + print("Usage: python3 csv_data_analyzer.py [sample_size]") + sys.exit(1) + + file_path = sys.argv[1] + sample_size = sys.argv[2] if len(sys.argv) > 2 else None + + main(file_path, sample_size) \ No newline at end of file diff --git a/src/main/python/utils/files_utils.py b/src/main/python/utils/files_utils.py new file mode 100644 index 00000000000..9683e9e77df --- /dev/null +++ b/src/main/python/utils/files_utils.py @@ -0,0 +1,91 @@ +import gzip +import io +import os + +from tqdm import tqdm +from tqdm.auto import tqdm +import pandas as pd +import re + +def combine_csv_files(input_files, output_file): + # Read and combine CSV files vertically + combined_df = pd.concat([pd.read_csv(f) for f in input_files], ignore_index=True) + + # Write the combined dataframe to a new CSV file + combined_df.to_csv(output_file, index=False) + + print(f"Combined CSV file has been created: {output_file}") + return combined_df # Return the dataframe for further processing if needed + +def fast_df_to_gzip(df, output_file, compression_level=5, chunksize=100000): + """ + Write a pandas DataFrame to a compressed CSV.gz file quickly with a progress bar. + + :param df: pandas DataFrame to write + :param output_file: path to the output .csv.gz file + :param compression_level: gzip compression level (1-9, 9 being highest) + :param chunksize: number of rows to write at a time + """ + total_rows = len(df) + + with gzip.open(output_file, 'wt', compresslevel=compression_level) as gz_file: + # Write header + gz_file.write(','.join(df.columns) + '\n') + + # Write data in chunks + with tqdm(total=total_rows, desc="Writing to gzip", unit="rows") as pbar: + for start in range(0, total_rows, chunksize): + end = min(start + chunksize, total_rows) + chunk = df.iloc[start:end] + + csv_buffer = io.StringIO() + chunk.to_csv(csv_buffer, index=False, header=False) + gz_file.write(csv_buffer.getvalue()) + + pbar.update(end - start) + + +def sanitize_name(filename): + # Start with the original filename + sanitized = filename + + # Replace other common superscripts if needed + superscript_map = {'¹': '1', '²': '2', '³': '3', '⁴': '4', '⁵': '5', '⁶': '6', '⁷': '7', '⁸': '8', '⁹': '9'} + for sup, normal in superscript_map.items(): + sanitized = sanitized.replace(sup, normal) + + # Replace parentheses with underscores + sanitized = sanitized.replace('(', '_').replace(')', '_') + + # Replace forward slashes and backslashes with dashes + sanitized = sanitized.replace('/', '-').replace('\\', '-') + + # Replace spaces with underscores + sanitized = sanitized.replace(' ', '_') + + # Remove or replace any other non-alphanumeric characters (except dashes and underscores) + sanitized = re.sub(r'[^\w\-_]', '', sanitized) + + # Replace any sequence of dashes or underscores with a single underscore + sanitized = re.sub(r'[_-]+', '_', sanitized) + + # Remove leading and trailing underscores + sanitized = sanitized.strip('_') + + return sanitized + + +def check_files(paths, delete=True): + if isinstance(paths, str): + paths = [paths] + + results = [] + for path in paths: + exists = os.path.isfile(path) + if exists and delete: + os.remove(path) + results.append(False) + else: + results.append(exists and not delete) + + return all(results) \ No newline at end of file diff --git a/src/main/python/utils/log_filter_script.py b/src/main/python/utils/log_filter_script.py new file mode 100644 index 00000000000..827fecbc50d --- /dev/null +++ b/src/main/python/utils/log_filter_script.py @@ -0,0 +1,97 @@ +import os +import sys +import re +from pathlib import Path +from collections import Counter + + +def filter_log_file(input_file, output_file): + """ + Filter out repetitive IntHashGrid error messages and freight carrier messages from log file. + + Args: + input_file (str): Path to input log file + output_file (str): Path to output filtered log file + """ + try: + # Patterns to match the different error messages + spatial_pattern = re.compile( + r'.*ERROR com\.conveyal\.r5\.streets\.IntHashGrid - Visiting too many spatial index cells\.') + freight_pattern = re.compile( + r'.*ERROR b\.a\.a\.f\.input\.GenericFreightReader - Following freight carrier row discarded because tour ([\w-]+) was filtered out: \{.*\}') + + # Counters for different types of filtered lines + spatial_count = 0 + freight_count = 0 + total_count = 0 + + # Counter for specific tours that were filtered out + filtered_tours = Counter() + + with open(input_file, 'r', encoding='utf-8') as infile, \ + open(output_file, 'w', encoding='utf-8') as outfile: + + for line in infile: + total_count += 1 + + # Check for spatial index error + if spatial_pattern.match(line): + spatial_count += 1 + continue + + # Check for freight carrier error + freight_match = freight_pattern.match(line) + if freight_match: + freight_count += 1 + tour_id = freight_match.group(1) + filtered_tours[tour_id] += 1 + continue + + # Write non-matching lines to output file + outfile.write(line) + + # Print summary + print(f"\nProcessing complete:") + print(f"Total lines processed: {total_count}") + print(f"\nFiltered messages:") + print(f"- Spatial index errors: {spatial_count}") + print(f"- Freight carrier messages: {freight_count}") + print(f"Total lines filtered: {spatial_count + freight_count}") + print(f"Lines remaining: {total_count - (spatial_count + freight_count)}") + + # Print freight tour details if any were found + if filtered_tours: + print(f"\nFiltered tours breakdown:") + print("Tour ID\t\tCount") + print("-" * 30) + for tour_id, count in sorted(filtered_tours.items()): + print(f"{tour_id}\t\t{count}") + + # Additional statistics about tours + print(f"\nTotal unique tours filtered: {len(filtered_tours)}") + + print(f"\nFiltered log saved to: {output_file}") + + except FileNotFoundError: + print(f"Error: Could not find input file '{input_file}'") + sys.exit(1) + except PermissionError: + print(f"Error: Permission denied when accessing files") + sys.exit(1) + except Exception as e: + print(f"An unexpected error occurred: {str(e)}") + sys.exit(1) + + +if __name__ == "__main__": + # Get input file path from command line argument or use default + if len(sys.argv) > 1: + input_file = sys.argv[1] + else: + input_file = os.path.expanduser("~/Downloads/beamLog (3).out") + + # Create output filename by adding '_filtered' before the extension + input_path = Path(input_file) + output_file = input_path.with_stem(input_path.stem + '_filtered') + + filter_log_file(input_file, str(output_file)) diff --git a/src/main/python/utils/study_area_config.py b/src/main/python/utils/study_area_config.py new file mode 100644 index 00000000000..44160cd82a7 --- /dev/null +++ b/src/main/python/utils/study_area_config.py @@ -0,0 +1,541 @@ +""" +Configuration file for study area settings used in OSM network download and processing. +This file contains all the parameters needed to define a study area and its network characteristics. +""" +import os +import osmnx as ox +from osmnx import settings +import pandas as pd + +############################# +########## Methods ########## +############################# + +def get_fuel_key(row): + """ + Derive the standardized fuel key from vehicle data row. + + This function extracts the primary fuel type and adds a suffix + for electric vehicles based on whether they are pure electric + or hybrid vehicles. + + Args: + row (pandas.Series): A row from a vehicle types DataFrame + containing 'primaryFuelType' and 'secondaryFuelType' columns + + Returns: + str: A standardized fuel key string + """ + # Get primary fuel and convert to lowercase + fuel = row['primaryFuelType'].lower() + + # Special handling for electric vehicles + if fuel == "electricity": + # Check if it's a hybrid (has a secondary fuel) or pure electric + suffix = "only" if pd.isna(row['secondaryFuelType']) else "hybrid" + return f"{fuel}-{suffix}" + + return fuel + +def generate_network_name(config: dict) -> str: + """ + Generate a configuration name based on study area, graph layers, and tolerance. + Format: [study_area]-[main_geo_level]-[residential_geo_level][density]-t[tolerance][-ferry]-network + + Example output: sfbay-area-cbg7000-network or sfbay-area-cbg7000-ferry-network + """ + # Get study area + study_area = config["study_area"] + layers = config["network"]["graph_layers"] + + # Get residential geographic level and density + if "residential" in layers: + density_value = str(layers["residential"]["min_density_per_km2"]) + residential_geo_level = f"-{layers["residential"]["geo_level"]}{density_value}" + else: + density_value = "" + residential_geo_level = "" + + # Ferry suffix + ferry_suffix = "-ferry" if "ferry" in layers else "" + + # Combine all parts + return f"{study_area}-area{residential_geo_level}{ferry_suffix}-network" + + +def create_osm_highway_filter(highway_types): + """ + Convert a list of highway types to an OSM custom filter string. + + Args: + highway_types (list): List of highway type strings + + Returns: + str: OSM custom filter string in the format '["highway"~"type1|type2|..."]' + """ + # Join the highway types with the pipe character + highway_regex = "|".join(highway_types) + + # Create the full filter string + filter_string = f'["highway"~"{highway_regex}"]' + + return filter_string + + +def get_area_config(area_name): + + """ + Retrieve a deep copy of the configuration for the specified area. + + Args: + area_name (str): The name of the area ('sfbay' or 'seattle') + + Returns: + dict: A deep copy of the area's configuration + + Raises: + ValueError: If an invalid area name is provided + """ + import copy + area_configs = { + "sfbay": sfbay_area_config, + "seattle": seattle_area_config + } + + if area_name not in area_configs: + valid_areas = ", ".join(f"'{area}'" for area in area_configs.keys()) + raise ValueError(f"Invalid area name '{area_name}'. Choose from: {valid_areas}") + + return copy.deepcopy(area_configs[area_name]) + +############################# +########## Settings ######### +############################# + +# Create a file named beam_classes.py + +class BeamClasses: + """ + BEAM vehicle class definitions with flexible import options. + + This class provides accessible vehicle class constants used in BEAM transportation models, + with helper methods for grouping and categorization. + """ + # Freight vehicle classes + CLASS_2B3_VOCATIONAL = 'Class2b3Vocational' + CLASS_456_VOCATIONAL = 'Class456Vocational' + CLASS_78_VOCATIONAL = 'Class78Vocational' + CLASS_78_TRACTOR = 'Class78Tractor' + + # Non-freight vehicle classes + CLASS_CAR = "Car" # includes light and medium duty trucks + CLASS_BIKE = "Bike" + CLASS_MDP = "MediumDutyPassenger" + + @classmethod + def get_medium_heavy_freight_classes(cls): + """Returns a list of all freight vehicle classes.""" + return [ + cls.CLASS_456_VOCATIONAL, + cls.CLASS_78_VOCATIONAL, + cls.CLASS_78_TRACTOR + ] + + @classmethod + def get_freight_classes(cls): + """Returns a list of all freight vehicle classes.""" + return [ + cls.CLASS_2B3_VOCATIONAL, + cls.CLASS_456_VOCATIONAL, + cls.CLASS_78_VOCATIONAL, + cls.CLASS_78_TRACTOR + ] + + @classmethod + def get_passenger_classes(cls): + """Returns a list of all non-freight vehicle classes.""" + return [ + cls.CLASS_CAR, + cls.CLASS_BIKE, + cls.CLASS_MDP + ] + + @classmethod + def get_all_classes(cls): + """Returns a list of all vehicle classes.""" + return cls.get_freight_classes() + cls.get_passenger_classes() + + @classmethod + def is_freight(cls, beam_class): + """Returns True if the given class is a freight vehicle class.""" + return beam_class in cls.get_freight_classes() + + @classmethod + def class_to_display_name(cls, beam_class): + """Converts internal class names to display-friendly names.""" + display_names = { + cls.CLASS_2B3_VOCATIONAL: "Class 2b/3 Vocational", + cls.CLASS_456_VOCATIONAL: "Class 4-6 Vocational", + cls.CLASS_78_VOCATIONAL: "Class 7-8 Vocational", + cls.CLASS_78_TRACTOR: "Class 7-8 Tractor", + cls.CLASS_CAR: "Passenger Car", + cls.CLASS_BIKE: "Bicycle", + cls.CLASS_MDP: "Medium-Duty Passenger" + } + return display_names.get(beam_class, beam_class) + +constants = { + "joule_per_meter_base_rate": 1.213e8, # Energy consumption base rate in joules per meter + "max_fuel_capacity_in_joule": 1.2e16, # Maximum fuel capacity in joules (represents physical tank limits) + "meters_per_mile": 1609.34 # Conversion factor from miles to meters +} + +osm_highways = ["motorway", "motorway_link", "trunk", "trunk_link", "primary", "primary_link", "secondary", + "secondary_link", "tertiary", "tertiary_link", "unclassified", "residential"] + +osmnx_settings = { + "log_console": True, + "use_cache": True, + "cache_only_mode": False, + "all_oneway": True, + "requests_timeout": 180, + "overpass_memory": None, + "max_query_area_size": 50 * 1000 * 50 * 1000, # 50km × 50km + "overpass_rate_limit": False, + "overpass_max_attempts": 3, + "useful_tags_way": list(ox.settings.useful_tags_way) + [ + "maxweight", "hgv", "maxweight:hgv", "maxlength", "motorcar", "motor_vehicle", "goods", "truck" + ], + "overpass_url": "https://overpass-api.de/api", + # https://wiki.openstreetmap.org/wiki/Overpass_API#Public_Overpass_API_instances + } + +weight_limits = { + "unit": "lbs", + "mdv_max": 26000, # Upper limit for Medium Duty Vehicles (Class 3-6) in pounds + "hdv_max": 80000, # Upper limit for Heavy Duty Vehicles (Class 7-8) in pounds + } + +fastsim_routee_files = { + "primary_powertrain": { + "md-D-Diesel": "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(Diesel,_2020,_no_program).csv", + "md-E-BE": "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(BEV,_2025,_no_program).csv", + # "md-E-H2FC": np.nan, + "md-E-PHEV": "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(BEV,_2025,_no_program).csv", + "hdt-D-Diesel": "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(Diesel,_2020,_no_program).csv", + "hdt-E-BE": "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(BEV,_2025,_no_program).csv", + # "hdt-E-H2FC": np.nan, + "hdt-E-PHEV": "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(BEV,_2025,_no_program).csv", + "hdv-D-Diesel": "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(Diesel,_2020,_no_program).csv", + "hdv-E-BE": "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(BEV,_2025,_no_program).csv", + # "hdv-E-H2FC": np.nan, + "hdv-E-PHEV": "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(BEV,_2025,_no_program).csv" + }, + "secondary_powertrain": { + # "md-D-Diesel": np.nan, + # "md-E-BE": np.nan, + # "md-E-H2FC": np.nan, + "md-E-PHEV": ("Diesel", + 9595.796035186175, + constants["max_fuel_capacity_in_joule"], + "Freight_Baseline_FASTSimData_2020/Class_6_Box_truck_(HEV,_2025,_no_program).csv"), + # "hdt-D-Diesel": np.nan, + # "hdt-E-BE": np.nan, + # "hdt-E-H2FC": np.nan, + "hdt-E-PHEV": ("Diesel", + 13817.086117829229, + constants["max_fuel_capacity_in_joule"], + "Freight_Baseline_FASTSimData_2020/Class_8_Sleeper_cab_high_roof_(HEV,_2025,_no_program).csv"), + # "hdv-D-Diesel": np.nan, + # "hdv-E-BE": np.nan, + # "hdv-E-H2FC": np.nan, + "hdv-E-PHEV": ("Diesel", + 14026.761465378302, + constants["max_fuel_capacity_in_joule"], + "Freight_Baseline_FASTSimData_2020/Class_8_Box_truck_(HEV,_2025,_no_program).csv") + } +} + +########## SF Bay Area ######### + +sfbay_area_config = { + # Base paths + "work_dir": os.path.expanduser("~/Workspace/Simulation/sfbay"), + "study_area": "sfbay", + "state_fips": "06", + # 087 Santa Cruz + # 113 Yolo + "county_fips": ['001', '013', '041', '055', '075', '081', '085', '095', '097'], + "census_year": 2018, + + "geo": { + "utm_epsg": 26910, # NAD83 / UTM zone 10N + "taz_shp": "geo/shp/sfbay-tazs-epsg-26910.shp", + "taz_id": "taz1454", + "cbg_id": "GEOID", + }, + + "network": { + "osmnx_settings": osmnx_settings, + "weight_limits": weight_limits, # Vehicle weight classifications (FHWA) + "download_enabled": True, # if download isn't enabled, we read network from disk + "tolerance": 2, + "graph_layers": { # Density thresholds and corresponding network filters + "main": { + "geo_level": "county", + "custom_filter": create_osm_highway_filter(list(set(osm_highways) - {"residential"})), + "buffer_zone_in_meters": 200 + }, + "residential": { + "min_density_per_km2": 5500, + "geo_level": "cbg", + "custom_filter": create_osm_highway_filter(osm_highways), + "buffer_zone_in_meters": 20 + } + # // California has a higher urbanization rate (94.8% urban vs 80.7% national average) + # // https://dof.ca.gov/wp-content/uploads/sites/352/Forecasting/Demographics/Documents/Urban-Rural_Classification_and_2020_Urban_Area_Criteria_CA_SDC.pdf + # const avgPersonsPerHousehold = 2.9; // CA average household size (higher than national 2.5) + # + # // Core density calculation (using similar proportions as national but adjusted for CA household size) + # const coreHUDensity = 1275; // National high-density nucleus requirement + # const caDensityAdjustment = 2.9 / 2.5; // CA vs national household size ratio + # // Calculate CA-adjusted thresholds + # const caHighDensityPPSM = coreHUDensity * 2.9; + # const caInitialCorePPSM = 425 * 2.9; + # const caUrbanExtensionPPSM = 200 * 2.9; + # // Result + # // California-adjusted density thresholds (persons per square mile): + # // densest urban cores, typical of downtown areas in major California cities: 7,395 ppsm = 2,855 ppsk + # // High-density nucleus requirement: 3698 ppsm = 1429 ppsk + # // Initial core requirement: 1233 ppsm = 475 ppsk + # // Urban extension requirement: 580 ppsm = 224 ppsk + # // Rural Areas less than 580 people per square mile + }, + "validation": { + "npmrds": { + "year": 2018, + "geo": "validation/npmrds/California.shp", + "data": "validation/npmrds/al_ca_oct2018_1hr_trucks_pax.csv" + } + } + }, + + # FastSim routee files + "fastsim_routee_files": fastsim_routee_files, + + "freight": { + "stops_data": "data/austin_cargo_operations.csv", + "2018_Baseline" : { + "carriers_file": f"beam-ft/2024-11-06/2018-Baseline/carriers--2018-Baseline.csv", + "payloads_file": f"beam-ft/2024-11-06/2018-Baseline/payloads--2018-Baseline.csv", + "tours_file": f"beam-ft/2024-11-06/2018-Baseline/tours--2018-Baseline.csv", + "ft_vehicle_types_file": f"vehicle-tech/ft-vehicletypes--20241106--2018-Baseline.csv" + } + }, + + "emissions": { + "2018-Baseline" : { + "override_rates": False, + "override_fleet": True, + "rates": { + "output_dir": "emissions/20240123", + "filters": { + "season_month": "Annual", + "calendar_year": 2018, + "temperature": 60., + "relative_humidity": 40., + "sub_area": ["SF"], + "include_nan": True + }, + "emfac": { + "emfac_rates_by_model_year_file": f"emissions/rates/emfac/imputed_MTC_emission_rate_agg_NH3_added_2018_2025_2030_2040_2050.csv", + "emfac_vmt_by_model_year_file": f"emissions/rates/emfac/Default_Statewide_2018_2025_2030_2040_2050_Annual_vmt_20240612233346.csv", + "emfac_pop_by_model_year_file": f"emissions/rates/emfac/Default_Statewide_2018_2025_2030_2040_2050_Annual_population_20240612233346.csv" + }, + "black_carbon": { + "black_carbon_rates_file": f"emissions/rates/black_carbon/emfac_bc_rate_three_ver_2018.csv", + }, + "road_dust": { + "rainy_days_file": f"emissions/rates/road_dust/CA_input/rainy_days.csv", + "silt_loading_file": f"emissions/rates/road_dust/CA_input/silt_loading.csv", + } + }, + "beam" : { + "carriers_file": f"beam-ft/20240123/2018-Baseline/carriers--2018-Baseline.csv", + "payloads_file": f"beam-ft/20240123/2018-Baseline/payloads--2018-Baseline.csv", + "ft_vehicle_types_file": f"vehicle-tech/vehicleTypes--frism--2018-Baseline.csv", + "pax_vehicles_file": f"beam-pax/2023-Baseline/vehicles--atlas--2023-Baseline.csv.gz", + "pax_vehicle_types_file": f"vehicle-tech/vehicleTypes--atlas--2023-Baseline.csv" + }, + "mapping": { + "fleet": { + "ignore_beam_passenger_distribution": False, + "ignore_beam_freight_distribution": False + }, + "atlas":{ + "enable_atlas_emfac_crosswalk": True, + "emfac": f"atlas/atlas-emfac-xwalk.csv", + "routee": f"atlas/vehicle_type_mapping_baseline.csv", + "alternatives": { + "car": ['car'], + "suv": ['suv', 'car', 'truck'], + 'truck': ['truck', 'suv', 'minvan'], + 'van': ['minvan', 'truck'], + 'minvan': ['minvan', 'truck', 'van'] + } + }, + "fuel": { + "beam": { + "hydrogen": 'Elec', # From emission pov, BEAM's hydrogen cars shall be electric + "electricity-only": 'Elec', + "electricity-hybrid": 'Phe', + "gasoline": 'Gas', + "diesel": 'Dsl', + "biodiesel": 'Dsl' # From emission pov, BEAM's biodiesel cars shall be diesel + }, + "emfac-ft": { + "Elec": 'Elec', + "Phe": 'Phe', + "Gas": 'Dsl', + "Dsl": 'Dsl', + "NG": 'Dsl' # EMFAC NG cars will be mapped to BEAM's diesel cars + }, + "emfac-pax": { + "Elec": 'Elec', + "Phe": 'Phe', + "Gas": 'Gas', + "Dsl": 'Gas', + "NG": 'Gas' # EMFAC NG cars will be mapped to BEAM's diesel cars + }, + "emfac-bus": { + "Elec": 'Elec', + "Phe": 'Phe', + "Gas": 'Gas', + "Dsl": 'Dsl', + "NG": 'Dsl' + }, + "alternatives": { + "Elec": ['Elec', 'Phe'], + 'Phe': ['Phe', 'Elec'], + "Gas": ['Gas', 'Dsl'], + "Dsl": ['Dsl', 'Gas'] + } + }, + "class": { + "emfac-ft": { + "T6 CAIRP Class 4": "Class456Vocational", + "T6 CAIRP Class 5": "Class456Vocational", + "T6 CAIRP Class 6": "Class456Vocational", + "T6 CAIRP Class 7": "Class78Tractor", + "T6 Instate Delivery Class 4": "Class456Vocational", + "T6 Instate Delivery Class 5": "Class456Vocational", + "T6 Instate Delivery Class 6": "Class456Vocational", + "T6 Instate Delivery Class 7": "Class78Vocational", + "T6 Instate Other Class 4": "Class456Vocational", + "T6 Instate Other Class 5": "Class456Vocational", + "T6 Instate Other Class 6": "Class456Vocational", + "T6 Instate Other Class 7": "Class78Vocational", + "T6 Instate Tractor Class 6": "Class456Vocational", + "T6 Instate Tractor Class 7": "Class78Tractor", + "T6 OOS Class 4": "Class456Vocational", + "T6 OOS Class 5": "Class456Vocational", + "T6 OOS Class 6": "Class456Vocational", + "T6 OOS Class 7": "Class78Vocational", + "T7 CAIRP Class 8": "Class78Tractor", + "T7 NNOOS Class 8": "Class78Vocational", + "T7 NOOS Class 8": "Class78Vocational", + "T7 Single Concrete/Transit Mix Class 8": "Class78Vocational", + "T7 Single Dump Class 8": "Class78Vocational", + "T7 Single Other Class 8": "Class78Vocational", + "T7 Tractor Class 8": "Class78Tractor", + "T7IS": "Class78Tractor" + }, + "emfac-pax": { + "LDA": "Car", + "LDT1": "Car", + "LDT2": "Car", + "MCY": "Bike", + "MDV": "Car" + }, + "emfac-bus": { + "UBUS": "MediumDutyPassenger" + }, + "alternatives": { + "Class456Vocational": ['Class456Vocational', 'Class78Vocational'], + 'Class78Vocational': ['Class78Vocational', 'Class456Vocational', 'Class78Tractor'], + "Class78Tractor": ['Class78Tractor', 'Class78Vocational'], + "Car": ['Car'], + "Bike": ['Bike'], + "MediumDutyPassenger": ['MediumDutyPassenger'] + } + } + } + } + } +} + +########## Seattle Area ######### + +seattle_area_config = { + # OSMNX settings + "osmnx_settings": osmnx_settings, + + # Vehicle weight classifications (FHWA) + "weight_limits": weight_limits, + + # FastSim routee files + "fastsim_routee_files": fastsim_routee_files, + + # if download isn't enabled, we read network from disk + "download_enabled": True, + + # Base paths + "work_dir": os.path.expanduser("~/Workspace/Simulation/seattle"), + + # Geographic settings + "study_area": "seattle", + "state_fips": "53", + "county_fips": ["061", "033", "035", "053"], # ["061", "033", "035", "053"] + "census_year": 2018, + "utm_epsg": 32048, # + "tolerance": 2, + + # Density thresholds and corresponding network filters + "graph_layers": { + "main": { + "geo_level": "county", + "custom_filter": create_osm_highway_filter(list(set(osm_highways) - {"residential"})), + "buffer_zone_in_meters": 200 + }, + "ferry": { + "geo_level": "county", + "custom_filter": '["route"="ferry"]', + "buffer_zone_in_meters": 10000 + }, + "residential": { + "min_density_per_km2": 0, + "geo_level": "cbg", + "custom_filter": create_osm_highway_filter(osm_highways), + "buffer_zone_in_meters": 20 + } + # // Washington has a moderate urbanization rate (84.1% urban vs 80.7% national average) + # // https://www.census.gov/quickfacts/fact/table/WA/INC110223 + # // Washington's urbanization rate is higher than the national average but lower than California's 94.8% + # const avgPersonsPerHousehold = 2.51; // WA average household size (slightly higher than national 2.5) + + # // Core density calculation (using similar proportions as national but adjusted for WA household size) + # const coreHUDensity = 1275; // National high-density nucleus requirement + # const waDensityAdjustment = 2.51 / 2.5; // WA vs national household size ratio + # // Calculate WA-adjusted thresholds + # const waHighDensityPPSM = coreHUDensity * 2.51; + # const waInitialCorePPSM = 425 * 2.51; + # const waUrbanExtensionPPSM = 200 * 2.51; + + # // Washington-adjusted density thresholds (persons per square mile): + # // densest urban cores, typical of downtown areas in major Washington cities: 3200 ppsm = 1236 ppsk + # // High-density nucleus requirement: 3200 ppsm = 1236 ppsk + # // Initial core requirement: 1067 ppsm = 412 ppsk + # // Urban extension requirement: 502 ppsm = 194 ppsk + # // Rural Areas less than 502 people per square mile + } +} \ No newline at end of file diff --git a/src/main/resources/beam-template.conf b/src/main/resources/beam-template.conf index 09847bf8ff9..6dafdc61617 100755 --- a/src/main/resources/beam-template.conf +++ b/src/main/resources/beam-template.conf @@ -30,6 +30,7 @@ beam.agentsim.timeBinSize = "int | 3600" beam.agentsim.firstIteration = "int | 0" beam.agentsim.lastIteration = "int | 0" beam.agentsim.endTime = "30:00:00" +beam.agentsim.lastTransitTrip = "28:00:00" beam.agentsim.scheduleMonitorTask.initialDelay = 1 beam.agentsim.scheduleMonitorTask.interval = 30 beam.agentsim.snapLocationAndRemoveInvalidInputs = "boolean | false" @@ -106,6 +107,8 @@ beam.agentsim.agents.modalBehaviors.lowTimeSensitivity.highCongestion.highwayFac beam.agentsim.agents.modalBehaviors.lowTimeSensitivity.highCongestion.nonHighwayFactor.LevelLE2 = "double | 1.0" beam.agentsim.agents.modalBehaviors.lowTimeSensitivity.lowCongestion.highwayFactor.LevelLE2 = "double | 1.0" beam.agentsim.agents.modalBehaviors.lowTimeSensitivity.lowCongestion.nonHighwayFactor.LevelLE2 = "double | 1.0" +beam.agentsim.agents.modalBehaviors.multinomialLogit.units = "dollars" +beam.agentsim.agents.modalBehaviors.multinomialLogit.params.time = "double | 0.022" beam.agentsim.agents.modalBehaviors.multinomialLogit.params.transfer = "double | -1.4" beam.agentsim.agents.modalBehaviors.multinomialLogit.params.transit_crowding = "double | 0.0" beam.agentsim.agents.modalBehaviors.multinomialLogit.params.transit_crowding_percentile = "double | 90.0" @@ -485,6 +488,11 @@ beam.exchange { urbansim.scenarioLoadingTimeoutSeconds = "int | 3000" } output { + activitySimSkimsEnabled = "boolean | false" + sendNonChosenTripsToSkimmer = "boolean | true" + generateSkimsForAllModes = "boolean | false" + generateSkimsForRideHailTransit = "boolean | false" + # geo level different than TAZ (in beam taz-centers format) emissions { # This is the list of pollutants to filter out among # "CH4", "CO", "CO2", "HC", "NH3", "NOx", "PM", "PM10", "PM2_5", "ROG", "SOx", "TOG" @@ -500,6 +508,7 @@ beam.exchange { primary.enabled = "boolean | false" secondary.enabled = "boolean | false" # To filter the modes in the mapped skim using beam mode schema + #@optional secondary.beamModeFilter = [ "car", "bike", @@ -512,8 +521,8 @@ beam.exchange { "walk_transit", ] # geo level different than beam.agentsim.taz format - secondary.taz.filePath = string - secondary.taz.tazIdFieldName = string + secondary.taz.filePath = "String | ''" + secondary.taz.tazIdFieldName = "String | ''" #@optional secondary.taz.tazMapping { # To map this taz level with beam.agentsim.taz using two columns CSV file @@ -643,28 +652,28 @@ beam.physsim.network.overwriteRoadTypeProperties { alpha = "double?" beta = "double?" } - primary { + trunk { speed = "double?" capacity = "int?" lanes = "int?" alpha = "double?" beta = "double?" } - primaryLink { + trunkLink { speed = "double?" capacity = "int?" lanes = "int?" alpha = "double?" beta = "double?" } - trunk { + primary { speed = "double?" capacity = "int?" lanes = "int?" alpha = "double?" beta = "double?" } - trunkLink { + primaryLink { speed = "double?" capacity = "int?" lanes = "int?" @@ -699,28 +708,28 @@ beam.physsim.network.overwriteRoadTypeProperties { alpha = "double?" beta = "double?" } - minor { + unclassified { speed = "double?" capacity = "int?" lanes = "int?" alpha = "double?" beta = "double?" } - residential { + minor { speed = "double?" capacity = "int?" lanes = "int?" alpha = "double?" beta = "double?" } - livingStreet { + residential { speed = "double?" capacity = "int?" lanes = "int?" alpha = "double?" beta = "double?" } - unclassified { + livingStreet { speed = "double?" capacity = "int?" lanes = "int?" @@ -756,6 +765,7 @@ beam.replanning.ModuleProbability_3 = 0.1 beam.replanning.Module_4 = "TimeMutator" beam.replanning.ModuleProbability_4 = 0.0 beam.replanning.fractionOfIterationsToDisableInnovation = "double | Double.PositiveInfinity" +beam.replanning.subtractExpectedScores = "boolean | true" #@optional beam.replanning.clearModes.modes = [string] | [] beam.replanning.clearModes.iteration = "int | 0" @@ -821,7 +831,7 @@ beam.agentsim.h3taz = { # * linkStatsFromLastRun (only link stats is loaded from beam.input.lastBaseOutputDir directory) beam.warmStart.type = "disabled" beam.warmStart.samplePopulationIntegerFlag = 0 # Int chosen instead of Boolean, as passthrough coverts Boolean to Int -#PATH can be a directory or zip archive of the output directory (e.g. like what get's stored on S3), including a URL to an S3 output. +#PATH can be a directory or zip archive of the output directory (e.g. like what get's stored on S3), including a URL to an S3 output../gradlew -Ptag=beammodel/beam:0.9.0.0 buildImage beam.warmStart.path = "" # If the full warmstart directory isn't being used, it is possible to only load in a linkStats file instead to pre- # populate the link travel times. Add path to linkStats file here @@ -1055,6 +1065,7 @@ beam.routing { # if the route has a different access mode to the fastest, the actual amount of minutes used to decide # if it will be kept is 5 times this parameter. suboptimalMinutes = "int | 10" + suboptimalMinutesForDriveAccess = "int | 2" # HOW LONG DOES IT TAKE YOU TO PARK YOUR VEHICLE AT THE STATION accessBufferTimeSeconds { bike = "int | 60" diff --git a/src/main/scala/beam/agentsim/agents/PersonAgent.scala b/src/main/scala/beam/agentsim/agents/PersonAgent.scala index fbb500e7abf..ed1e0f7e6bf 100644 --- a/src/main/scala/beam/agentsim/agents/PersonAgent.scala +++ b/src/main/scala/beam/agentsim/agents/PersonAgent.scala @@ -53,6 +53,7 @@ import beam.sim.common.GeoUtils import beam.sim.config.BeamConfig.Beam.Debug import beam.sim.population.AttributesOfIndividual import beam.sim.{BeamScenario, BeamServices, Geofence} +import beam.utils.DateUtils.getLastTransitTripTime import beam.utils.MeasureUnitConversion._ import beam.utils.NetworkHelper import beam.utils.logging.ExponentialLazyLogging @@ -223,7 +224,7 @@ object PersonAgent { restOfCurrentTrip.headOption.exists(_.isRideHail) && !rideHailReservedForLegs.contains(restOfCurrentTrip.head) } - def currentTourModeIsIn(modes: BeamMode*): Boolean = currentTourMode.exists(modes.contains) + def currentTripModeIsIn(modes: BeamMode*): Boolean = currentTripMode.exists(modes.contains) override def withPassengerSchedule(newPassengerSchedule: PassengerSchedule): DrivingData = copy(passengerSchedule = newPassengerSchedule) @@ -673,7 +674,8 @@ class PersonAgent( currentTourModeChoiceStrategy.tourVehicle.orElse(data.currentTourPersonalVehicle), numberOfReplanningAttempts = 0, failedTrips = IndexedSeq.empty, - enrouteData = EnrouteData() + enrouteData = EnrouteData(), + passengerSchedule = PassengerSchedule() ), SpaceTime(currentCoord, _currentTick.get), excludeModes = @@ -794,24 +796,35 @@ class PersonAgent( serviceName = response.rideHailManagerName ) ) - val currentCoord = beamServices.geo.wgs2Utm(data.restOfCurrentTrip.head.beamLeg.travelPath.startPoint).loc eventsManager.processEvent( new ReplanningEvent( tick, Id.createPersonId(id), replanningReason, - currentCoord.getX, - currentCoord.getY + data.restOfCurrentTrip.head.beamLeg.travelPath.startPoint.loc.getX, + data.restOfCurrentTrip.head.beamLeg.travelPath.startPoint.loc.getY ) ) + + val currentCoord = beamServices.geo.wgs2Utm(data.restOfCurrentTrip.head.beamLeg.travelPath.startPoint).loc val nextCoord = nextActivity(data).get.getCoord goto(ChoosingMode) using ChoosesModeData( - data.copy(currentTripMode = None, numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1), + data.copy( + currentTripMode = None, + currentTrip = None, + restOfCurrentTrip = List.empty[EmbodiedBeamLeg], + numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1, + passengerSchedule = PassengerSchedule() + ), currentLocation = SpaceTime( currentCoord, tick ), + pendingChosenTrip = None, + rideHail2TransitRoutingResponse = None, + rideHail2TransitAccessResult = None, + rideHail2TransitEgressResult = None, isWithinTripReplanning = true, excludeModes = (if (data.numberOfReplanningAttempts > 0) Set(RIDE_HAIL, RIDE_HAIL_POOLED, RIDE_HAIL_TRANSIT) else Set()) ++ (if (canUseCars(currentCoord, nextCoord)) Set.empty[BeamMode] @@ -832,25 +845,51 @@ class PersonAgent( val currentCoord = beamServices.geo.wgs2Utm(data.nextLeg.beamLeg.travelPath.startPoint).loc val nextCoord = nextActivity(data).get.getCoord + val nextCoordWgs = beamServices.geo.utm2Wgs(nextCoord) val replanningReason = getReplanningReasonFrom(data, firstErrorResponse.errorCode.entryName) eventsManager.processEvent( new ReplanningEvent( _currentTick.get, Id.createPersonId(id), replanningReason, - currentCoord.getX, - currentCoord.getY, - nextCoord.getX, - nextCoord.getY + data.nextLeg.beamLeg.travelPath.startPoint.loc.getX, + data.nextLeg.beamLeg.travelPath.startPoint.loc.getY, + nextCoordWgs.getX, + nextCoordWgs.getY ) ) + + val (replannedMode, excludedMode) = + data.currentTripMode match { // Keep drive transit if we're picking up the vehicle + case Some(mode @ (BIKE_TRANSIT | DRIVE_TRANSIT)) if isLastTripWithinTour(nextActivity(data).get) => + (mode, None) + case Some(mode @ (BIKE_TRANSIT | RIDE_HAIL_TRANSIT | DRIVE_TRANSIT)) => + (WALK_TRANSIT, Some(mode)) + case _ => (WALK_TRANSIT, None) + } + goto(ChoosingMode) using ChoosesModeData( - data.copy(numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1), + data.copy( + numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1, + currentTrip = None, + currentTripMode = Some(replannedMode), + restOfCurrentTrip = List.empty[EmbodiedBeamLeg], + passengerSchedule = PassengerSchedule(), + failedTrips = data.failedTrips ++ data.currentTrip.map(trip => + trip.copy(legs = trip.legs.filter(_.beamLeg.startTime > _currentTick.getOrElse(-1))) + ) + ), currentLocation = SpaceTime(currentCoord, _currentTick.get), + pendingChosenTrip = None, + rideHail2TransitRoutingResponse = None, + rideHail2TransitAccessResult = None, + rideHail2TransitEgressResult = None, isWithinTripReplanning = true, - excludeModes = + excludeModes = excludedMode.toSet ++ ( if (canUseCars(currentCoord, nextCoord)) Set.empty else Set(BeamMode.RIDE_HAIL, BeamMode.CAR, BeamMode.CAV) + ), + mostRecentDeniedBoardingLeg = Some(data.nextLeg) ) } @@ -1038,7 +1077,11 @@ class PersonAgent( if (currentBeamVehicle.beamVehicleType.vehicleCategory != Bike) { if (currentBeamVehicle.stall.isEmpty) logWarn("Expected currentBeamVehicle.stall to be defined.") } - if (currentBeamVehicle.isSharedVehicle || BeamVehicle.isSharedTeleportationVehicle(currentBeamVehicle.id)) { + if ( + (currentBeamVehicle.isSharedVehicle && !BeamVehicle.isEmergencyVehicle( + currentBeamVehicle.id + )) || BeamVehicle.isSharedTeleportationVehicle(currentBeamVehicle.id) + ) { // Is a shared vehicle. Give it up. currentBeamVehicle.getManager.get ! ReleaseVehicle(currentBeamVehicle, triggerId) beamVehicles -= data.currentVehicle.head @@ -1090,30 +1133,41 @@ class PersonAgent( _currentTick.get, Id.createPersonId(id), replanningReason, - currentCoord.getX, - currentCoord.getY + basePersonData.restOfCurrentTrip.head.beamLeg.travelPath.startPoint.loc.getX, + basePersonData.restOfCurrentTrip.head.beamLeg.travelPath.startPoint.loc.getY ) ) val nextAct = nextActivity(basePersonData).get val nextCoord = nextAct.getCoord + // Change -- just switch back to walk_transit // Have to give up my mode as well, perhaps there's no option left for driving. - _experiencedBeamPlan.putStrategy(nextAct, TripModeChoiceStrategy(mode = None)) - val (updatedTourMode, updatedTourPersonalVehicle): (Option[BeamTourMode], Option[Id[BeamVehicle]]) = - if (nextAct.getType.equalsIgnoreCase("Home")) { (None, None) } - else { (basePersonData.currentTourMode, basePersonData.currentTourPersonalVehicle) } +// _experiencedBeamPlan.putStrategy(nextAct, TripModeChoiceStrategy(mode = None)) +// val (updatedTourMode, updatedTourPersonalVehicle): (Option[BeamTourMode], Option[Id[BeamVehicle]]) = +// if (nextAct.getType.equalsIgnoreCase("Home")) { (None, None) } +// else { (basePersonData.currentTourMode, basePersonData.currentTourPersonalVehicle) } goto(ChoosingMode) using ChoosesModeData( basePersonData.copy( - currentTripMode = None, - currentTourMode = updatedTourMode, + currentTripMode = Some(WALK_TRANSIT), + currentTrip = None, + restOfCurrentTrip = List.empty[EmbodiedBeamLeg], currentTourPersonalVehicle = updatedTourPersonalVehicle, - numberOfReplanningAttempts = basePersonData.numberOfReplanningAttempts + 1 + numberOfReplanningAttempts = basePersonData.numberOfReplanningAttempts + 1, + passengerSchedule = PassengerSchedule(), + failedTrips = basePersonData.failedTrips ++ basePersonData.currentTrip.map(trip => + trip.copy(legs = trip.legs.filter(_.beamLeg.startTime > _currentTick.getOrElse(-1))) + ) ), SpaceTime(currentCoord, _currentTick.get), isWithinTripReplanning = true, + pendingChosenTrip = None, + rideHail2TransitRoutingResponse = None, + rideHail2TransitAccessResult = None, + rideHail2TransitEgressResult = None, excludeModes = if (canUseCars(currentCoord, nextCoord)) Set.empty - else Set(BeamMode.RIDE_HAIL, BeamMode.CAR, BeamMode.CAV) + else Set(BeamMode.RIDE_HAIL, BeamMode.CAR, BeamMode.CAV), + mostRecentDeniedBoardingLeg = basePersonData.restOfCurrentTrip.headOption ) } @@ -1267,7 +1321,10 @@ class PersonAgent( // TRANSIT but too late case Event(StateTimeout, data: BasePersonData) if data.hasNextLeg && data.nextLeg.beamLeg.mode.isTransit && - data.nextLeg.beamLeg.startTime < _currentTick.get => + ((data.nextLeg.beamLeg.startTime < _currentTick.get) || (_currentTick.get > getLastTransitTripTime( + beamServices.beamConfig + ))) => + val nextAct = nextActivity(data) // We've missed the bus. This occurs when something takes longer than planned (based on the // initial inquiry). So we replan but change trip mode to WALK_TRANSIT since we've already done our non-transit // portion. @@ -1285,20 +1342,37 @@ class PersonAgent( _currentTick.get, Id.createPersonId(id), replanningReason, - currentCoord.getX, - currentCoord.getY + data.nextLeg.beamLeg.travelPath.startPoint.loc.getX, + data.nextLeg.beamLeg.travelPath.startPoint.loc.getY ) ) - val nextCoord = nextActivity(data).get.getCoord + val (replannedMode, excludedMode) = + data.currentTripMode match { // Keep drive transit if we're picking up the vehicle + case Some(mode @ (BIKE_TRANSIT | DRIVE_TRANSIT)) if isLastTripWithinTour(nextAct.get) => + (mode, None) + case Some(mode @ (BIKE_TRANSIT | RIDE_HAIL_TRANSIT | DRIVE_TRANSIT)) => + (WALK_TRANSIT, Some(mode)) + case _ => (WALK_TRANSIT, None) + } + + val nextCoord = nextAct.get.getCoord goto(ChoosingMode) using ChoosesModeData( personData = data - .copy(currentTripMode = Some(WALK_TRANSIT), numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1), + .copy( + currentTripMode = Some(replannedMode), + numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1, + passengerSchedule = PassengerSchedule(), + failedTrips = data.failedTrips ++ data.currentTrip.toVector + ), currentLocation = SpaceTime(currentCoord, _currentTick.get), + pendingChosenTrip = None, + rideHail2TransitRoutingResponse = None, + rideHail2TransitAccessResult = None, + rideHail2TransitEgressResult = None, isWithinTripReplanning = true, - excludeModes = - if (canUseCars(currentCoord, nextCoord)) Set.empty - else Set(BeamMode.RIDE_HAIL, BeamMode.CAR, BeamMode.CAV) + excludeModes = excludedMode.toSet ++ (if (canUseCars(currentCoord, nextCoord)) Set.empty + else Set(BeamMode.RIDE_HAIL, BeamMode.CAR, BeamMode.CAV)) ) // TRANSIT case Event(StateTimeout, data: BasePersonData) if data.hasNextLeg && data.nextLeg.beamLeg.mode.isTransit => @@ -1332,16 +1406,24 @@ class PersonAgent( _currentTick.get, Id.createPersonId(id), replanningReason, - currentCoord.getX, - currentCoord.getY + data.nextLeg.beamLeg.travelPath.startPoint.loc.getX, + data.nextLeg.beamLeg.travelPath.startPoint.loc.getY ) ) val nextCoord = nextActivity(data).get.getCoord goto(ChoosingMode) using ChoosesModeData( personData = data - .copy(currentTripMode = Some(WALK_TRANSIT), numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1), + .copy( + currentTripMode = None, + numberOfReplanningAttempts = data.numberOfReplanningAttempts + 1, + passengerSchedule = PassengerSchedule() + ), currentLocation = SpaceTime(currentCoord, _currentTick.get), + pendingChosenTrip = None, + rideHail2TransitRoutingResponse = None, + rideHail2TransitAccessResult = None, + rideHail2TransitEgressResult = None, isWithinTripReplanning = true, excludeModes = if (canUseCars(currentCoord, nextCoord)) Set.empty @@ -1365,7 +1447,7 @@ class PersonAgent( case Event( StateTimeout, data: BasePersonData - ) if data.currentTourModeIsIn(HOV2_TELEPORTATION, HOV3_TELEPORTATION) => + ) if data.currentTripModeIsIn(HOV2_TELEPORTATION, HOV3_TELEPORTATION) => nextActivity(data) match { case Some(activity) => val (tick, triggerId) = releaseTickAndTriggerId() @@ -1497,7 +1579,7 @@ class PersonAgent( if (activityEndTime > tick + beamServices.beamConfig.beam.agentsim.schedulerParallelismWindow) { activityEndTime.toInt } else { - logger.warn( + logger.debug( "Moving back next activity end time from {} to {} to avoid parallelism issues, currently on trip {}", activityEndTime, tick + beamServices.beamConfig.beam.agentsim.schedulerParallelismWindow, @@ -1546,6 +1628,7 @@ class PersonAgent( } case Some(personalVehId) => logger.error(s"Vehicle ${personalVehId.toString} seems to have disappeared") + logger.warn("Events leading up to this point:\n\t" + getLog.mkString("\n\t")) None case None => None @@ -1795,7 +1878,9 @@ class PersonAgent( protected def getCurrentTourStrategy( data: BasePersonData ): TourModeChoiceStrategy = { - _experiencedBeamPlan.getTourStrategy[TourModeChoiceStrategy](currentActivity(data)) + nextActivity(data) + .map(_experiencedBeamPlan.getTourStrategy[TourModeChoiceStrategy](_)) + .getOrElse(TourModeChoiceStrategy()) } private def handleSuccessfulTransitReservation( diff --git a/src/main/scala/beam/agentsim/agents/Population.scala b/src/main/scala/beam/agentsim/agents/Population.scala index 75354f8c715..7cabe26d40d 100755 --- a/src/main/scala/beam/agentsim/agents/Population.scala +++ b/src/main/scala/beam/agentsim/agents/Population.scala @@ -138,8 +138,10 @@ class Population( .collectionAsScalaIterable(household.getVehicleIds) .map { vid => val bv = beamScenario.privateVehicles(BeamVehicle.createId(vid)) + val managerType = + if (bv.isFreightVehicle) VehicleManager.TypeEnum.Freight else VehicleManager.TypeEnum.Household val reservedFor = - VehicleManager.createOrGetReservedFor(household.getId.toString, VehicleManager.TypeEnum.Household) + VehicleManager.createOrGetReservedFor(household.getId.toString, managerType) bv.vehicleManagerId.set(reservedFor.managerId) bv.id -> bv } diff --git a/src/main/scala/beam/agentsim/agents/choice/logit/MultinomialLogit.scala b/src/main/scala/beam/agentsim/agents/choice/logit/MultinomialLogit.scala index 7616a8d6efe..e5e9ac6fa06 100644 --- a/src/main/scala/beam/agentsim/agents/choice/logit/MultinomialLogit.scala +++ b/src/main/scala/beam/agentsim/agents/choice/logit/MultinomialLogit.scala @@ -44,8 +44,10 @@ class MultinomialLogit[A, T]( } def calcAlternativesWithUtility( - alternatives: Map[A, Map[T, Double]] + alternatives: Map[A, Map[T, Double]], + override_scale_factor_option: Option[Double] = None ): Iterable[AlternativeWithUtility[A]] = { + val override_scale_factor = override_scale_factor_option.getOrElse(scale_factor) // evaluate utility of alternatives val altsWithUtility: Iterable[AlternativeWithUtility[A]] = alternatives.foldLeft(List.empty[AlternativeWithUtility[A]]) { case (accumulator, (alt, attributes)) => @@ -56,8 +58,8 @@ class MultinomialLogit[A, T]( // place on tail of list, allowing us to short-circuit the sampling in next step accumulator :+ AlternativeWithUtility( alt, - thisUtility * scale_factor, - math.exp(thisUtility * scale_factor) + thisUtility * override_scale_factor, + math.exp(thisUtility * override_scale_factor) ) } else if (thisUtility.isNegInfinity) { // utility of negative infinity means that an alternative isn't feasible, so we filter it out @@ -65,8 +67,8 @@ class MultinomialLogit[A, T]( } else { AlternativeWithUtility( alt, - thisUtility * scale_factor, - math.exp(thisUtility * scale_factor) + thisUtility * override_scale_factor, + math.exp(thisUtility * override_scale_factor) ) +: accumulator } } @@ -126,18 +128,20 @@ class MultinomialLogit[A, T]( * @return */ def getExpectedMaximumUtility( - alternatives: Map[A, Map[T, Double]] + alternatives: Map[A, Map[T, Double]], + override_scale_factor_option: Option[Double] = None ): Option[Double] = { + val override_scale_factor = override_scale_factor_option.getOrElse(scale_factor) val scaledUtilityOfAlternatives: Iterable[Double] = for { (alt, attributes) <- alternatives utility <- getUtilityOfAlternative(alt, attributes) } yield { - utility * scale_factor + utility * override_scale_factor } if (scaledUtilityOfAlternatives.isEmpty) None - else Some { MathUtils.logSumExp(scaledUtilityOfAlternatives) / scale_factor } + else Some { MathUtils.logSumExp(scaledUtilityOfAlternatives) / override_scale_factor } } /** diff --git a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceDriveIfAvailable.scala b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceDriveIfAvailable.scala index 46ea6d4a90c..75614a8bff6 100755 --- a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceDriveIfAvailable.scala +++ b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceDriveIfAvailable.scala @@ -53,9 +53,10 @@ class ModeChoiceDriveIfAvailable(val beamServices: BeamServices) extends ModeCho ) = 0.0 override def computeAllDayUtility( - trips: ListBuffer[EmbodiedBeamTrip], + trips: Map[EmbodiedBeamTrip, Map[String, Double]], person: Person, - attributesOfIndividual: AttributesOfIndividual + attributesOfIndividual: AttributesOfIndividual, + overrideAttributes: Boolean = false ): Double = 0.0 } diff --git a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceLCCM.scala b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceLCCM.scala index 697f466a79d..6fa699ce539 100644 --- a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceLCCM.scala +++ b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceLCCM.scala @@ -290,9 +290,10 @@ class ModeChoiceLCCM( ): Double = 0.0 override def computeAllDayUtility( - trips: ListBuffer[EmbodiedBeamTrip], + trips: Map[EmbodiedBeamTrip, Map[String, Double]], person: Person, - attributesOfIndividual: AttributesOfIndividual + attributesOfIndividual: AttributesOfIndividual, + overrideAttributes: Boolean = false ): Double = { // Compute and log all-day score w.r.t. all modality styles // One of them has many suspicious-looking 0.0 values. Probably something which @@ -305,7 +306,7 @@ class ModeChoiceLCCM( } .toMap .mapValues(modeChoiceCalculatorForStyle => - trips.map(trip => modeChoiceCalculatorForStyle.utilityOf(trip, attributesOfIndividual, None, None)).sum + trips.keys.map(trip => modeChoiceCalculatorForStyle.utilityOf(trip, attributesOfIndividual, None, None)).sum ) .toArray .toMap // to force computation DO NOT TOUCH IT, because here is call-by-name and it's lazy which will hold a lot of memory !!! :) diff --git a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceMultinomialLogit.scala b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceMultinomialLogit.scala index eda7e4af9fa..f9cf6b56d38 100755 --- a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceMultinomialLogit.scala +++ b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceMultinomialLogit.scala @@ -79,7 +79,15 @@ class ModeChoiceMultinomialLogit( (mct.embodiedBeamTrip, theParams ++ transferParam) }.toMap - val alternativesWithUtility = model.calcAlternativesWithUtility(inputData) + val scaleFactor = beamConfig.beam.agentsim.agents.modalBehaviors.multinomialLogit.units.toLowerCase match { + case "dollars" => None + case "utils" => + Some( + beamConfig.beam.agentsim.agents.modalBehaviors.multinomialLogit.params.time / attributesOfIndividual.valueOfTime * 60.0 + ) + } + + val alternativesWithUtility = model.calcAlternativesWithUtility(inputData, scaleFactor) val chosenModeOpt = model.sampleAlternative(alternativesWithUtility, random) expectedMaximumUtility = model.getExpectedMaximumUtility(inputData).getOrElse(0) @@ -585,7 +593,7 @@ class ModeChoiceMultinomialLogit( numTransfers: Int = 0, transitOccupancyLevel: Double ): Double = { - modeModel.getUtilityOfAlternative(mode, attributes(cost, transitOccupancyLevel, numTransfers)).getOrElse(0) + modeModel.getUtilityOfAlternative(mode, attributes(cost + time, transitOccupancyLevel, numTransfers)).getOrElse(0) } private def attributes(cost: Double, transitOccupancyLevel: Double, numTransfers: Int) = { @@ -597,11 +605,33 @@ class ModeChoiceMultinomialLogit( } override def computeAllDayUtility( - trips: ListBuffer[EmbodiedBeamTrip], + trips: Map[EmbodiedBeamTrip, Map[String, Double]], person: Person, - attributesOfIndividual: AttributesOfIndividual + attributesOfIndividual: AttributesOfIndividual, + overrideAttributes: Boolean = false ): Double = - trips.map(trip => utilityOf(trip, attributesOfIndividual, None, None)).sum // TODO: Update with destination activity + trips.map { case (trip, mods) => + val modeChoiceData = altsToModeCostTimeTransfers( + IndexedSeq(trip), + attributesOfIndividual, + None, + None + ).head + + val newScaledTime = if (overrideAttributes) { + modeChoiceData.scaledTime / mods.getOrElse("travelTimeRatio", 1.0) + } else { modeChoiceData.scaledTime } + + // Placeholder to subtract off other components (e.g. cost) if they differ from expected values + + utilityOf( + trip.tripClassifier, + modeChoiceData.cost, + newScaledTime, + modeChoiceData.numTransfers, + modeChoiceData.transitOccupancyLevel + ) + }.sum // TODO: Update with destination activity } object ModeChoiceMultinomialLogit extends StrictLogging { diff --git a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceRideHailIfAvailable.scala b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceRideHailIfAvailable.scala index 5cb7aa10785..3761cda8481 100755 --- a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceRideHailIfAvailable.scala +++ b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceRideHailIfAvailable.scala @@ -54,8 +54,9 @@ class ModeChoiceRideHailIfAvailable(val beamServices: BeamServices) extends Mode ): Double = 0.0 override def computeAllDayUtility( - trips: ListBuffer[EmbodiedBeamTrip], + trips: Map[EmbodiedBeamTrip, Map[String, Double]], person: Person, - attributesOfIndividual: AttributesOfIndividual + attributesOfIndividual: AttributesOfIndividual, + overrideAttributes: Boolean = false ): Double = 0.0 } diff --git a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceTransitIfAvailable.scala b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceTransitIfAvailable.scala index 2bf8b7438bf..dc679a6d597 100755 --- a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceTransitIfAvailable.scala +++ b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceTransitIfAvailable.scala @@ -56,9 +56,10 @@ class ModeChoiceTransitIfAvailable(val beamServices: BeamServices) extends ModeC ): Double = 0.0 override def computeAllDayUtility( - trips: ListBuffer[EmbodiedBeamTrip], + trips: Map[EmbodiedBeamTrip, Map[String, Double]], person: Person, - attributesOfIndividual: AttributesOfIndividual + attributesOfIndividual: AttributesOfIndividual, + overrideAttributes: Boolean = false ): Double = 0.0 } diff --git a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceUniformRandom.scala b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceUniformRandom.scala index 71ce672db60..7b645d29cf0 100755 --- a/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceUniformRandom.scala +++ b/src/main/scala/beam/agentsim/agents/choice/mode/ModeChoiceUniformRandom.scala @@ -44,8 +44,9 @@ class ModeChoiceUniformRandom(val beamConfig: BeamConfig) extends ModeChoiceCalc ): Double = 0.0 override def computeAllDayUtility( - trips: ListBuffer[EmbodiedBeamTrip], + trips: Map[EmbodiedBeamTrip, Map[String, Double]], person: Person, - attributesOfIndividual: AttributesOfIndividual + attributesOfIndividual: AttributesOfIndividual, + overrideAttributes: Boolean = false ): Double = 0.0 } diff --git a/src/main/scala/beam/agentsim/agents/freight/FreightEntities.scala b/src/main/scala/beam/agentsim/agents/freight/FreightEntities.scala index 779e6ea5507..e30bc18d79c 100644 --- a/src/main/scala/beam/agentsim/agents/freight/FreightEntities.scala +++ b/src/main/scala/beam/agentsim/agents/freight/FreightEntities.scala @@ -16,17 +16,26 @@ sealed abstract class FreightRequestType extends EnumEntry object FreightRequestType extends Enum[FreightRequestType] { val values: immutable.IndexedSeq[FreightRequestType] = findValues - case object Unloading extends FreightRequestType case object Loading extends FreightRequestType +} + +sealed abstract class FreightDeliveryType extends EnumEntry { val value: String } +object FreightDeliveryType extends Enum[FreightDeliveryType] { + val values: immutable.IndexedSeq[FreightDeliveryType] = findValues + case object B2B extends FreightDeliveryType { override val value = "b2b" } + case object B2C extends FreightDeliveryType { override val value = "b2c" } + case object Whatever extends FreightDeliveryType { override val value = "whatever" } + + def apply(s: String): FreightDeliveryType = { + if (s.trim.toLowerCase.startsWith(B2B.value) || s.trim.toLowerCase.contains(B2B.value)) B2B + else if (s.trim.toLowerCase.startsWith(B2C.value) || s.trim.toLowerCase.contains(B2C.value)) B2C + else Whatever + } } -case class FreightTour( - tourId: Id[FreightTour], - departureTimeInSec: Int, - maxTourDurationInSec: Int -) +case class FreightTour(tourId: Id[FreightTour], departureTimeInSec: Int, maxTourDurationInSec: Int) case class PayloadPlan( payloadId: Id[PayloadPlan], diff --git a/src/main/scala/beam/agentsim/agents/freight/FreightReplanner.scala b/src/main/scala/beam/agentsim/agents/freight/FreightReplanner.scala index d2debfe9302..00620ba08cf 100644 --- a/src/main/scala/beam/agentsim/agents/freight/FreightReplanner.scala +++ b/src/main/scala/beam/agentsim/agents/freight/FreightReplanner.scala @@ -143,7 +143,7 @@ class FreightReplanner( ): TimeDistanceCost = { val beamVehicleType = (for { vehicle <- maybeVehicle - vehicleType <- freightCarrier.fleet.get(Id.createVehicleId(vehicle.id)) + vehicleType <- beamServices.beamScenario.privateVehicles.get(Id.createVehicleId(vehicle.id)) } yield vehicleType.beamVehicleType).getOrElse(freightCarrier.fleet.values.head.beamVehicleType) val fuelPrice: Double = beamServices.beamScenario.fuelTypePrices(beamVehicleType.primaryFuelType) @@ -186,9 +186,10 @@ class FreightReplanner( def solveForTheWholeFeet: Solution = { val vehicles = - freightCarrier.fleet.values - .map(beamVehicle => { + freightCarrier.fleet.keys + .map(beamVehicleId => { val departure = randomTimeAround(departureTime) + val beamVehicle = beamServices.beamScenario.privateVehicles(Id.createVehicleId(beamVehicleId)) toJspritVehicle(freightCarrier.carrierId, beamVehicle, departure) }) .toIndexedSeq @@ -207,7 +208,7 @@ class FreightReplanner( val tourSolutions = for { (vehicleId, tours) <- freightCarrier.tourMap - beamVehicle = freightCarrier.fleet(vehicleId) + beamVehicle = beamServices.beamScenario.privateVehicles(Id.createVehicleId(vehicleId)) tour <- tours services = freightCarrier.plansPerTour(tour.tourId).map(toService) vehicles = IndexedSeq(toJspritVehicle(freightCarrier.carrierId, beamVehicle, tour.departureTimeInSec)) diff --git a/src/main/scala/beam/agentsim/agents/freight/input/FreightReader.scala b/src/main/scala/beam/agentsim/agents/freight/input/FreightReader.scala index 85e824f9b69..b3fb12b73ac 100644 --- a/src/main/scala/beam/agentsim/agents/freight/input/FreightReader.scala +++ b/src/main/scala/beam/agentsim/agents/freight/input/FreightReader.scala @@ -42,7 +42,7 @@ trait FreightReader { vehicleTypes: Map[Id[BeamVehicleType], BeamVehicleType] ): IndexedSeq[FreightCarrier] - def calculatePayloadWeights(plans: IndexedSeq[PayloadPlan]): IndexedSeq[(Set[Id[PayloadPlan]], Double)] = { + private def calculatePayloadWeights(plans: IndexedSeq[PayloadPlan]): IndexedSeq[(Set[Id[PayloadPlan]], Double)] = { plans.foldLeft(IndexedSeq((Set.empty[Id[PayloadPlan]], 0.0))) { case (acc, PayloadPlan(payloadId, _, _, _, weight, Unloading, _, _, _, _, _, _, _)) => val (payloads, payloadWeight) = acc.last @@ -107,8 +107,8 @@ trait FreightReader { householdsFactory: HouseholdsFactory ): IndexedSeq[(FreightCarrier, Household, Plan, Person, Id[BeamVehicle])] = { carriers.flatMap { carrier => - val freightHouseholdId = createHouseholdId(carrier.carrierId) - val household = householdsFactory.createHousehold(freightHouseholdId) + val freightCarrierId = createHouseholdId(carrier.carrierId) + val household = householdsFactory.createHousehold(freightCarrierId) household.setIncome(new IncomeImpl(0, Income.IncomePeriod.year)) carrier.tourMap.map { case (vehicleId, tours) => val personId = createPersonId(carrier.carrierId, vehicleId) @@ -139,7 +139,7 @@ trait FreightReader { powertrain, vehicleType, vehicleManagerId = new AtomicReference( - VehicleManager.createOrGetReservedFor(carrierId.toString, VehicleManager.TypeEnum.Freight).managerId + VehicleManager.createOrGetReservedFor(carrierId.toString, Some(VehicleManager.TypeEnum.Freight)).managerId ), randomSeed ) @@ -147,7 +147,7 @@ trait FreightReader { vehicle } - protected def createFreightActivity( + private def createFreightActivity( activityType: String, locationUTM: Coord, endTime: Int, @@ -161,7 +161,7 @@ trait FreightReader { act } - protected def createFreightLeg(departureTime: Int): Leg = { + private def createFreightLeg(departureTime: Int): Leg = { val leg = PopulationUtils.createLeg(BeamMode.CAR.value) leg.setDepartureTime(departureTime) leg @@ -169,7 +169,7 @@ trait FreightReader { } object FreightReader { - val FREIGHT_ID_PREFIX = "freight" + val CARRIER_ID_PREFIX = "carrier" val FREIGHT_REQUEST_TYPE = "FreightRequestType" val PAYLOAD_WEIGHT_IN_KG = "PayloadWeightInKg" val PAYLOAD_IDS = "PayloadIds" diff --git a/src/main/scala/beam/agentsim/agents/freight/input/GenericFreightReader.scala b/src/main/scala/beam/agentsim/agents/freight/input/GenericFreightReader.scala index 5f000ca55c2..5e1d12c3ad3 100644 --- a/src/main/scala/beam/agentsim/agents/freight/input/GenericFreightReader.scala +++ b/src/main/scala/beam/agentsim/agents/freight/input/GenericFreightReader.scala @@ -1,7 +1,7 @@ package beam.agentsim.agents.freight.input import beam.agentsim.agents.freight._ -import beam.agentsim.agents.freight.input.FreightReader.{FREIGHT_ID_PREFIX, NO_CARRIER_ID, NO_VEHICLE_ID} +import beam.agentsim.agents.freight.input.FreightReader._ import beam.agentsim.agents.vehicles.{BeamVehicle, BeamVehicleType} import beam.agentsim.infrastructure.taz.{TAZ, TAZTreeMap} import beam.sim.common.GeoUtils @@ -125,16 +125,19 @@ class GenericFreightReader( ) } val operationDurationInSec = get("operationDurationInSec").toDouble.round.toInt - val activityType = if (config.generateFixedActivitiesDurations) { - s"${requestType.toString}|$operationDurationInSec" - } else { - requestType.toString - } val payloadId = get("payloadId").createId[PayloadPlan] val locationX = row.get("locationX") val locationY = row.get("locationY") + val deliveryType: FreightDeliveryType = FreightDeliveryType(payloadId.toString) + + val activityType = if (config.generateFixedActivitiesDurations) { + s"${deliveryType.value}|${requestType.toString}|$operationDurationInSec" + } else { + s"${deliveryType.value}|${requestType.toString}" + } + extractCoordInUtmOrTaz( locationX, locationY, @@ -253,8 +256,8 @@ class GenericFreightReader( val tourMap: Map[Id[BeamVehicle], IndexedSeq[FreightTour]] = carrierRows .groupBy(_.vehicleId) - .mapValues { rows => - rows + .mapValues { + _ //setting the tour warehouse location to be the carrier warehouse location .map(row => tours(row.tourId)) .sortBy(_.departureTimeInSec) @@ -293,10 +296,10 @@ class GenericFreightReader( if (isGoodsCarrier) if (carrierIdStr == null || carrierIdStr.isBlank) NO_CARRIER_ID else carrierIdStr.createId - else s"${FREIGHT_ID_PREFIX}Carrier-$carrierIdStr".createId[FreightCarrier] + else s"$CARRIER_ID_PREFIX-$carrierIdStr".createId[FreightCarrier] val tourId: Id[FreightTour] = get("tourId").createId val vehicleId: Id[BeamVehicle] = - if (isGoodsCarrier) NO_VEHICLE_ID else Id.createVehicleId(s"${FREIGHT_ID_PREFIX}Vehicle-$vehicleIdStr") + if (isGoodsCarrier) NO_VEHICLE_ID else Id.createVehicleId(s"${CARRIER_ID_PREFIX}Vehicle-$vehicleIdStr") val vehicleTypeId: Id[BeamVehicleType] = if (isGoodsCarrier) "no-type".createId else get("vehicleTypeId").createId if (!existingAllTours.contains(tourId)) { logger.error(f"Following freight carrier row discarded because tour $tourId was filtered out: $row") @@ -378,14 +381,14 @@ class GenericFreightReader( @Override def createPersonId(carrierId: Id[FreightCarrier], vehicleId: Id[BeamVehicle]): Id[Person] = { - val updatedVehicleId = vehicleId.toString.replace(FREIGHT_ID_PREFIX + "Vehicle-", "") - Id.createPersonId(s"${FREIGHT_ID_PREFIX}Driver-$updatedVehicleId") + val updatedVehicleId = vehicleId.toString.replace(s"${CARRIER_ID_PREFIX}Vehicle-", "") + Id.createPersonId(s"${CARRIER_ID_PREFIX}Driver-$updatedVehicleId") } @Override def createHouseholdId(carrierId: Id[FreightCarrier]): Id[Household] = { val updatedCarrierId = carrierId.toString.replace(FREIGHT_ID_PREFIX + "Carrier-", "") - s"${FREIGHT_ID_PREFIX}Household-$updatedCarrierId".createId + s"carrier-$updatedCarrierId".createId } } diff --git a/src/main/scala/beam/agentsim/agents/household/HouseholdActor.scala b/src/main/scala/beam/agentsim/agents/household/HouseholdActor.scala index bf63b67759c..41631accf00 100755 --- a/src/main/scala/beam/agentsim/agents/household/HouseholdActor.scala +++ b/src/main/scala/beam/agentsim/agents/household/HouseholdActor.scala @@ -28,6 +28,7 @@ import beam.agentsim.events.SpaceTime import beam.agentsim.infrastructure.ChargingNetworkManager.ChargingPlugRequest import beam.agentsim.infrastructure.ParkingInquiry.{ParkingActivityType, ParkingSearchMode} import beam.agentsim.infrastructure.{ParkingInquiry, ParkingInquiryResponse} +import beam.agentsim.infrastructure.parking.ParkingType import beam.agentsim.scheduler.BeamAgentScheduler.{CompletionNotice, ScheduleTrigger} import beam.agentsim.scheduler.HasTriggerId import beam.agentsim.scheduler.Trigger.TriggerWithId @@ -127,6 +128,8 @@ object HouseholdActor { case class MobilityStatusResponse(streetVehicle: Vector[VehicleOrToken], triggerId: Long) extends HasTriggerId + case class RetryModeChoice(triggerId: Long) extends HasTriggerId + case class GetVehicleTypes(triggerId: Long) extends HasTriggerId case class VehicleTypesResponse(vehicleTypes: Set[BeamVehicleType], triggerId: Long) extends HasTriggerId @@ -159,7 +162,7 @@ object HouseholdActor { val population: org.matsim.api.core.v01.population.Population, val household: Household, vehicles: Map[Id[BeamVehicle], BeamVehicle], - fallbackHomeCoord: Coord, + fallbackInitialLocationCoord: Coord, sharedVehicleFleets: Seq[ActorRef] = Vector(), possibleSharedVehicleTypes: Set[BeamVehicleType], routeHistory: RouteHistory, @@ -196,8 +199,7 @@ object HouseholdActor { private var members: Map[Id[Person], PersonIdWithActorRef] = Map() - private val isFreightCarrier: Boolean = - household.getId.toString.startsWith(FreightReader.FREIGHT_ID_PREFIX) + private val isFreightCarrier: Boolean = household.getId.toString.startsWith(FreightReader.CARRIER_ID_PREFIX) // Data need to execute CAV dispatch private val cavPlans: mutable.ListBuffer[CAVSchedule] = mutable.ListBuffer() @@ -205,7 +207,7 @@ object HouseholdActor { private var personAndActivityToCav: Map[(Id[Person], Activity), BeamVehicle] = Map() private var personAndActivityToLegs: Map[(Id[Person], Activity), List[BeamLeg]] = Map() - private var householdMembersToActivityTypeAndLocation: Map[Id[Person], HomeAndStartingWorkLocation] = + private var householdMembersToActivityTypeAndLocation: Map[Id[Person], ActivityTypeAndLocation] = Map() private val trackingCAVAssignmentAtInitialization = mutable.HashMap.empty[Id[BeamVehicle], Id[Person]] private val householdVehicleCategories = List(Car, Bike) @@ -235,9 +237,10 @@ object HouseholdActor { } person.getSelectedPlan.getPlanElements.asScala.find(_.isInstanceOf[Activity]) map { element => val act = element.asInstanceOf[Activity] - val parkingActivityType = ParkingInquiry.activityTypeStringToEnum(act.getType) + val actType = if (isFreightCarrier) ParkingActivityType.Depot.toString else act.getType + val parkingActivityType = ParkingInquiry.activityTypeStringToEnum(actType) val endTime = act.getEndTime.orElseGet(() => DateUtils.getEndOfTime(beamServices.beamScenario.beamConfig)) - person.getId -> HomeAndStartingWorkLocation( + person.getId -> ActivityTypeAndLocation( parkingActivityType, act.getType, act.getCoord, @@ -247,15 +250,30 @@ object HouseholdActor { } .toMap - if (!householdMembersToActivityTypeAndLocation.exists(_._2.parkingActivityType == ParkingActivityType.Home)) { + if ( + isFreightCarrier && !householdMembersToActivityTypeAndLocation.exists( + _._2.parkingActivityType == ParkingActivityType.Depot + ) + ) { + householdMembersToActivityTypeAndLocation ++= Map( + Id.createPersonId("NoDriver") -> ActivityTypeAndLocation( + ParkingActivityType.Depot, + "Warehouse", + fallbackInitialLocationCoord, + DateUtils.getEndOfTime(beamServices.beamScenario.beamConfig) + ) + ) + } else if ( + !isFreightCarrier && !householdMembersToActivityTypeAndLocation.exists( + _._2.parkingActivityType == ParkingActivityType.Home + ) + ) { householdMembersToActivityTypeAndLocation ++= Map( - Id.createPersonId("") -> HomeAndStartingWorkLocation( + Id.createPersonId("NoDriver") -> ActivityTypeAndLocation( ParkingActivityType.Home, "Home", - fallbackHomeCoord, - DateUtils.getEndOfTime( - beamServices.beamScenario.beamConfig - ) + fallbackInitialLocationCoord, + DateUtils.getEndOfTime(beamServices.beamScenario.beamConfig) ) ) } @@ -285,6 +303,7 @@ object HouseholdActor { Some(new EmergencyHouseholdVehicleGenerator(household, beamScenario, vehiclesAdjustment, category)) else None, whoDrivesThisFreightVehicle, + isFreightCarrier, beamServices.matsimServices.getEvents, beamServices.geo, beamServices.beamConfig, @@ -336,7 +355,7 @@ object HouseholdActor { .map(_._1) .getOrElse(householdMembersToActivityTypeAndLocation.keys.head) trackingCAVAssignmentAtInitialization.put(cav.id, personId) - val HomeAndStartingWorkLocation(_, _, location, _) = householdMembersToActivityTypeAndLocation(personId) + val ActivityTypeAndLocation(_, _, location, _) = householdMembersToActivityTypeAndLocation(personId) cav.spaceTime = SpaceTime(location, 0) schedulerRef ! ScheduleTrigger(InitializeTrigger(0), cavDriverRef) cav.setManager(Some(self)) @@ -604,11 +623,12 @@ object HouseholdActor { .sequence(vehicles.filter(_._2.isCAV).values.map { vehicle => vehicle.setManager(Some(self)) val personId = trackingCAVAssignmentAtInitialization(vehicle.id) - val HomeAndStartingWorkLocation(_, activityType, location, endTime) = + val ActivityTypeAndLocation(_, activityType, location, endTime) = householdMembersToActivityTypeAndLocation(personId) val parkingDuration = endTime - tick for { ParkingInquiryResponse(stall, _, _) <- sendParkingOrChargingInquiry( + personId, vehicle, activityType, location, @@ -637,6 +657,7 @@ object HouseholdActor { } private def sendParkingOrChargingInquiry( + person: Id[Person], vehicle: BeamVehicle, activityType: String, location: Coord, @@ -647,6 +668,7 @@ object HouseholdActor { SpaceTime(location, 0), activityType, VehicleManager.getReservedFor(vehicle.vehicleManagerId.get).get, + personId = Option(person), beamVehicle = Option(vehicle), triggerId = triggerId, searchMode = ParkingSearchMode.Init, @@ -671,14 +693,19 @@ object HouseholdActor { } } + object EmergencyHouseholdVehicleGenerator { + private val sharedRandomGenerator = new UniformRealDistributionEnhanced() + } + class EmergencyHouseholdVehicleGenerator( household: Household, beamScenario: BeamScenario, vehiclesAdjustment: VehiclesAdjustment, defaultCategory: VehicleCategory ) extends LazyLogging { - private val realDistribution: UniformRealDistributionEnhanced = new UniformRealDistributionEnhanced() - realDistribution.reseedRandomGenerator(beamScenario.beamConfig.matsim.modules.global.randomSeed) + + private val realDistribution: UniformRealDistributionEnhanced = + EmergencyHouseholdVehicleGenerator.sharedRandomGenerator def sampleVehicleTypeForEmergencyUse( personId: Id[Person], @@ -733,7 +760,9 @@ object HouseholdActor { manager: ActorRef ): BeamVehicle = { val vehicleManagerId = - VehicleManager.createOrGetReservedFor(household.getId.toString, VehicleManager.TypeEnum.Household).managerId + VehicleManager + .createOrGetReservedFor(household.getId.toString, Some(VehicleManager.TypeEnum.Household)) + .managerId val vehicle = new BeamVehicle( Id.createVehicleId(personId.toString + "-emergency-" + vehicleIndex), new Powertrain(vehicleType.primaryFuelConsumptionInJoulePerMeter), @@ -750,7 +779,7 @@ object HouseholdActor { } } - case class HomeAndStartingWorkLocation( + case class ActivityTypeAndLocation( parkingActivityType: ParkingActivityType, activityType: String, activityLocation: Coord, diff --git a/src/main/scala/beam/agentsim/agents/household/HouseholdFleetManager.scala b/src/main/scala/beam/agentsim/agents/household/HouseholdFleetManager.scala index f4fcc1abce3..951fa1a10c7 100644 --- a/src/main/scala/beam/agentsim/agents/household/HouseholdFleetManager.scala +++ b/src/main/scala/beam/agentsim/agents/household/HouseholdFleetManager.scala @@ -36,9 +36,10 @@ class HouseholdFleetManager( parkingManager: ActorRef, chargingNetworkManager: ActorRef, vehicles: Map[Id[BeamVehicle], BeamVehicle], - homeAndStartingWorkLocations: Map[Id[Person], HomeAndStartingWorkLocation], + householdMembersToActivityTypeAndLocation: Map[Id[Person], ActivityTypeAndLocation], maybeEmergencyHouseholdVehicleGenerator: Option[EmergencyHouseholdVehicleGenerator], whoDrivesThisFreightVehicle: Map[Id[BeamVehicle], Id[Person]], // so far only freight module is using this collection + isFreightCarrier: Boolean, eventsManager: EventsManager, geo: GeoUtils, beamConfig: BeamConfig, @@ -62,6 +63,7 @@ class HouseholdFleetManager( logger.debug(s"ResolvedParkingResponses ($triggerId, $xs)") xs.foreach { case (id, resp) => val veh = vehiclesInternal(id) + val person = trackingVehicleAssignmentAtInitialization(id) veh.setManager(Some(self)) veh.spaceTime = SpaceTime(resp.stall.locationUTM.getX, resp.stall.locationUTM.getY, 0) veh.setMustBeDrivenHome(false) @@ -71,7 +73,7 @@ class HouseholdFleetManager( stall = resp.stall, locationWGS = geo.utm2Wgs(resp.stall.locationUTM), vehicleId = id, - driverId = "None" + driverId = person.toString ) eventsManager.processEvent(parkEvent) if (resp.stall.chargingPointType.isDefined) { @@ -95,22 +97,44 @@ class HouseholdFleetManager( val listOfFutures: List[Future[(Id[BeamVehicle], ParkingInquiryResponse)]] = { // Request that all household vehicles be parked at the home coordinate. If the vehicle is an EV, // send the request to the charging manager. Otherwise send request to the parking manager. - val workingPersonsList = - homeAndStartingWorkLocations.filter(_._2.parkingActivityType == ParkingActivityType.Work).keys.toBuffer + val workingPersonsList = householdMembersToActivityTypeAndLocation + .filter(_._2.parkingActivityType == ParkingActivityType.Work) + .keys + .toBuffer vehicles.toList.map { case (id, vehicle) => - val personId: Id[Person] = - if (workingPersonsList.nonEmpty) workingPersonsList.remove(0) - else + val personId: Id[Person] = { + if (vehicle.isFreightVehicle) { + homeAndStartingWorkLocations + .find(_._2.parkingActivityType == ParkingActivityType.Freight) + .map(_._1) + .getOrElse { + homeAndStartingWorkLocations.foreach { case (personId, location) => + println(s"Person ID: $personId") + println(s" Parking Activity Type: ${location.parkingActivityType}") + println(s" Activity Type: ${location.activityType}") + println(s" Activity Location: ${location.activityLocation}") + println(s" Activity End Time: ${location.activityEndTime}") + println("---") + } + throw new RuntimeException( + s"Freight vehicle ${vehicle.id} has no assigned person with Freight parking activity" + ) + } + } else if (workingPersonsList.isEmpty) { homeAndStartingWorkLocations .find(_._2.parkingActivityType == ParkingActivityType.Home) .map(_._1) - .getOrElse(homeAndStartingWorkLocations.keys.head) + .getOrElse(householdMembersToActivityTypeAndLocation.keys.head) +} else workingPersonsList.remove(0) + } trackingVehicleAssignmentAtInitialization.put(vehicle.id, personId) - val HomeAndStartingWorkLocation(_, activityType, location, endTime) = homeAndStartingWorkLocations(personId) + val ActivityTypeAndLocation(_, activityType, location, endTime) = + householdMembersToActivityTypeAndLocation(personId) val inquiry = ParkingInquiry.init( SpaceTime(location, 0), activityType, VehicleManager.getReservedFor(vehicle.vehicleManagerId.get).get, + personId = Option(personId), beamVehicle = Option(vehicle), triggerId = triggerId, searchMode = ParkingSearchMode.Init, @@ -170,7 +194,7 @@ class HouseholdFleetManager( case inquiry @ MobilityStatusInquiry(personId, _, _, requireVehicleCategoryAvailable, triggerId) => val availableVehicleMaybe: Option[BeamVehicle] = requireVehicleCategoryAvailable match { - case Some(_) if personId.toString.startsWith(FreightReader.FREIGHT_ID_PREFIX) => + case Some(_) if personId.toString.startsWith(FreightReader.CARRIER_ID_PREFIX) => whoDrivesThisFreightVehicle .filter(_._2 == personId) .flatMap { case (vehicleId, _) => availableVehicles.find(_.id == vehicleId) } @@ -193,7 +217,7 @@ class HouseholdFleetManager( requireVehicleCategoryAvailable match { case Some(requiredType) if vehicles.values.exists(_.beamVehicleType.vehicleCategory == requiredType) => logger.warn(s"Emergency vehicle generation for type $requiredType failed") - case Some(requiredType) => + case Some(_) => logger.debug(s"Ignoring vehicle request because it isn't for the right category") case None => } @@ -248,9 +272,15 @@ class HouseholdFleetManager( // Pipe my car through the parking manager // and complete initialization only when I got them all. + val reservedFor = VehicleManager.getReservedFor(vehicle.vehicleManagerId.get()).get + val activityType = if (reservedFor.managerType == VehicleManager.TypeEnum.Freight) { + ParkingActivityType.Freight.toString + } else { + ParkingActivityType.Wherever.toString + } val responseFuture = parkingManager ? ParkingInquiry.init( inquiry.whereWhen, - "wherever", + activityType, VehicleManager.getReservedFor(vehicle.vehicleManagerId.get()).get, Some(vehicle), triggerId = inquiry.triggerId, diff --git a/src/main/scala/beam/agentsim/agents/modalbehaviors/ChoosesMode.scala b/src/main/scala/beam/agentsim/agents/modalbehaviors/ChoosesMode.scala index aafb8207abf..e50b0e42823 100644 --- a/src/main/scala/beam/agentsim/agents/modalbehaviors/ChoosesMode.scala +++ b/src/main/scala/beam/agentsim/agents/modalbehaviors/ChoosesMode.scala @@ -5,7 +5,12 @@ import akka.pattern.pipe import beam.agentsim.agents.BeamAgent._ import beam.agentsim.agents.PersonAgent._ import beam.agentsim.agents._ -import beam.agentsim.agents.household.HouseholdActor.{MobilityStatusInquiry, MobilityStatusResponse, ReleaseVehicle} +import beam.agentsim.agents.household.HouseholdActor.{ + MobilityStatusInquiry, + MobilityStatusResponse, + ReleaseVehicle, + RetryModeChoice +} import beam.agentsim.agents.modalbehaviors.ChoosesMode._ import beam.agentsim.agents.modalbehaviors.DrivesVehicle.{ActualVehicle, Token, VehicleOrToken} import beam.agentsim.agents.planning.Strategy.{TourModeChoiceStrategy, TripModeChoiceStrategy} @@ -207,6 +212,12 @@ trait ChoosesMode { case (data: ChoosesModeData, Some(BIKE_TRANSIT | DRIVE_TRANSIT), Some(WALK_BASED)) if data.personData.currentTourPersonalVehicle.isDefined => val currentTourPersonalVehicleId = data.personData.currentTourPersonalVehicle.get + if (data.isWithinTripReplanning) { + logger.debug( + s"Person ${this.id} is within trip replanning. " + + s"Current tour personal vehicle id: $currentTourPersonalVehicleId" + ) + } if (beamVehicles.contains(currentTourPersonalVehicleId)) { self ! MobilityStatusResponse( Vector(beamVehicles(currentTourPersonalVehicleId)), @@ -325,6 +336,16 @@ trait ChoosesMode { } } + /** + * Sends a request to the given vehicle fleets to determine the availability of vehicles at a specific location and activity. + * An optional vehicle category can be specified to filter the results. + * + * @param vehicleFleets the list of vehicle fleet actor references to query for available vehicles + * @param location the location and time for which to check vehicle availability + * @param activity the activity associated with the request, which may influence vehicle availability + * @param requireVehicleCategoryAvailable an optional vehicle category to filter available vehicles; if specified, only vehicles of this category will be included + * @return a Future containing a MobilityStatusResponse that includes a collection of available vehicles and a trigger ID + */ private def requestAvailableVehicles( vehicleFleets: Seq[ActorRef], location: SpaceTime, @@ -373,6 +394,14 @@ trait ChoosesMode { var currentTripMode = (currentTripStrategy.mode, personData.currentTripMode) match { case (None, None) => None + case (Some(strategyMode @ (DRIVE_TRANSIT | BIKE_TRANSIT | RIDE_HAIL_TRANSIT)), None) + if choosesModeData.isWithinTripReplanning => + logger.debug( + s"Keeping my _experiencedBeamPlan mode as $strategyMode and ChoosesModeData " + + "as WALK_TRANSIT because I missed my initial transit leg but want to keep my vehicle, my input chooses mode" + + "trip mode was set to None" + ) + Some(WALK_TRANSIT) case (Some(strategyMode), None) => Some(strategyMode) case (Some(strategyMode), Some(dataMode)) if strategyMode == dataMode => @@ -382,16 +411,17 @@ trait ChoosesMode { TripModeChoiceStrategy(Some(dataMode)) _experiencedBeamPlan.putStrategy(_experiencedBeamPlan.getTripContaining(nextAct), updatedTripStrategy) Some(dataMode) - case (Some(DRIVE_TRANSIT), Some(WALK_TRANSIT)) if choosesModeData.isWithinTripReplanning => - logger.debug( - "Keeping my _experiencedBeamPlan mode as DRIVE_TRANSIT and ChoosesModeData" + + case (Some(mode @ (DRIVE_TRANSIT | BIKE_TRANSIT | RIDE_HAIL_TRANSIT)), Some(WALK_TRANSIT)) + if choosesModeData.isWithinTripReplanning => + logger.warn( + f"Keeping my _experiencedBeamPlan mode as $mode and ChoosesModeData" + "as WALK_TRANSIT because I missed my initial transit leg but want to keep my vehicle" ) Some(WALK_TRANSIT) - case (Some(BIKE_TRANSIT), Some(WALK_TRANSIT)) if choosesModeData.isWithinTripReplanning => - logger.debug( - "Keeping my _experiencedBeamPlan mode as BIKE_TRANSIT and ChoosesModeData" + - "as WALK_TRANSIT because I missed my initial transit leg but want to keep my vehicle" + case (Some(WALK_TRANSIT), Some(DRIVE_TRANSIT)) if choosesModeData.isWithinTripReplanning => + logger.warn( + "Keeping my _experiencedBeamPlan mode as WALK_TRANSIT and ChoosesModeData" + + s"as DRIVE_TRANSIT, even though I don't know why. Full personData: $personData " ) Some(WALK_TRANSIT) case _ => @@ -432,18 +462,29 @@ trait ChoosesMode { case (None, Some(ps)) if ps.tourMode.contains(WALK_BASED) => Vector() case _ => - personData.currentTourPersonalVehicle.map(vehId => beamVehicles(vehId)).toVector + personData.currentTourPersonalVehicle + .flatMap(vehId => { + beamVehicles.get(vehId) match { + case Some(vehicle) => Some(vehicle) + case None => + logger.error(s"Vehicle with ID $vehId from currentTourPersonalVehicle not found in beamVehicles map") + //throw new NoSuchElementException(s"Vehicle ID $vehId not found") + None + } + }) + .toVector } availablePersonalStreetVehicles ++= availableVehicleFromParentTour val availableEmergencyVehicles = beamVehicles.filterKeys(k => k.toString.startsWith(f"${this.id.toString}-emergency")).values.toVector -// val otherNewAndTourVehicles = -// filterAvailableVehicles(availablePersonalStreetVehicles ++ availableEmergencyVehicles, currentTourStrategy) + // val otherNewAndTourVehicles = + // filterAvailableVehicles(availablePersonalStreetVehicles ++ availableEmergencyVehicles, currentTourStrategy) val otherNewAndTourVehicles = filterAvailableVehicles( availablePersonalStreetVehicles ++ availableEmergencyVehicles, - currentTourStrategy + currentTourStrategy, + parentTourStrategy.nonEmpty ).distinct val availableModesGivenTourMode = getAvailableModesGivenTourMode( @@ -472,10 +513,6 @@ trait ChoosesMode { triggerId ) - // Note that remainingAvailableVehicles includes all vehicles that were available, - // and any unused vehicles will be released. - // That's why we remove any drive_transit vehicles after - // replanning -- so they don't get released. val newPersonData = choosesModeData.copy( personData = personData .copy( @@ -561,15 +598,23 @@ trait ChoosesMode { // by R5. These don't necessarily have correct wait times, but R5 has been updated to give them appropriate costs. // Once we've chosen the best itinerary we can send requests to the RHM to fill in true costs and wait times - val rhTransitTrip = modeChoiceCalculator( - theRouterResult.itineraries.filter(_.tripClassifier == RIDE_HAIL_TRANSIT).toIndexedSeq, - matsimPlan.getPerson.getCustomAttributes - .get("beam-attributes") - .asInstanceOf[AttributesOfIndividual], - nextActivity(choosesModeData.personData), - Some(currentActivity(choosesModeData.personData)), - Some(matsimPlan.getPerson) - ) + // val rhTransitTrip = modeChoiceCalculator( + // theRouterResult.itineraries.filter(_.tripClassifier == RIDE_HAIL_TRANSIT).toIndexedSeq, + // matsimPlan.getPerson.getCustomAttributes + // .get("beam-attributes") + // .asInstanceOf[AttributesOfIndividual], + // nextActivity(choosesModeData.personData), + // Some(currentActivity(choosesModeData.personData)), + // Some(matsimPlan.getPerson) + // ) + + val rhTransitTrip = theRouterResult.itineraries + .filter(trip => + (trip.tripClassifier == RIDE_HAIL_TRANSIT) && (trip.legs.head.beamLeg.startTime > (_currentTick.get + 300)) + ) match { + case Seq() => None + case x => Some(x.minBy(_.totalTravelTimeInSecs)) + } // If there's a drive-transit trip AND we don't have an error RH2Tr response (due to no desire to use RH) then seek RH on access and egress val newPersonData = @@ -580,11 +625,11 @@ trait ChoosesMode { ) ) { val accessSegment = - rhTransitTrip.get.legs.view + rhTransitTrip.get.legs .takeWhile(!_.beamLeg.mode.isMassTransit) .map(_.beamLeg) val egressSegment = - rhTransitTrip.get.legs.view.reverse.takeWhile(!_.beamLeg.mode.isTransit).reverse.map(_.beamLeg) + rhTransitTrip.get.legs.reverse.takeWhile(!_.beamLeg.mode.isTransit).reverse.map(_.beamLeg) val (accessId, accessResult) = if ( (accessSegment.map(_.travelPath.distanceInM).sum > 0) & accessSegment @@ -751,6 +796,12 @@ trait ChoosesMode { (choosesModeData.parkingRequestIds(parkingInquiryResponse.requestId) -> parkingInquiryResponse) ) stay using newPersonData + case Event(_: RetryModeChoice, choosesModeData: ChoosesModeData) => + val newPersonData = choosesModeData.copy( + routingFinished = true, + parkingRequestIds = Map.empty // Clear pending parking requests + ) + stay using newPersonData case Event(cavTripLegsResponse: CavTripLegsResponse, choosesModeData: ChoosesModeData) => stay using choosesModeData.copy(cavTripLegs = Some(cavTripLegsResponse)) //handling response with the shared vehicle nearby the egress legs @@ -813,24 +864,13 @@ trait ChoosesMode { ) } using completeChoiceIfReady) - private def correctCurrentTripModeAccordingToRules( - currentTripMode: Option[BeamMode], - personData: BasePersonData, - availableModes: Seq[BeamMode] - ): Option[BeamMode] = { - val replanningIsAvailable = - personData.numberOfReplanningAttempts < beamServices.beamConfig.beam.agentsim.agents.modalBehaviors.maximumNumberOfReplanningAttempts - currentTripMode match { - case Some(mode @ (HOV2_TELEPORTATION | HOV3_TELEPORTATION)) - if availableModes.contains(CAR) && replanningIsAvailable => - Some(mode) - case Some(mode) if availableModes.contains(mode) && replanningIsAvailable => Some(mode) - case Some(mode) if availableModes.contains(mode) => Some(WALK) - case None if !replanningIsAvailable => Some(WALK) - case _ => None - } - } - + /** + * Generates a sequence of parking inquiries for vehicles in the given itineraries, based on the + * chosen mode data and parking behavior of the vehicles. It checks which vehicles have already + * been requested for parking and creates inquiries for the remaining vehicles. + * + * @param choosesModeData Data related to the mode choice of the person, including parking + */ private def makeParkingInquiries( choosesModeData: ChoosesModeData, itineraries: Seq[EmbodiedBeamTrip] @@ -1049,6 +1089,19 @@ trait ChoosesMode { case object FinishingModeChoice extends BeamAgentState + /** + * Creates a sequence of ride-hail to transit itineraries based on the provided results for + * ride-hail access, ride-hail egress, and a drive transit trip. + * + * @param rideHail2TransitAccessResult the result of the ride-hail-to-transit access leg request, + * containing ride-hail vehicle options and associated data + * @param rideHail2TransitEgressResult the result of the ride-hail-to-transit egress leg request, + * containing ride-hail vehicle options and associated data + * @param driveTransitTrip the returned drive transit trip that will be turned into a + * ridehail transit trip + * @return a vector of possible ride-hail to transit itineraries as embodied trips; returns an empty + * vector if an itinerary cannot be generated + */ private def createRideHail2TransitItin( rideHail2TransitAccessResult: RideHailResponse, rideHail2TransitEgressResult: RideHailResponse, @@ -1093,29 +1146,43 @@ trait ChoosesMode { } else Vector.empty[EmbodiedBeamTrip] } + /** + * Creates a ride-hail transit trip by combining a drive-transit trip, ride-hail access legs, + * and ride-hail egress legs, while adjusting for timing constraints and extra wait times. + * + * @param driveTransitTrip the original drive-transit trip composed of a sequence of legs + * @param tncAccessLeg the sequence of ride-hail access legs used to reach the transit + * @param timeToCustomer time required for the ride-hail vehicle to reach the customer + * @param tncEgressLeg the sequence of ride-hail egress legs used after the transit + * @return an optional ride-hail transit trip combining the input components if timing constraints are satisfied, + * or None if the trip cannot be created due to excessive wait time + */ private def createRideHailTransitTrip( driveTransitTrip: EmbodiedBeamTrip, tncAccessLeg: Vector[EmbodiedBeamLeg], timeToCustomer: Int, tncEgressLeg: Vector[EmbodiedBeamLeg] ): Option[EmbodiedBeamTrip] = { - val transitLegs = driveTransitTrip.legs + val transitLegs = driveTransitTrip.legs.view .dropWhile(leg => !leg.beamLeg.mode.isTransit) .reverse .dropWhile(leg => !leg.beamLeg.mode.isTransit) + .reverse val (extraWaitTimeBuffer, accessLegAdjustment) = tncAccessLeg.filter(_.isRideHail) match { case Vector() => (Int.MaxValue, 0) case rhLegs => + val latenessToFirstTransitLeg = tncAccessLeg.last.beamLeg.endTime - transitLegs.head.beamLeg.startTime max 0 + val startTimeBufferForWaiting = + 300.0 + timeToCustomer.toDouble * 0.25 + latenessToFirstTransitLeg.toDouble val extraWaitTimeBuffer = rhLegs.last.beamLeg.endTime - - tncAccessLeg.map(_.beamLeg.duration).sum - timeToCustomer - _currentTick.get - val startTimeBufferForWaiting = math.max(300.0, timeToCustomer.toDouble * 0.5) - (extraWaitTimeBuffer, startTimeBufferForWaiting.floor.toInt) + tncAccessLeg.map(_.beamLeg.duration).sum - timeToCustomer - _currentTick.get - startTimeBufferForWaiting + (extraWaitTimeBuffer.floor.toInt, startTimeBufferForWaiting.floor.toInt) } - if (extraWaitTimeBuffer >= 300) { + if (extraWaitTimeBuffer > 0) { Some( - EmbodiedBeamTrip( + surroundWithWalkLegsIfNeededAndMakeTrip( Vector( tncAccessLeg.head.copy(beamLeg = tncAccessLeg.head.beamLeg.updateStartTime(tncAccessLeg.head.beamLeg.startTime - accessLegAdjustment) @@ -1172,9 +1239,18 @@ trait ChoosesMode { } } + /** + * Filters the available vehicles based on the current tour strategy. + * Only includes vehicles that align with the conditions defined by the method logic. + * + * @param allAvailableStreetVehicles A vector containing all street vehicles currently available. + * @param currentTourStrategy The strategy object representing the current tour mode and vehicle preferences. + * @return A vector of filtered vehicles or tokens meeting the specified conditions. + */ private def filterAvailableVehicles( allAvailableStreetVehicles: Vector[VehicleOrToken], - currentTourStrategy: TourModeChoiceStrategy + currentTourStrategy: TourModeChoiceStrategy, + onSubTour: Boolean = false ): Vector[VehicleOrToken] = { val tourVehicle = currentTourStrategy.tourVehicle val tourMode = currentTourStrategy.tourMode @@ -1188,7 +1264,8 @@ trait ChoosesMode { case ActualVehicle(beamVehicle) if tourVehicle.contains(beamVehicle.id) => Some(ActualVehicle(beamVehicle)) case ActualVehicle(beamVehicle) if BeamVehicle.isSharedTeleportationVehicle(beamVehicle.id) => Some(ActualVehicle(beamVehicle)) - case ActualVehicle(beamVehicle) if tourVehicle.isEmpty && tourMode.isDefined && beamVehicle.isMustBeDrivenHome => + case ActualVehicle(beamVehicle) + if tourVehicle.isEmpty && tourMode.isDefined && beamVehicle.isMustBeDrivenHome && !onSubTour => logger.debug( s"Person person ${this.id} is already on a walk based tour, and we have access to vehicle " + s" ${beamVehicle.id}, and we're" + @@ -1223,13 +1300,14 @@ trait ChoosesMode { availablePersonalStreetVehicles: Vector[VehicleOrToken], currentTourMode: Option[BeamTourMode], nextActivity: Activity, - maybeTourModeChoiceStrategy: Option[TourModeChoiceStrategy] = None + maybeTourModeChoiceStrategy: Option[TourModeChoiceStrategy] = None, + isSubTour: Boolean = false ): Seq[BeamMode] = { val maybeTourPersonalVehicle = maybeTourModeChoiceStrategy.flatMap(_.tourVehicle) availableModes.intersect(currentTourMode match { case Some(WALK_BASED) if availablePersonalStreetVehicles - .exists(_.vehicle.isMustBeDrivenHome) && isLastTripWithinTour(nextActivity) => + .exists(_.vehicle.isMustBeDrivenHome) && isLastTripWithinTour(nextActivity) && !isSubTour => val requiredEgressModes = availablePersonalStreetVehicles.flatMap { case veh: ActualVehicle => maybeTourPersonalVehicle match { @@ -1257,15 +1335,67 @@ trait ChoosesMode { }) } - def mustBeDrivenHome(vehicle: VehicleOrToken): Boolean = { - vehicle match { - case ActualVehicle(beamVehicle) => - beamVehicle.isMustBeDrivenHome - case _: Token => - false // is not a household vehicle + // Note that remainingAvailableVehicles includes all vehicles that were available, + // and any unused vehicles will be released. + // That's why we remove any drive_transit vehicles after + // replanning -- so they don't get released. + + /** + * Finds the set of modes that were queried based on the routing response, ride hail result, + * and the optional ride hail to transit routing request identifier. + * + * @param routingResponse The response of a routing request, containing the requested modes and details about transit usage. + * @param rideHailResult The result of a ride hail mode request, including whether the request was for pooled or non-pooled ride hail. + * @param rideHail2TransitRoutingRequestId An optional identifier to determine if ride hail to transit was part of the query. + * @return A set of Beam modes that were part of the query, which includes non-ride hail modes, + * direct ride hail modes, and ride hail transit modes. + */ + private def findQueriedModes( + routingResponse: RoutingResponse, + rideHailResult: RideHailResponse, + rideHail2TransitRoutingRequestId: Option[Int] + ): Set[BeamMode] = { + val expectedNonRideHailModes = routingResponse.request match { + case Some(RoutingRequest(_, _, _, withTransit, _, streetVehicles, _, _, _, _, _)) if !withTransit => + streetVehicles.map(_.mode).toSet + case Some(RoutingRequest(_, _, _, true, _, streetVehicles, _, _, _, _, _)) => + streetVehicles + .map(_.mode) + .flatMap { + case CAR => Seq(DRIVE_TRANSIT, CAR) + case BIKE => Seq(BIKE_TRANSIT, BIKE) + case WALK => Seq(WALK_TRANSIT, WALK) + case _ => Seq.empty[BeamMode] + } + .toSet + case _ => Set.empty[BeamMode] + } + val expectedDirectRideHailModes = rideHailResult.request match { + case RideHailRequest(_, _, _, _, _, _, _, _, _, requestTime, _, _, _, _) if requestTime == -1 => + Set.empty[BeamMode] + case RideHailRequest(_, _, _, _, _, asPooled, _, _, _, _, _, _, _, _) if asPooled => + Set(RIDE_HAIL_POOLED) + case RideHailRequest(_, _, _, _, _, _, _, _, _, _, _, _, _, _) => Set(RIDE_HAIL) } + + val expectedRideHailTransitModes = rideHail2TransitRoutingRequestId match { + case Some(_) => Set(RIDE_HAIL_TRANSIT) + case None => Set.empty[BeamMode] + } + + expectedNonRideHailModes ++ expectedDirectRideHailModes ++ expectedRideHailTransitModes } + /** + * Handles the mode and vehicle choice for a person during their current activity in the simulation. + * This function evaluates available transportation options, including ride-hail, walking, and other transit methods, + * based on various criteria such as current location, tour strategy, and vehicle availability. It computes the + * best possible trip options, filters them, and determines the next course of action based on the chosen alternative. + * The method also updates the person's data with the selected trip mode and tour specifics. + * + * @return A transformation of the FSM state, applying the updated mode choice and trip information for the specific person + * if all conditions are met. Only states matching the specified input conditions are handled. + */ private def completeChoiceIfReady: PartialFunction[State, State] = { case FSM.State( _, @@ -1278,7 +1408,7 @@ trait ChoosesMode { parkingResponseIds, Some(rideHailResult), Some(rideHail2TransitRoutingResponse), - _, + rideHail2TransitRoutingRequestId, Some(rideHail2TransitAccessResult), _, Some(rideHail2TransitEgressResult), @@ -1291,7 +1421,8 @@ trait ChoosesMode { _, _, true, - _ + _, + mostRecentFailedBoardingTrip ), _, _, @@ -1323,10 +1454,13 @@ trait ChoosesMode { Vector() } - val combinedItinerariesForChoice = rideHailItinerary ++ addParkingCostToItins( + val combinedItinerariesForChoice = (rideHailItinerary ++ addParkingCostToItins( routingResponse.itineraries, parkingResponses - ) ++ rideHail2TransitIineraries + ) ++ rideHail2TransitIineraries) + .groupBy(t => (t.vehiclesInTrip, t.tripClassifier)) + .map(x => x._2.minBy(_.totalTravelTimeInSecs)) + .toVector def isAvailable(mode: BeamMode): Boolean = combinedItinerariesForChoice.exists(_.tripClassifier == mode) @@ -1338,16 +1472,21 @@ trait ChoosesMode { case _ => } - val newAndTourVehicles = allAvailableStreetVehicles ++ getParentTourStrategy(personData) - .flatMap(_.tourVehicle) - .flatMap(v => beamVehicles.get(v)) - .filterNot(_.vehicle.isSharedVehicle) - .toVector - .groupBy(_.id) - .values - .map(_.head) + val availableParentTourVehicles = getParentTourStrategy(personData) + .flatMap(strategy => + strategy.tourMode match { + case Some(CAR_BASED | BIKE_BASED) => + strategy.tourVehicle + .flatMap(v => beamVehicles.get(v)) + .filterNot(_.vehicle.isSharedVehicle) + case _ => + None // If it's a walk_based tour we assume it was left at a transit stop en_route + } + ) .toVector + val newAndTourVehicles = allAvailableStreetVehicles ++ availableParentTourVehicles + val availableEmergencyVehicles = beamVehicles.filterKeys(k => k.toString.startsWith(f"${this.id.toString}-emergency")).values.toVector @@ -1360,32 +1499,29 @@ trait ChoosesMode { combinedItinerariesForChoice ) + val parentTourStrategy = getParentTourStrategy(personData) + val availableModesForTrips = getAvailableModesGivenTourMode( availableModesForPerson(matsimPlan.getPerson, choosesModeData.excludeModes), newAndTourVehicles, chosenCurrentTourMode, nextAct, - Some(currentTourStrategy) + Some(currentTourStrategy), + parentTourStrategy.nonEmpty ) + if (availableModesForTrips.contains(DRIVE_TRANSIT) && parentTourStrategy.nonEmpty) { + logger.debug("This is a strange situation to be worried about potentially") + } + val filteredItinerariesForChoice = choosesModeData.personData.currentTripMode match { case Some(mode) if mode == DRIVE_TRANSIT || mode == BIKE_TRANSIT => (isFirstOrLastTripWithinTour(nextAct), personData.hasDeparted) match { case (true, false) => combinedItinerariesForChoice.filter(_.tripClassifier == mode) case _ => - combinedItinerariesForChoice.filter(trip => - trip.tripClassifier == WALK_TRANSIT || trip.tripClassifier == RIDE_HAIL_TRANSIT - ) + combinedItinerariesForChoice } - case Some(mode) if mode == WALK_TRANSIT || mode == RIDE_HAIL_TRANSIT => - combinedItinerariesForChoice.filter(trip => - trip.tripClassifier == WALK_TRANSIT || trip.tripClassifier == RIDE_HAIL_TRANSIT - ) - case Some(HOV2_TELEPORTATION) => - combinedItinerariesForChoice.filter(_.tripClassifier == HOV2_TELEPORTATION) - case Some(HOV3_TELEPORTATION) => - combinedItinerariesForChoice.filter(_.tripClassifier == HOV3_TELEPORTATION) case Some(mode) => combinedItinerariesForChoice.filter(_.tripClassifier == mode) case _ => @@ -1398,9 +1534,25 @@ trait ChoosesMode { .filterNot(itin => itin.vehiclesInTrip .filterNot(_.toString.startsWith("body")) - .exists(veh => personData.failedTrips.flatMap(_.vehiclesInTrip).contains(veh)) + .exists(mostRecentFailedBoardingTrip.map(_.beamVehicleId).contains) ) + val currentAct = currentActivity(personData) + + if (beamServices.beamConfig.beam.exchange.output.activity_sim_skimmer.exists(_.primary.enabled)) { + val queriedModes = findQueriedModes(routingResponse, rideHailResult, rideHail2TransitRoutingRequestId) + + // Find modes that were queried but don't have valid itineraries and report failures + queriedModes.diff(combinedItinerariesForChoice.map(_.tripClassifier).toSet) foreach { beamMode => + val possibleActivitySimModes = + determineActivitySimPathTypesFromBeamMode(Some(beamMode), Some(currentAct)) + + createFailedActivitySimSkimmerEvent(currentAct, nextAct, possibleActivitySimModes).foreach(ev => + eventsManager.processEvent(ev) + ) + } + } + val attributesOfIndividual = matsimPlan.getPerson.getCustomAttributes .get("beam-attributes") @@ -1411,16 +1563,21 @@ trait ChoosesMode { goto(FinishingModeChoice) using choosesModeData.copy( personData = personData.copy( currentTourMode = chosenCurrentTourMode, + currentTripMode = Some(chosenTrip.tripClassifier), + passengerSchedule = PassengerSchedule(), + restOfCurrentTrip = List.empty[EmbodiedBeamLeg], currentTourPersonalVehicle = chosenCurrentTourMode match { // if they're on a walk based tour we let them keep access to whatever personal vehicle they used on the // first leg or in a parent tour case Some(WALK_BASED) => choosesModeData.personData.currentTourPersonalVehicle // Otherwise they keep track of the chosen vehicle case _ => - chosenCurrentTourPersonalVehicle.getOrElse( - chosenTrip, - choosesModeData.personData.currentTourPersonalVehicle - ) + chosenCurrentTourPersonalVehicle + .get(chosenTrip) + .flatten // If we're on a subtour and it uses no vehicle, we still pass on any tour vehicle from parent tours + .orElse( + choosesModeData.personData.currentTourPersonalVehicle + ) } ), pendingChosenTrip = Some(chosenTrip), @@ -1428,6 +1585,23 @@ trait ChoosesMode { ) } + if (personData.numberOfReplanningAttempts > 20) { + logger.warn( + s"Agent ${this.id} exceeded 20 replanning attempts at ${choosesModeData.currentLocation}. " + + s"Creating emergency walking trip. State: $choosesModeData" + ) + + val bushwhackingTrip = RoutingWorker.createBushwackingTrip( + choosesModeData.currentLocation.loc, + nextActivity(choosesModeData.personData).get.getCoord, + _currentTick.get, + body.toStreetVehicle, + geo + ) + + gotoFinishingModeChoice(bushwhackingTrip) + } + val currentPlanMode = _experiencedBeamPlan .getStrategy[TripModeChoiceStrategy](_experiencedBeamPlan.getTripContaining(nextAct)) .mode @@ -1440,9 +1614,11 @@ trait ChoosesMode { Some(matsimPlan.getPerson) ) match { case Some(chosenTrip) if !currentPlanMode.contains(CAV) => - filteredItinerariesForChoice.foreach { + // Send non-chosen trips to skimmer if configured to do so + combinedItinerariesForChoice.foreach { case possibleTrip - if (possibleTrip != chosenTrip) && beamScenario.beamConfig.beam.router.skim.sendNonChosenTripsToSkimmer => + if (possibleTrip != chosenTrip) && beamScenario.beamConfig.beam.router.skim.sendNonChosenTripsToSkimmer && !choosesModeData.personData.currentTourMode + .contains(FREIGHT_TOUR) => generateSkimData( possibleTrip.legs.lastOption.map(_.beamLeg.endTime).getOrElse(_currentTick.get), possibleTrip, @@ -1469,14 +1645,32 @@ trait ChoosesMode { choosesModeData.copy( personData = personData.copy( currentTourMode = chosenCurrentTourMode, + currentTripMode = Some(chosenTrip.tripClassifier), currentTourPersonalVehicle = chosenCurrentTourPersonalVehicle - .getOrElse(chosenTrip, personData.currentTourPersonalVehicle) + .get(chosenTrip) + .flatten // If we're on a subtour and it uses no vehicle, we still pass on any tour vehicle from parent tours + .orElse(personData.currentTourPersonalVehicle) ), pendingChosenTrip = Some(chosenTrip), availableAlternatives = availableAlts ) goto(FinishingModeChoice) using dataForNextStep case None => + if (!choosesModeData.personData.currentTourMode.contains(FREIGHT_TOUR)) { + combinedItinerariesForChoice.foreach { possibleTrip => + logger.debug( + f"Sending trip ${possibleTrip} to skimmer because it didn't match required mode ${currentPlanMode}" + ) + generateSkimData( + routingResponse.request.map(_.departureTime).getOrElse(_currentTick.get), + possibleTrip, + failedTrip = false, + personData.currentActivityIndex, + currentActivity(personData), + nextActivity(personData) + ) + } + } choosesModeData.personData.currentTripMode match { case Some(CAV) => // Special case, if you are using household CAV, no choice was necessary you just use this mode @@ -1553,43 +1747,139 @@ trait ChoosesMode { personData.copy(currentTourPersonalVehicle = None) ) case Some(mode) => - val correctedTripMode = correctCurrentTripModeAccordingToRules(None, personData, availableModesForTrips) - if (correctedTripMode != personData.currentTripMode) { - val nextActLoc = nextActivity(choosesModeData.personData).get.getCoord - val currentAct = currentActivity(personData) - val odFailedSkimmerEvent = createFailedODSkimmerEvent(currentAct, nextAct, mode) - eventsManager.processEvent( - odFailedSkimmerEvent - ) - if (beamServices.beamConfig.beam.exchange.output.activity_sim_skimmer.exists(_.primary.enabled)) { - val possibleActivitySimModes = - determineActivitySimPathTypesFromBeamMode( - choosesModeData.personData.currentTripMode, - Some(currentAct) - ) - createFailedActivitySimSkimmerEvent(currentAct, nextAct, possibleActivitySimModes).foreach(ev => - eventsManager.processEvent(ev) + val odFailedSkimmerEvent = createFailedODSkimmerEvent(currentAct, nextAct, mode) + eventsManager.processEvent(odFailedSkimmerEvent) + + // Generate activity sim failure events if enabled + if (beamServices.beamConfig.beam.exchange.output.activity_sim_skimmer.exists(_.primary.enabled)) { + val possibleActivitySimModes = + determineActivitySimPathTypesFromBeamMode( + choosesModeData.personData.currentTripMode, + Some(currentAct) ) - } - eventsManager.processEvent( - new ReplanningEvent( - _currentTick.get, - Id.createPersonId(id), - getReplanningReasonFrom( - choosesModeData.personData, - ReservationErrorCode.RouteNotAvailableForChosenMode.entryName - ), - choosesModeData.currentLocation.loc.getX, - choosesModeData.currentLocation.loc.getY, - nextActLoc.getX, - nextActLoc.getY + createFailedActivitySimSkimmerEvent(currentAct, nextAct, possibleActivitySimModes).foreach(ev => + eventsManager.processEvent(ev) + ) + } + createAndProcessModeChoiceEvent(None, _currentTick.get, choosesModeData) + + // Create replanning event + eventsManager.processEvent( + new ReplanningEvent( + _currentTick.get, + Id.createPersonId(id), + getReplanningReasonFrom( + choosesModeData.personData, + ReservationErrorCode.RouteNotAvailableForChosenMode.entryName + ), + choosesModeData.currentLocation.loc.getX, + choosesModeData.currentLocation.loc.getY, + nextAct.getCoord.getX, + nextAct.getCoord.getY + ) + ) + + if ( + isFirstTripWithinTour( + currentActivity(choosesModeData.personData) + ) && !choosesModeData.isWithinTripReplanning + ) { + logger.debug("Resetting tour mode to none because we haven't left yet") + updateTourModeStrategy( + None, + None, + nextActivity(choosesModeData.personData).get, + choosesModeData.allAvailableStreetVehicles + ) + } + + // Available vehicles filtering for replanning + val availableVehicles = + if (mode.isTeleportation) + // Remove teleportation vehicle since we can't use it for non-teleportation mode + choosesModeData.allAvailableStreetVehicles.filterNot(vehicle => + BeamVehicle.isSharedTeleportationVehicle(vehicle.id) ) - ) //give another chance to make a choice without predefined mode - //TODO: Do we need to do anything with tour mode here? - gotoChoosingModeWithoutPredefinedMode(choosesModeData) + else choosesModeData.allAvailableStreetVehicles + + // If we've done a comprehensive routing query, we can reuse results without more routing + if ( + choosesModeData.routingResponse.exists( + _.request.exists(_.withTransit) + ) && choosesModeData.rideHail2TransitRoutingRequestId.nonEmpty && !choosesModeData.isWithinTripReplanning && personData.numberOfReplanningAttempts == 0 + ) { + self ! RetryModeChoice(getCurrentTriggerId.get) + val updatedTripStrategy = TripModeChoiceStrategy(None) + _experiencedBeamPlan.putStrategy( + _experiencedBeamPlan.getTripContaining(nextActivity(choosesModeData.personData).get), + updatedTripStrategy + ) + + stay() using choosesModeData.copy( + personData = personData.copy( + currentTripMode = None, + numberOfReplanningAttempts = personData.numberOfReplanningAttempts + 1 + ), + allAvailableStreetVehicles = availableVehicles, + routingFinished = true, + excludeModes = choosesModeData.excludeModes ++ choosesModeData.personData.currentTripMode + ) } else { - val expensiveWalkTrip = createExpensiveWalkTrip(currentPersonLocation, nextAct, routingResponse) - gotoFinishingModeChoice(expensiveWalkTrip) + val (updatedVehicles, currentTourVehicle) = + if ( + (mode == DRIVE_TRANSIT || mode == BIKE_TRANSIT) && (isLastTripWithinTour( + nextAct + ) || personData.numberOfReplanningAttempts > 5) && personData.currentTourPersonalVehicle.isDefined + ) { + // Abandon the vehicle because we have no route to get it home + val vehicleId = personData.currentTourPersonalVehicle.get + logger.warn( + s"Agent ${this.id} is abandoning vehicle $vehicleId after ${personData.numberOfReplanningAttempts + 1} " + + s"failed attempts to find a route to take it home on a ${mode.toString} trip." + ) + + val remainingVehicles = availableVehicles.filterNot(v => v.id == vehicleId) + updateTourModeStrategy( + currentTourStrategy.tourMode, + None, + nextActivity(choosesModeData.personData).get, + remainingVehicles + ) + // Release the vehicle + if (beamVehicles.contains(vehicleId)) { + val vehicle = beamVehicles(vehicleId).vehicle + vehicle.setMustBeDrivenHome(false) + vehicle.unsetDriver() + beamVehicles.remove(vehicleId) + } + (remainingVehicles, None) + } else { + (availableVehicles, personData.currentTourPersonalVehicle) + } + // Need to gather more routing options + self ! MobilityStatusResponse(availableVehicles, getCurrentTriggerId.get) + logger.debug( + "Person {} replanning because planned mode {} not available", + body.id, + mode.toString + ) + val updatedTripStrategy = TripModeChoiceStrategy(None) + _experiencedBeamPlan.putStrategy( + _experiencedBeamPlan.getTripContaining(nextActivity(choosesModeData.personData).get), + updatedTripStrategy + ) + stay() using ChoosesModeData( + personData = personData.copy( + currentTripMode = None, + numberOfReplanningAttempts = personData.numberOfReplanningAttempts + 1, + currentTourPersonalVehicle = currentTourVehicle + ), + allAvailableStreetVehicles = updatedVehicles, + currentLocation = choosesModeData.currentLocation, + excludeModes = choosesModeData.excludeModes ++ choosesModeData.personData.currentTripMode, + parkingRequestIds = Map.empty, // Clear any pending parking requests + mostRecentDeniedBoardingLeg = choosesModeData.mostRecentDeniedBoardingLeg + ) } case _ => // Bad things happen but we want them to continue their day, so we signal to downstream that trip should be made to be expensive @@ -1677,99 +1967,26 @@ trait ChoosesMode { .legs .head } - val expensiveWalkTrip = EmbodiedBeamTrip( - Vector(originalWalkTripLeg.copy(replanningPenalty = 10.0)) - ) - expensiveWalkTrip - } - - private def gotoChoosingModeWithoutPredefinedMode(choosesModeData: ChoosesModeData) = { - // TODO: Check modes for subsequent trips here - val onFirstTripWithinTour: Boolean = isFirstTripWithinTour(currentActivity(choosesModeData.personData)) - val withinReplanning: Boolean = choosesModeData.isWithinTripReplanning - val agentStillAtTourOrigin: Boolean = onFirstTripWithinTour && !withinReplanning - val outcomeTourMode = if (agentStillAtTourOrigin) { None } - else { Some(WALK_BASED) } - val parentTourVehicle = getParentTourStrategy(choosesModeData.personData).flatMap(_.tourVehicle) - val isAccessEgressInTour: Boolean = choosesModeData.personData.currentTourMode.contains(WALK_BASED) - val newTourVehicle = choosesModeData.personData.currentTourPersonalVehicle match { - case Some(id) if beamVehicles.contains(id) => - if (isAccessEgressInTour && !agentStillAtTourOrigin) { - /* - * This code block only runs when someone needs to re-plan and re-do mode choice. - * If for instance they were going to take a bike trip but no bike route was available - * they need to release the bike so others can use it. - * But if they're in the middle of a tour and just can't find a transit route, - * for instance, but they took drive_transit on their first leg and need to take it home, - * we keep the original vehicle in beamVehicles so we can use it later - * - * The problem is that when someone gets a resourceCapacityExhausted error on the first leg of a drive_transit tour, - * the existing logic thinks that we're in the first scenario (didn't use a vehicle so we can release it) - * rather than the second one (have already used a vehicle and need to return to it at the end of our tour). - * - * For that matter, we are adding "choosesModeData.isWithinTripReplanning". As long as we are still replanning - * we don't release the vehicle until their last tour trip of their tour. - * - * e.g., they'll just get on the next train, go about their drive_transit tour, and - * then take drive_transit as the mode for the last leg of their tour and pick up their car on the way home - * */ - Some(id) - } else if (parentTourVehicle.isEmpty) { - val vehicle = beamVehicles(id).vehicle - vehicle.setMustBeDrivenHome(false) - beamVehicles.remove(vehicle.id) - vehicle.getManager.get ! ReleaseVehicle(vehicle, getCurrentTriggerId.get) - if (!agentStillAtTourOrigin) { - logger.warn( - s"Abandoning vehicle $id because no return ${choosesModeData.personData.currentTripMode} " + - s"itinerary is available" - ) - } else { - logger.debug( - s"Not keeping vehicle $id because no ${choosesModeData.personData.currentTripMode} " + - s"is available" - ) - } - None - } else { - parentTourVehicle - } - case _ => None - } + val minDuration = + if (originalWalkTripLeg.beamLeg.duration < beamServices.beamConfig.beam.agentsim.schedulerParallelismWindow) { + logger.info( + s"Agent ${this.id}'s walk trip duration ${originalWalkTripLeg.beamLeg.duration} is less than the minimum " + + s"of ${beamServices.beamConfig.beam.agentsim.schedulerParallelismWindow}. Setting it to the minimum." + ) + beamServices.beamConfig.beam.agentsim.schedulerParallelismWindow + } else { + originalWalkTripLeg.beamLeg.duration + } - if (choosesModeData.personData.currentTripMode.get.isTeleportation) { - //we need to remove our teleportation vehicle since we cannot use it if it's not a teleportation mode { - val availableVehicles = choosesModeData.allAvailableStreetVehicles.filterNot(vehicle => - BeamVehicle.isSharedTeleportationVehicle(vehicle.id) - ) - self ! MobilityStatusResponse(availableVehicles, getCurrentTriggerId.get) - stay() - } else { - val updatedTripStrategy = TripModeChoiceStrategy(None) - _experiencedBeamPlan.putStrategy( - _experiencedBeamPlan.getTripContaining(nextActivity(choosesModeData.personData).get), - updatedTripStrategy - ) - updateTourModeStrategy( - outcomeTourMode, - newTourVehicle, - nextActivity(choosesModeData.personData).get, - choosesModeData.allAvailableStreetVehicles + val expensiveWalkTrip = EmbodiedBeamTrip( + Vector( + originalWalkTripLeg.copy( + replanningPenalty = 10.0, + beamLeg = originalWalkTripLeg.beamLeg.scaleToNewDuration(minDuration) + ) ) - goto(ChoosingMode) - } using choosesModeData.copy( - personData = choosesModeData.personData.copy( - currentTripMode = None, - currentTourMode = outcomeTourMode, - currentTrip = None, - restOfCurrentTrip = List.empty, - currentTourPersonalVehicle = newTourVehicle, - numberOfReplanningAttempts = choosesModeData.personData.numberOfReplanningAttempts + 1 - ), - currentLocation = choosesModeData.currentLocation, - excludeModes = choosesModeData.excludeModes ++ choosesModeData.personData.currentTripMode ) - + expensiveWalkTrip } /** @@ -1938,79 +2155,12 @@ trait ChoosesMode { val chosenTrip = makeFinalCorrections(pendingTrip, tick, correctedActivityEndTime) - // Write start and end links of chosen route into Activities. - // We don't check yet whether the incoming and outgoing routes agree on the link an Activity is on. - // Our aim should be that every transition from a link to another link be accounted for. - val headOpt = chosenTrip.legs.headOption - .flatMap(_.beamLeg.travelPath.linkIds.headOption) - val lastOpt = chosenTrip.legs.lastOption - .flatMap(_.beamLeg.travelPath.linkIds.lastOption) - if (headOpt.isDefined && lastOpt.isDefined) { - _experiencedBeamPlan - .activities(data.personData.currentActivityIndex) - .setLinkId(Id.createLinkId(headOpt.get)) - _experiencedBeamPlan - .activities(data.personData.currentActivityIndex + 1) - .setLinkId(Id.createLinkId(lastOpt.get)) - } else { - val origin = beamServices.geo.utm2Wgs( - _experiencedBeamPlan - .activities(data.personData.currentActivityIndex) - .getCoord - ) - val destination = beamServices.geo.utm2Wgs( - _experiencedBeamPlan - .activities(data.personData.currentActivityIndex + 1) - .getCoord - ) - val linkRadiusMeters = beamScenario.beamConfig.beam.routing.r5.linkRadiusMeters - _experiencedBeamPlan - .activities(data.personData.currentActivityIndex) - .setLinkId( - Id.createLinkId( - beamServices.geo.getNearestR5Edge(transportNetwork.streetLayer, origin, linkRadiusMeters) - ) - ) - _experiencedBeamPlan - .activities(data.personData.currentActivityIndex + 1) - .setLinkId( - Id.createLinkId( - beamServices.geo.getNearestR5Edge(transportNetwork.streetLayer, destination, linkRadiusMeters) - ) - ) - } - - val tripId: String = _experiencedBeamPlan.trips - .lift(data.personData.currentActivityIndex + 1) match { - case Some(trip) => - trip.leg.map(l => Option(l.getAttributes.getAttribute("trip_id")).getOrElse("").toString).getOrElse("") - case None => "" - } + createAndProcessModeChoiceEvent(Some(chosenTrip), tick, data) val destinationActivity = nextActivity(data.personData).get val isFirstTrip = isFirstTripWithinTour(destinationActivity) val isLastTrip = isLastTripWithinTour(destinationActivity) - val initialTourMode = data.personData.currentTourMode - - val modeChoiceEvent = new ModeChoiceEvent( - tick, - id, - chosenTrip.tripClassifier.value, - initialTourMode.map(_.value).getOrElse(""), - data.expectedMaxUtilityOfLatestChoice.getOrElse[Double](Double.NaN), - _experiencedBeamPlan.activities(data.personData.currentActivityIndex).getLinkId.toString, - data.availableAlternatives.get, - data.availablePersonalStreetVehicles.nonEmpty, - chosenTrip.legs.view.map(_.beamLeg.travelPath.distanceInM).sum, - _experiencedBeamPlan.tourIndexOfElement(destinationActivity), - chosenTrip, - _experiencedBeamPlan.activities(data.personData.currentActivityIndex).getType, - destinationActivity.getType, - tripId - ) - eventsManager.processEvent(modeChoiceEvent) - data.personData.currentTripMode match { case Some(mode) if mode.isTeleportation => scheduler ! CompletionNotice( @@ -2048,14 +2198,23 @@ trait ChoosesMode { var isCurrentPersonalVehicleVoided = false vehiclesNotUsed.collect { case ActualVehicle(vehicle) if data.personData.currentTourPersonalVehicle.contains(vehicle.id) => - if ( - data.personData.currentTourMode - .contains(WALK_BASED) && (!isFirstTripWithinTour(destinationActivity) || data.isWithinTripReplanning) - ) { - logger.debug( - s"We're keeping vehicle ${vehicle.id} even though it isn't used in this trip " + - s"because we need it for egress at the end of the tour" - ) + if (data.personData.currentTourMode.contains(WALK_BASED)) { + // Note: Removed this condition: !isFirstTripWithinTour(destinationActivity) + if ( + getCurrentTourStrategy(data.personData).tourVehicle.contains( + vehicle.id + ) || data.isWithinTripReplanning + ) { + logger.debug( + s"Person ${this.id} is keeping vehicle ${vehicle.id} even though it isn't used in this trip " + + s"because we need it for egress at the end of the tour" + ) + } else if (getParentTourStrategy(data.personData).isEmpty) { + logger.warn( + s"Person ${this.id} is keeping vehicle ${vehicle.id} even though it's not stored in our " + + s"tourModeStrategy, which is ${getCurrentTourStrategy(data.personData)}" + ) + } } else if (getParentTourStrategy(data.personData).exists(s => s.tourVehicle.contains(vehicle.id))) { logger.debug( s"We're keeping vehicle ${vehicle.id} even though it isn't used in this trip " + @@ -2064,7 +2223,7 @@ trait ChoosesMode { } else { if (!data.isWithinTripReplanning) { logger.warn( - s"We are going to give up vehicle " + + s"Person ${this.id} is going to give up vehicle " + s"${vehicle.id} because it's not used in our next leg. Perhaps it was created unnecessarily? - $data" ) } @@ -2083,7 +2242,7 @@ trait ChoosesMode { beamVehicles.remove(vehicle.id) vehicle.getManager match { case Some(manager) if BeamVehicle.isEmergencyVehicle(vehicle.id) && !isLastTrip => - logger.debug("Releasing emergency vehicle") + logger.debug(f"Releasing emergency vehicle for person ${this.id}") manager ! ReleaseVehicle(vehicle, triggerId) case Some(manager) => manager ! ReleaseVehicle(vehicle, triggerId) case _ => logger.warn(s"Giving up vehicle ${vehicle.id}, which doesn't have a manager set") @@ -2116,7 +2275,7 @@ trait ChoosesMode { .filter(!_.vehicle.isSharedVehicle) .find { veh => (chosenTrip.tripClassifier, data.personData.currentTourMode) match { - case (_, Some(FREIGHT_TOUR)) => veh.vehicle.isFreightVehicle + case (_, Some(FREIGHT_TOUR)) => veh.vehicle.isFreight case (_, Some(CAR_BASED)) => veh.vehicle.beamVehicleType.vehicleCategory == VehicleCategory.Car case (_, Some(BIKE_BASED)) => veh.vehicle.beamVehicleType.vehicleCategory == VehicleCategory.Bike @@ -2158,12 +2317,22 @@ trait ChoosesMode { ) case Some(strategyMode) if strategyMode == chosenTrip.tripClassifier => case Some(strategyMode @ (DRIVE_TRANSIT | BIKE_TRANSIT | RIDE_HAIL_TRANSIT)) - if (chosenTrip.tripClassifier == WALK_TRANSIT) && data.isWithinTripReplanning => - logger.debug(f"Assigning replanning walk_transit trip as part of planned $strategyMode trip") + if data.isWithinTripReplanning => + if (chosenTrip.tripClassifier != WALK_TRANSIT) { + logger.info( + f"Switching to a ${chosenTrip.tripClassifier} trip after a failed $strategyMode trip after departure" + ) + } else { + logger.debug(f"Assigning replanning walk_transit trip as part of planned $strategyMode trip") + } case Some(otherMode) if currentTourPersonalVehicle.isDefined & isLastTrip => logger.warn( s"Chose a ${chosenTrip.tripClassifier} trip with a $otherMode leg in our plans. This is because " + - s"we need to tour vehicle ${currentTourPersonalVehicle.get} back home" + s"we need to take tour vehicle ${currentTourPersonalVehicle.get} back home. Updating it in plan" + ) + _experiencedBeamPlan.putStrategy( + _experiencedBeamPlan.getTripContaining(destinationActivity), + TripModeChoiceStrategy(Some(chosenTrip.tripClassifier)) ) case Some(otherMode) => logger.error( @@ -2206,6 +2375,17 @@ trait ChoosesMode { } } + /** + * Constructs and sends routing and mode choice requests to the appropriate services (e.g., router, ride hail manager). + * + * @param currentTripMode Optionally, the current mode of transportation for the trip. + * @param currentTourMode Optionally, the overall mode chosen for the tour. + * @param hasRideHail A flag indicating if ride hail services are available. + * @param availableVehicles A vector of available vehicles or tokens for the current person. + * @param choosesModeData Data structure containing information for mode choice decision-making. + * @param triggerId An identifier for the triggering event of the requests. + * @return A tuple containing placeholders for chooses mode response, an optional request ID, and an updated vector of vehicles or tokens. + */ private def makeRoutingRequests( currentTripMode: Option[BeamMode], currentTourMode: Option[BeamTourMode], @@ -2241,7 +2421,6 @@ trait ChoosesMode { possibleEgressVehicles = possibleEgressVehicles, triggerId = getCurrentTriggerIdOrGenerate ) - } def makeRideHailRequest(): Unit = { @@ -2258,7 +2437,6 @@ trait ChoosesMode { triggerId = getCurrentTriggerIdOrGenerate, asPooled = !choosesModeData.personData.currentTripMode.contains(RIDE_HAIL) ) - // println(s"requesting: ${inquiry.requestId}") rideHailManager ! inquiry } @@ -2274,7 +2452,7 @@ trait ChoosesMode { withTransit = true, Some(id), Vector(bodyStreetVehicleRequestParam, dummyRHVehicle.copy(locationUTM = currentSpaceTime)), - streetVehiclesUseIntermodalUse = AccessAndEgress, + streetVehiclesUseIntermodalUse = rideHailTransitIntermodalUse, triggerId = getCurrentTriggerIdOrGenerate ) router ! theRequest @@ -2307,6 +2485,44 @@ trait ChoosesMode { var requestId: Option[Int] = None // Form and send requests var householdVehiclesWereNotAvailable = false // to replan when personal vehicles are not available + + // Check if we should always query certain modes for skimming + val shouldAlwaysQueryTransit = beamScenario.beamConfig.beam.exchange.output.generateSkimsForAllModes + val shouldAlwaysQueryRideHailTransit = + shouldAlwaysQueryTransit & beamScenario.beamConfig.beam.exchange.output.generateSkimsForRideHailTransit + + val bufferToUse = choosesModeData.mostRecentDeniedBoardingLeg match { + case Some(transitLeg) => + // Get the departure time of the failed transit leg + val failedTransitDepartureTime = transitLeg.beamLeg.startTime + // Buffer to skip just past this transit departure + (failedTransitDepartureTime - _currentTick.get) + BUFFER_PER_REPLANNING_ATTEMPT_IN_SEC + + case None => + // Fallback to standard buffer if no failed transit leg + choosesModeData.personData.numberOfReplanningAttempts * BUFFER_PER_REPLANNING_ATTEMPT_IN_SEC + } + + // Track ride hail requests that have already been made + val (alreadyRequestedRideHail, alreadyRequestedRideHailTransit) = + if (shouldAlwaysQueryTransit) { + currentTripMode match { + case Some(RIDE_HAIL | RIDE_HAIL_POOLED) if choosesModeData.isWithinTripReplanning => (false, false) + case Some(RIDE_HAIL_TRANSIT) if choosesModeData.isWithinTripReplanning => + makeRideHailRequest() + (true, false) + case _ if hasRideHail => + makeRideHailRequest() + if (shouldAlwaysQueryRideHailTransit) { + requestId = makeRideHailTransitRoutingRequest(bodyStreetVehicle) + (true, true) + } else { + (true, false) + } + case _ => (false, false) + } + } else { (false, false) } + currentTripMode match { case None => if (hasRideHail) { @@ -2315,8 +2531,8 @@ trait ChoosesMode { withRideHail = true, withRideHailTransit = !choosesModeData.isWithinTripReplanning ) - makeRideHailRequest() - if (!choosesModeData.isWithinTripReplanning) { + if (!alreadyRequestedRideHail) { makeRideHailRequest() } + if (!choosesModeData.isWithinTripReplanning & !alreadyRequestedRideHailTransit) { requestId = makeRideHailTransitRoutingRequest(bodyStreetVehicle) } } else { @@ -2348,36 +2564,57 @@ trait ChoosesMode { } :+ bodyStreetVehicle makeRequestWith( - withTransit = availableModesGivenTourMode.exists(_.isTransit), + withTransit = availableModesGivenTourMode.exists(_.isTransit) || shouldAlwaysQueryTransit, availableStreetVehiclesGivenTourMode, - possibleEgressVehicles = dummySharedVehicles + possibleEgressVehicles = dummySharedVehicles, + departureBuffer = bufferToUse ) case Some(WALK) => - responsePlaceholders = makeResponsePlaceholders(withRouting = true) - makeRequestWith(withTransit = true, Vector(bodyStreetVehicle)) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) + makeRequestWith(withTransit = shouldAlwaysQueryTransit, Vector(bodyStreetVehicle)) case Some(WALK_TRANSIT) => - responsePlaceholders = makeResponsePlaceholders(withRouting = true) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) makeRequestWith( withTransit = true, Vector(bodyStreetVehicle), - departureBuffer = choosesModeData.personData.numberOfReplanningAttempts * 5 + departureBuffer = bufferToUse ) case Some(CAV) => // Request from household the trip legs to put into trip householdRef ! CavTripLegsRequest(bodyVehiclePersonId, currentActivity(choosesModeData.personData)) - responsePlaceholders = makeResponsePlaceholders(withPrivateCAV = true) + responsePlaceholders = makeResponsePlaceholders( + withPrivateCAV = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) case Some(HOV2_TELEPORTATION) => val vehicles = availableVehicles .filter(v => BeamVehicle.isSharedTeleportationVehicle(v.id)) .map(car_vehicle => car_vehicle.streetVehicle.copy(mode = CAR_HOV2)) - makeRequestWith(withTransit = false, vehicles :+ bodyStreetVehicle) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) + makeRequestWith(withTransit = shouldAlwaysQueryTransit, vehicles :+ bodyStreetVehicle) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) case Some(HOV3_TELEPORTATION) => val vehicles = availableVehicles .filter(v => BeamVehicle.isSharedTeleportationVehicle(v.id)) .map(car_vehicle => car_vehicle.streetVehicle.copy(mode = CAR_HOV3)) - makeRequestWith(withTransit = false, vehicles :+ bodyStreetVehicle) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) + makeRequestWith(withTransit = shouldAlwaysQueryTransit, vehicles :+ bodyStreetVehicle) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) case Some(tripMode @ (CAR | BIKE | CAR_HOV2 | CAR_HOV3)) => val maybeLeg = _experiencedBeamPlan.getPlanElements .get(_experiencedBeamPlan.getPlanElements.indexOf(nextAct) - 1) match { @@ -2400,14 +2637,26 @@ trait ChoosesMode { nextAct.getCoord, triggerId ) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) case Some(vehicle) => logger.error(s"Agent ${this.id} is on a ${tripMode.value} trip but has vehicle ${vehicle.toString}") - makeRequestWith(withTransit = false, Vector(bodyStreetVehicle)) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) + makeRequestWith(withTransit = shouldAlwaysQueryTransit, Vector(bodyStreetVehicle)) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) case _ => - makeRequestWith(withTransit = false, Vector(bodyStreetVehicle)) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) + makeRequestWith(withTransit = shouldAlwaysQueryTransit, Vector(bodyStreetVehicle)) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit + ) logger.error( "No vehicle available for existing route of person {} trip of mode {} even though it was created in their plans", this.id, @@ -2425,6 +2674,7 @@ trait ChoosesMode { if ( beamScenario.beamConfig.beam.agentsim.agents.vehicles.replanOnTheFlyWhenHouseholdVehiclesAreNotAvailable && vehicles.isEmpty ) { + val currentCoordWgs = beamServices.geo.utm2Wgs(currentPersonLocation.loc) eventsManager.processEvent( new ReplanningEvent( departTime, @@ -2433,18 +2683,27 @@ trait ChoosesMode { choosesModeData.personData, ReservationErrorCode.HouseholdVehicleNotAvailable.entryName ), - currentPersonLocation.loc.getX, - currentPersonLocation.loc.getY + currentCoordWgs.getX, + currentCoordWgs.getY ) ) householdVehiclesWereNotAvailable = true logger.warn("No HH vehicle available so going back to replanning") } - makeRequestWith(withTransit = householdVehiclesWereNotAvailable, vehicles :+ bodyStreetVehicle) - responsePlaceholders = - makeResponsePlaceholders(withRouting = true, withRideHail = householdVehiclesWereNotAvailable) - if (householdVehiclesWereNotAvailable) { + makeRequestWith( + withTransit = householdVehiclesWereNotAvailable | shouldAlwaysQueryTransit, + vehicles :+ bodyStreetVehicle + ) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = householdVehiclesWereNotAvailable | alreadyRequestedRideHail, + withRideHailTransit = householdVehiclesWereNotAvailable | alreadyRequestedRideHailTransit + ) + if (householdVehiclesWereNotAvailable & !alreadyRequestedRideHail) { makeRideHailRequest() + if (!choosesModeData.isWithinTripReplanning & !alreadyRequestedRideHailTransit) { + requestId = makeRideHailTransitRoutingRequest(bodyStreetVehicle) + } } } case Some(mode @ (DRIVE_TRANSIT | BIKE_TRANSIT)) => @@ -2462,70 +2721,91 @@ trait ChoosesMode { makeRequestWith( withTransit = true, filterStreetVehiclesForQuery(availableVehicles.map(_.streetVehicle), vehicleMode) - :+ bodyStreetVehicle + :+ bodyStreetVehicle, + departureBuffer = bufferToUse + ) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit ) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) } else { // Reset available vehicles so we don't release our car that we've left during this replanning resetVehicles = true makeRequestWith( withTransit = true, Vector(bodyStreetVehicle), - departureBuffer = - choosesModeData.personData.numberOfReplanningAttempts * BUFFER_PER_REPLANNING_ATTEMPT_IN_SEC + departureBuffer = bufferToUse + ) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit ) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) } case (`lastTripIndex`, Some(currentTourPersonalVehicle)) => + val vehiclesForRouting = availableVehicles + .map(_.streetVehicle) + .filter(_.id == currentTourPersonalVehicle) + val intermodalUse: IntermodalUse = if (vehiclesForRouting.isEmpty) { + logger.error( + s"Agent ${this.id} has tour vehicle ${currentTourPersonalVehicle.toString} in PersonData but " + + s"has no available vehicles for routing on egress leg of drive transit trip" + ) + AccessAndOrEgress + } else { + Egress + } // At the end of the tour, only drive home a vehicle that we have also taken away from there. makeRequestWith( withTransit = true, - vehicles = Vector(bodyStreetVehicle), - streetVehiclesIntermodalUse = Access, - possibleEgressVehicles = availableVehicles - .map(_.streetVehicle) - .filter(_.id == currentTourPersonalVehicle) + vehiclesForRouting :+ bodyStreetVehicle, + streetVehiclesIntermodalUse = intermodalUse, + departureBuffer = bufferToUse ) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) - case (`lastTripIndex`, None) => - // TODO: Is there a way to query egress vehicles near the destination? - makeRequestWith( - withTransit = true, - availableVehicles - .filter(veh => (veh.streetVehicle.mode == vehicleMode) && veh.vehicle.isSharedVehicle) - .map(_.streetVehicle) :+ bodyStreetVehicle + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit ) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) case _ => - // Still go for it, because maybe there are some shared vehicles along the route - makeRequestWith( - withTransit = true, - availableVehicles - .filter(veh => (veh.streetVehicle.mode == vehicleMode) && veh.vehicle.isSharedVehicle) - .map(_.streetVehicle) - :+ bodyStreetVehicle + // Reset available vehicles so we don't release our car that we've left during this replanning + resetVehicles = true + makeRequestWith(withTransit = true, Vector(bodyStreetVehicle)) + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = alreadyRequestedRideHail, + withRideHailTransit = alreadyRequestedRideHailTransit ) - responsePlaceholders = makeResponsePlaceholders(withRouting = true) } case Some(RIDE_HAIL | RIDE_HAIL_POOLED) if choosesModeData.isWithinTripReplanning => // Give up on all ride hail after a failure responsePlaceholders = makeResponsePlaceholders(withRouting = true) makeRequestWith(withTransit = true, Vector(bodyStreetVehicle)) case Some(RIDE_HAIL | RIDE_HAIL_POOLED) => - responsePlaceholders = makeResponsePlaceholders(withRouting = true, withRideHail = true) - makeRequestWith(withTransit = false, Vector(bodyStreetVehicle)) // We need a WALK alternative if RH fails - makeRideHailRequest() + responsePlaceholders = makeResponsePlaceholders( + withRouting = true, + withRideHail = true, + withRideHailTransit = alreadyRequestedRideHailTransit + ) + makeRequestWith( + withTransit = shouldAlwaysQueryTransit, + Vector(bodyStreetVehicle) + ) // We need a WALK alternative if RH fails + if (!alreadyRequestedRideHail) { makeRideHailRequest() } case Some(RIDE_HAIL_TRANSIT) if choosesModeData.isWithinTripReplanning => // Give up on ride hail transit after a failure, too complicated, but try regular ride hail again responsePlaceholders = makeResponsePlaceholders(withRouting = true, withRideHail = true) - makeRequestWith(withTransit = true, Vector(bodyStreetVehicle)) - makeRideHailRequest() + makeRequestWith(withTransit = true, Vector(bodyStreetVehicle), departureBuffer = bufferToUse) + if (!alreadyRequestedRideHail) { makeRideHailRequest() } case Some(RIDE_HAIL_TRANSIT) => - responsePlaceholders = makeResponsePlaceholders(withRideHailTransit = true) - requestId = makeRideHailTransitRoutingRequest(bodyStreetVehicle) + responsePlaceholders = + makeResponsePlaceholders(withRideHailTransit = true, withRideHail = alreadyRequestedRideHail) + if (!alreadyRequestedRideHailTransit) { requestId = makeRideHailTransitRoutingRequest(bodyStreetVehicle) } case Some(m) => logDebug(m.toString) } + ( responsePlaceholders, requestId, @@ -2534,6 +2814,18 @@ trait ChoosesMode { ) } + /** + * Determines the tour mode and assigns vehicles for a trip or tour based on the given strategy, available modes, + * vehicles, and first leg itineraries. + * + * @param currentTourStrategy The current strategy for selecting the tour mode. + * @param currentTripMode The current mode of the trip, if already determined. + * @param availableVehicles A list of vehicles or tokens available for the person. + * @param choosesModeData The data used for mode choice decisions, containing person-related information. + * @param firstLegItineraries A collection of potential itineraries for the first leg of the trip. + * @return A tuple where the first element is the chosen tour mode (if any), and the second element is a mapping between + * embodied beam trips and the chosen vehicle IDs (if any). + */ private def chooseTourModeAndVehicle( currentTourStrategy: TourModeChoiceStrategy, currentTripMode: Option[BeamMode], @@ -2552,7 +2844,9 @@ trait ChoosesMode { case itin if currentTourStrategy.tourVehicle.exists(itin.vehiclesInTrip.contains) => itin -> currentTourStrategy.tourVehicle case itin if currentTourStrategy.tourVehicle.isEmpty && tourMode.isVehicleBased => - logger.warn("Vehicle based tour mode without vehicle defined") + if (tourMode != FREIGHT_TOUR) { + logger.warn("Vehicle based tour mode without vehicle defined") + } itin -> itin.legs.find(l => l.asDriver && (l.beamLeg.mode != WALK)).map(_.beamVehicleId) }.toMap ) @@ -2665,6 +2959,92 @@ trait ChoosesMode { } } + private def createAndProcessModeChoiceEvent( + chosenTripMaybe: Option[EmbodiedBeamTrip], + tick: Int, + data: ChoosesMode.ChoosesModeData + ): Unit = { + // Write start and end links of chosen route into Activities. + // We don't check yet whether the incoming and outgoing routes agree on the link an Activity is on. + // Our aim should be that every transition from a link to another link be accounted for. + val headOpt = chosenTripMaybe.flatMap( + _.legs.headOption + .flatMap(_.beamLeg.travelPath.linkIds.headOption) + ) + val lastOpt = chosenTripMaybe.flatMap( + _.legs.lastOption + .flatMap(_.beamLeg.travelPath.linkIds.lastOption) + ) + if (headOpt.isDefined && lastOpt.isDefined) { + _experiencedBeamPlan + .activities(data.personData.currentActivityIndex) + .setLinkId(Id.createLinkId(headOpt.get)) + _experiencedBeamPlan + .activities(data.personData.currentActivityIndex + 1) + .setLinkId(Id.createLinkId(lastOpt.get)) + } else { + val origin = beamServices.geo.utm2Wgs( + _experiencedBeamPlan + .activities(data.personData.currentActivityIndex) + .getCoord + ) + val destination = beamServices.geo.utm2Wgs( + _experiencedBeamPlan + .activities(data.personData.currentActivityIndex + 1) + .getCoord + ) + val linkRadiusMeters = beamScenario.beamConfig.beam.routing.r5.linkRadiusMeters + _experiencedBeamPlan + .activities(data.personData.currentActivityIndex) + .setLinkId( + Id.createLinkId( + beamServices.geo.getNearestR5Edge(transportNetwork.streetLayer, origin, linkRadiusMeters) + ) + ) + _experiencedBeamPlan + .activities(data.personData.currentActivityIndex + 1) + .setLinkId( + Id.createLinkId( + beamServices.geo.getNearestR5Edge(transportNetwork.streetLayer, destination, linkRadiusMeters) + ) + ) + } + + val tripId: String = _experiencedBeamPlan.trips + .lift(data.personData.currentActivityIndex + 1) match { + case Some(trip) => + trip.leg.map(l => Option(l.getAttributes.getAttribute("trip_id")).getOrElse("").toString).getOrElse("") + case None => "" + } + + val destinationActivity = nextActivity(data.personData).get + + val initialTourMode = data.personData.currentTourMode + + val tripDistance: Double = + chosenTripMaybe.map(_.legs.view.map(_.beamLeg.travelPath.distanceInM).sum).getOrElse(Double.NaN) + + val modeChoiceEvent = new ModeChoiceEvent( + tick, + id, + chosenTripMaybe + .map(_.tripClassifier.value) + .getOrElse(data.personData.currentTripMode.map(_.value).getOrElse("None")), + initialTourMode.map(_.value).getOrElse(""), + data.expectedMaxUtilityOfLatestChoice.getOrElse[Double](Double.NaN), + _experiencedBeamPlan.activities(data.personData.currentActivityIndex).getLinkId.toString, + data.availableAlternatives.getOrElse(""), + data.availablePersonalStreetVehicles.nonEmpty, + tripDistance, + _experiencedBeamPlan.tourIndexOfElement(destinationActivity), + chosenTripMaybe.getOrElse(EmbodiedBeamTrip.empty), + _experiencedBeamPlan.activities(data.personData.currentActivityIndex).getType, + destinationActivity.getType, + tripId + ) + eventsManager.processEvent(modeChoiceEvent) + } + private def updateTourModeStrategy( newTourMode: Option[BeamTourMode], newTourVehicle: Option[Id[BeamVehicle]], @@ -2674,6 +3054,8 @@ trait ChoosesMode { (newTourMode, newTourVehicle) match { case (Some(CAR_BASED), None) => logger.error("Why are we going into a car based tour without a car?") + case (None, _) => + logger.info(s"Resetting tour mode to None for person ${this.id}") case _ => } val currentTour = _experiencedBeamPlan.getTourContaining(nextActivity) @@ -2765,7 +3147,8 @@ object ChoosesMode { excludeModes: Set[BeamMode] = Set.empty[BeamMode], availableAlternatives: Option[String] = None, routingFinished: Boolean = false, - routingRequestToLegMap: Map[Int, TripIdentifier] = Map.empty + routingRequestToLegMap: Map[Int, TripIdentifier] = Map.empty, + mostRecentDeniedBoardingLeg: Option[EmbodiedBeamLeg] = None ) extends PersonData { override def currentVehicle: VehicleStack = personData.currentVehicle diff --git a/src/main/scala/beam/agentsim/agents/modalbehaviors/DrivesVehicle.scala b/src/main/scala/beam/agentsim/agents/modalbehaviors/DrivesVehicle.scala index 77d0a9a1599..91409065eee 100644 --- a/src/main/scala/beam/agentsim/agents/modalbehaviors/DrivesVehicle.scala +++ b/src/main/scala/beam/agentsim/agents/modalbehaviors/DrivesVehicle.scala @@ -18,7 +18,7 @@ import beam.agentsim.events.RefuelSessionEvent.NotApplicable import beam.agentsim.events._ import beam.agentsim.infrastructure.ChargingNetworkManager._ import beam.agentsim.infrastructure.ParkingInquiry.{ParkingActivityType, ParkingSearchMode} -import beam.agentsim.infrastructure.{ParkingInquiry, ParkingStall} +import beam.agentsim.infrastructure.{ParkingInquiry, ParkingNetworkManager, ParkingStall} import beam.agentsim.scheduler.BeamAgentScheduler.{CompletionNotice, ScheduleTrigger} import beam.agentsim.scheduler.Trigger.TriggerWithId import beam.agentsim.scheduler.{HasTriggerId, Trigger} @@ -384,15 +384,15 @@ trait DrivesVehicle[T <: DrivingData] extends BeamAgent[T] with Stash with Expon numberOfPassengers, currentLeg, getCurrentTripMode(data), - fuelConsumed.primaryFuel, - fuelConsumed.secondaryFuel, - currentBeamVehicle.primaryFuelLevelInJoules, - currentBeamVehicle.secondaryFuelLevelInJoules, - tollOnCurrentLeg, - payloadIds, - currentBeamVehicle.beamVehicleType.curbWeightInKg + payloadWeight, + fuelConsumed.primaryFuel.toFloat, + fuelConsumed.secondaryFuel.toFloat, + currentBeamVehicle.primaryFuelLevelInJoules.toFloat, + currentBeamVehicle.secondaryFuelLevelInJoules.toFloat, + tollOnCurrentLeg.toFloat, + payloadIds.toArray, + (currentBeamVehicle.beamVehicleType.curbWeightInKg + payloadWeight).toFloat, emissionsProfile, - riders + riders.toArray ) eventsManager.processEvent(pte) @@ -637,15 +637,15 @@ trait DrivesVehicle[T <: DrivingData] extends BeamAgent[T] with Stash with Expon numberOfPassengers, partiallyCompletedBeamLeg, getCurrentTripMode(data), - fuelConsumed.primaryFuel, - fuelConsumed.secondaryFuel, - currentBeamVehicle.primaryFuelLevelInJoules, - currentBeamVehicle.secondaryFuelLevelInJoules, - tollOnCurrentLeg, - payloadIds, - currentBeamVehicle.beamVehicleType.curbWeightInKg + payloadWeight, + fuelConsumed.primaryFuel.toFloat, + fuelConsumed.secondaryFuel.toFloat, + currentBeamVehicle.primaryFuelLevelInJoules.toFloat, + currentBeamVehicle.secondaryFuelLevelInJoules.toFloat, + tollOnCurrentLeg.toFloat, + payloadIds.toArray, + (currentBeamVehicle.beamVehicleType.curbWeightInKg + payloadWeight).toFloat, emissionsProfile, - riders + riders.toArray ) eventsManager.processEvent(pte) generateTCSEventIfPossible(pte) @@ -762,15 +762,14 @@ trait DrivesVehicle[T <: DrivingData] extends BeamAgent[T] with Stash with Expon currentBeamVehicle.id == currentVehicleUnderControl, currentBeamVehicle.id + " " + currentVehicleUnderControl ) - currentBeamVehicle.stall.foreach { theStall => - parkingManager ! ReleaseParkingStall(theStall, tick) - currentBeamVehicle.setLastVehicleTimeLink( - Some(tick), - theStall.link.map(_.getId.toString.toInt) - ) - } - currentBeamVehicle.unsetParkingStall() - + ParkingNetworkManager.handleReleasingParkingSpot( + tick, + currentBeamVehicle, + None, + id, + parkingManager, + eventsManager + ) case None => } val triggerToSchedule: Vector[ScheduleTrigger] = data.passengerSchedule diff --git a/src/main/scala/beam/agentsim/agents/modalbehaviors/ModeChoiceCalculator.scala b/src/main/scala/beam/agentsim/agents/modalbehaviors/ModeChoiceCalculator.scala index 883314585a1..826bbedf1d8 100755 --- a/src/main/scala/beam/agentsim/agents/modalbehaviors/ModeChoiceCalculator.scala +++ b/src/main/scala/beam/agentsim/agents/modalbehaviors/ModeChoiceCalculator.scala @@ -123,9 +123,10 @@ trait ModeChoiceCalculator { } def computeAllDayUtility( - trips: ListBuffer[EmbodiedBeamTrip], + trips: Map[EmbodiedBeamTrip, Map[String, Double]], person: Person, - attributesOfIndividual: AttributesOfIndividual + attributesOfIndividual: AttributesOfIndividual, + overrideAttributes: Boolean = false ): Double final def chooseRandomAlternativeIndex(alternatives: Seq[EmbodiedBeamTrip]): Int = { diff --git a/src/main/scala/beam/agentsim/agents/parking/ChoosesParking.scala b/src/main/scala/beam/agentsim/agents/parking/ChoosesParking.scala index ee808158340..d318c8ba7c9 100755 --- a/src/main/scala/beam/agentsim/agents/parking/ChoosesParking.scala +++ b/src/main/scala/beam/agentsim/agents/parking/ChoosesParking.scala @@ -176,6 +176,7 @@ trait ChoosesParking extends { this: PersonAgent => // Self type restricts this trait to only mix into a PersonAgent protected lazy val endOfSimulationTime: Int = DateUtils.getEndOfTime(beamServices.beamConfig) + var latestParkingInquiry: Option[ParkingInquiry] = None private def buildParkingInquiry(data: BasePersonData): ParkingInquiry = { val firstLeg = data.restOfCurrentTrip.head @@ -369,10 +370,19 @@ trait ChoosesParking extends { when(ChoosingParkingSpot) { case Event(ParkingInquiryResponse(stall, _, _), data) => + val tick = _currentTick.getOrElse(0) val distanceThresholdToIgnoreWalking = beamServices.beamConfig.beam.agentsim.thresholdForWalkingInMeters - val nextLeg = - data.passengerSchedule.schedule.keys.drop(data.currentLegPassengerScheduleIndex).head + val existingLeg = data.passengerSchedule.schedule.keys.drop(data.currentLegPassengerScheduleIndex).head + + val (startLegTriggerTick, nextLeg, fixedData) = if (existingLeg.startTime < tick) { + val rescheduledLeg = existingLeg.updateStartTime(tick) + val newSchedule = data.passengerSchedule.replaceLegWithSamePath(existingLeg, rescheduledLeg) + (tick, rescheduledLeg, data.asInstanceOf[BasePersonData].copy(passengerSchedule = newSchedule)) + } else { + (existingLeg.startTime, existingLeg, data) + } + currentBeamVehicle.setReservedParkingStall(Some(stall)) val distance = beamServices.geo.distUTMInMeters(stall.locationUTM, beamServices.geo.wgs2Utm(nextLeg.travelPath.endPoint.loc)) @@ -381,15 +391,15 @@ trait ChoosesParking extends { val (_, triggerId) = releaseTickAndTriggerId() scheduler ! CompletionNotice( triggerId, - Vector(ScheduleTrigger(StartLegTrigger(nextLeg.startTime, nextLeg), self)) + Vector(ScheduleTrigger(StartLegTrigger(startLegTriggerTick, nextLeg), self)) ) - val updatedData = data match { + val updatedData = fixedData match { case data: BasePersonData => data.copy(enrouteData = EnrouteData()) - case _ => data + case _ => fixedData } goto(WaitingToDrive) using updatedData } else { - val (updatedData, isEnrouting) = data match { + val (updatedData, isEnrouting) = fixedData match { case data: BasePersonData if data.enrouteData.isInEnrouteState => val updatedEnrouteData = data.enrouteData.copy(hasReservedFastChargerStall = @@ -397,7 +407,7 @@ trait ChoosesParking extends { ) (data.copy(enrouteData = updatedEnrouteData), updatedEnrouteData.isEnrouting) case _ => - (data, false) + (fixedData, false) } updatedData match { case data: BasePersonData if data.enrouteData.isInEnrouteState && !isEnrouting => @@ -405,7 +415,7 @@ trait ChoosesParking extends { val (tick, triggerId) = releaseTickAndTriggerId() scheduler ! CompletionNotice( triggerId, - Vector(ScheduleTrigger(StartLegTrigger(nextLeg.startTime, nextLeg), self)) + Vector(ScheduleTrigger(StartLegTrigger(startLegTriggerTick, nextLeg), self)) ) handleReleasingParkingSpot(tick, currentBeamVehicle, None, id, parkingManager, beamServices, eventsManager) goto(WaitingToDrive) using data.copy(enrouteData = EnrouteData()) diff --git a/src/main/scala/beam/agentsim/agents/planning/BeamPlan.scala b/src/main/scala/beam/agentsim/agents/planning/BeamPlan.scala index 70b0524e5fc..ff3f06e7df2 100755 --- a/src/main/scala/beam/agentsim/agents/planning/BeamPlan.scala +++ b/src/main/scala/beam/agentsim/agents/planning/BeamPlan.scala @@ -310,18 +310,6 @@ class BeamPlan extends Plan { } } - def lastTripOfCurrentTour(idx: Int): Boolean = { - if (idx <= 1) { - false - } else if (idx + 2 < activities.size) { - val nextTrip = getTourContaining(idx + 2) - val currentTrip = getTourContaining(idx + 1) - (nextTrip.tourId != currentTrip.tourId) - } else { - true - } - } - def tourIndexOfElement(planElement: PlanElement): Int = { (for (tour <- tours.zipWithIndex if tour._1 == getTourContaining(planElement)) yield tour._2).head diff --git a/src/main/scala/beam/agentsim/agents/ridehail/RideHailDepotManager.scala b/src/main/scala/beam/agentsim/agents/ridehail/RideHailDepotManager.scala index e4ba4a0e6eb..0f7c7c10725 100644 --- a/src/main/scala/beam/agentsim/agents/ridehail/RideHailDepotManager.scala +++ b/src/main/scala/beam/agentsim/agents/ridehail/RideHailDepotManager.scala @@ -15,7 +15,9 @@ import beam.agentsim.events.{ParkingEvent, SpaceTime} import beam.agentsim.infrastructure.ChargingNetworkManager._ import beam.agentsim.infrastructure.ParkingInquiry.ParkingSearchMode import beam.agentsim.infrastructure._ +import beam.agentsim.infrastructure.charging.ChargingPointType import beam.agentsim.infrastructure.parking._ +import beam.agentsim.infrastructure.taz.TAZ import beam.agentsim.scheduler.HasTriggerId import beam.router.BeamRouter.Location import beam.sim.config.BeamConfig @@ -275,13 +277,13 @@ trait RideHailDepotManager extends { * @param triggerId Long * @return */ - def sendChargingInquiry( + private def sendChargingInquiry( whenWhere: SpaceTime, beamVehicle: BeamVehicle, triggerId: Long ): Future[ParkingInquiryResponse] = { val (chargingTime, _) = beamVehicle.refuelingSessionDurationAndEnergyInJoulesForStall( - Some(ParkingStall.defaultFastChargingStall(whenWhere.loc)), + Some(RideHailDepotManager.getDefaultFastChargingStall(whenWhere.loc)), None, None, None @@ -304,6 +306,17 @@ trait RideHailDepotManager extends { object RideHailDepotManager { + private def getDefaultFastChargingStall(locationUTM: Location): ParkingStall = ParkingStall( + tazId = TAZ.DefaultTAZId, + parkingZoneId = ParkingZone.DefaultParkingZone.parkingZoneId, + locationUTM = locationUTM, + costInDollars = 0.0, + chargingPointType = Some(ChargingPointType.ChargingStationCcsComboType2), + pricingModel = Some(PricingModel.FlatFee(0)), + parkingType = ParkingType.Public, + reservedFor = VehicleManager.AnyManager + ) + sealed trait RefuelSource case object JustArrivedAtDepot extends RefuelSource case object DequeuedToCharge extends RefuelSource diff --git a/src/main/scala/beam/agentsim/agents/ridehail/RideHailMaster.scala b/src/main/scala/beam/agentsim/agents/ridehail/RideHailMaster.scala index 9b5ccda75f9..dd965a2fdec 100644 --- a/src/main/scala/beam/agentsim/agents/ridehail/RideHailMaster.scala +++ b/src/main/scala/beam/agentsim/agents/ridehail/RideHailMaster.scala @@ -55,7 +55,7 @@ class RideHailMaster( private val rideHailManagers: Map[String, RideHailManagerData] = beamServices.beamConfig.beam.agentsim.agents.rideHail.managers.map { managerConfig => val rideHailManagerId = - VehicleManager.createOrGetReservedFor(managerConfig.name, VehicleManager.TypeEnum.RideHail).managerId + VehicleManager.createOrGetReservedFor(managerConfig.name, Some(VehicleManager.TypeEnum.RideHail)).managerId val rideHailFleetInitializer = rideHailFleetInitializerProvider.get(managerConfig.name) val rhmActorRef = context.actorOf( Props( diff --git a/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicle.scala b/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicle.scala index e0a10f21ad6..8732e766e21 100755 --- a/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicle.scala +++ b/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicle.scala @@ -442,7 +442,8 @@ class BeamVehicle( def isSharedVehicle: Boolean = beamVehicleType.id.toString.startsWith("sharedVehicle") - def isFreightVehicle: Boolean = id.toString.startsWith("freightVehicle") + def isFreight: Boolean = + VehicleManager.getReservedFor(vehicleManagerId.get()).exists(_.managerType == VehicleManager.TypeEnum.Freight) def isCAV: Boolean = beamVehicleType.isConnectedAutomatedVehicle @@ -595,6 +596,10 @@ object BeamVehicle { vehicleId.toString.startsWith(idPrefixSharedTeleportationVehicle) } + def isFreightVehicle(vehicleId: Id[BeamVehicle]): Boolean = { + vehicleId.toString.startsWith("freightVehicle") + } + def isEmergencyVehicle(vehicleId: Id[BeamVehicle]): Boolean = { vehicleId.toString.contains("-emergency-") } diff --git a/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicleType.scala b/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicleType.scala index 959683ea058..f980358b9dd 100755 --- a/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicleType.scala +++ b/src/main/scala/beam/agentsim/agents/vehicles/BeamVehicleType.scala @@ -91,17 +91,18 @@ object VehicleCategory { case exception: Exception => throw new RuntimeException(f"Can not parse vehicle category: '$value'.", exception) } + val values: Vector[VehicleCategory] = Vector( + Body, + Bike, + Car, + MediumDutyPassenger, + Class2b3Vocational, + Class456Vocational, + Class78Vocational, + Class78Tractor + ) + private def fromStringOptional(value: String): Option[VehicleCategory] = { - Vector( - Body, - Bike, - Car, - MediumDutyPassenger, - Class2b3Vocational, - Class456Vocational, - Class78Vocational, - Class78Tractor - ) - .find(_.toString.equalsIgnoreCase(value)) + values.find(_.toString.equalsIgnoreCase(value)) } } diff --git a/src/main/scala/beam/agentsim/agents/vehicles/PassengerSchedule.scala b/src/main/scala/beam/agentsim/agents/vehicles/PassengerSchedule.scala index c5723c62f93..efb14309518 100755 --- a/src/main/scala/beam/agentsim/agents/vehicles/PassengerSchedule.scala +++ b/src/main/scala/beam/agentsim/agents/vehicles/PassengerSchedule.scala @@ -93,6 +93,38 @@ case class PassengerSchedule(schedule: TreeMap[BeamLeg, Manifest]) { schedule.map(keyVal => s"${keyVal._1.toString} -> ${keyVal._2.toString}").mkString("--") } + /** + * Replace a specific leg in the schedule with a new one (typically with an updated start time) + * Finds the leg with matching path regardless of start time + * + * @param oldLeg The leg to find (may not match exactly on start time) + * @param newLeg The replacement leg + * @return Updated PassengerSchedule with the leg replaced + */ + def replaceLegWithSamePath(oldLeg: BeamLeg, newLeg: BeamLeg): PassengerSchedule = { + // Try exact match first + if (schedule.contains(oldLeg)) { + val manifest = schedule(oldLeg) + new PassengerSchedule(schedule - oldLeg + (newLeg -> manifest)) + } else { + // Try to find by matching mode, duration and path (ignoring start time) + val matchingLeg = schedule.keys.find { leg => + leg.mode == oldLeg.mode && + leg.duration == oldLeg.duration && + BeamPath.compare(leg.travelPath, oldLeg.travelPath) == 0 + } + + matchingLeg match { + case Some(leg) => + val manifest = schedule(leg) + new PassengerSchedule(schedule - leg + (newLeg -> manifest)) + case None => + // No matching leg found, return unchanged + this + } + } + } + } //Specialized copy of Ordering.by[Tuple2] so we can control compare diff --git a/src/main/scala/beam/agentsim/agents/vehicles/VehicleManager.scala b/src/main/scala/beam/agentsim/agents/vehicles/VehicleManager.scala index dcee2218ee3..608020184e6 100644 --- a/src/main/scala/beam/agentsim/agents/vehicles/VehicleManager.scala +++ b/src/main/scala/beam/agentsim/agents/vehicles/VehicleManager.scala @@ -3,6 +3,7 @@ package beam.agentsim.agents.vehicles import beam.sim.config.BeamConfig import com.typesafe.scalalogging.LazyLogging import org.matsim.api.core.v01.Id +import beam.agentsim.agents.freight.input.FreightReader.CARRIER_ID_PREFIX import scala.collection.concurrent.TrieMap import scala.util.matching.Regex @@ -19,7 +20,7 @@ object VehicleManager extends LazyLogging { AnyManager.managerId -> AnyManager ) - val CustomReservedForRegex: Regex = """([\w-]+)\(([\w-]+)\)""".r.unanchored + private val CustomReservedForRegex: Regex = """([\w-]+)\(([\w-]+)\)""".r.unanchored object TypeEnum extends Enumeration { type VehicleManagerType = Value @@ -45,8 +46,21 @@ object VehicleManager extends LazyLogging { def getReservedFor(managerId: Id[VehicleManager]): Option[ReservedFor] = vehicleManagers.get(managerId) - def createOrGetReservedFor(idString: String, vehType: TypeEnum.VehicleManagerType): ReservedFor = { + def createOrGetReservedFor( + idString: String, + vehTypeMaybe: Option[TypeEnum.VehicleManagerType] = None + ): ReservedFor = { val vehId = Id.create(idString, classOf[VehicleManager]) + val vehType = vehTypeMaybe.getOrElse { + if (idString.startsWith(CARRIER_ID_PREFIX)) + TypeEnum.Freight + else if (idString.startsWith("ridehail")) + TypeEnum.RideHail + else if (idString.startsWith("shared")) + TypeEnum.Shared + else + TypeEnum.Household + } if (vehicleManagers.contains(vehId) && vehicleManagers(vehId).managerType != vehType) throw new RuntimeException("Duplicate vehicle manager ids is not allowed") val reservedFor = ReservedFor(vehId, vehType) @@ -59,9 +73,9 @@ object VehicleManager extends LazyLogging { case null | "" => Some(VehicleManager.AnyManager) case x if x == VehicleManager.AnyManager.managerId.toString => - Some(createOrGetReservedFor(reservedForString, TypeEnum.Default)) + Some(createOrGetReservedFor(reservedForString, Some(TypeEnum.Default))) case CustomReservedForRegex(kind, id) => - Some(createOrGetReservedFor(id, TypeEnum.withName(kind.trim.toLowerCase))) + Some(createOrGetReservedFor(id, Some(TypeEnum.withName(kind.trim.toLowerCase)))) case _ => None } @@ -70,16 +84,16 @@ object VehicleManager extends LazyLogging { val sharedFleets = cfgAgentSim.agents.vehicles.sharedFleets val rideHailManagers = cfgAgentSim.agents.rideHail.managers reservedForMaybe = reservedForString match { - case cfgAgentSim.agents.freight.name => Some(createOrGetReservedFor(reservedForString, TypeEnum.Freight)) + case cfgAgentSim.agents.freight.name => Some(createOrGetReservedFor(reservedForString, Some(TypeEnum.Freight))) case reservedFor if rideHailManagers.exists(_.name == reservedFor) => - Some(createOrGetReservedFor(reservedForString, TypeEnum.RideHail)) + Some(createOrGetReservedFor(reservedForString, Some(TypeEnum.RideHail))) case reservedFor if sharedFleets.exists(_.name == reservedFor) => - Some(createOrGetReservedFor(reservedForString, TypeEnum.Shared)) + Some(createOrGetReservedFor(reservedForString, Some(TypeEnum.Shared))) case _ => None } } - reservedForMaybe map { case ReservedFor(mngId, mngType) => createOrGetReservedFor(mngId.toString, mngType) } + reservedForMaybe } def reserveForToString(reservedFor: ReservedFor): String = { diff --git a/src/main/scala/beam/agentsim/events/ChargingPlugInEvent.scala b/src/main/scala/beam/agentsim/events/ChargingPlugInEvent.scala index a6c57f4ff03..5632d7cbb29 100644 --- a/src/main/scala/beam/agentsim/events/ChargingPlugInEvent.scala +++ b/src/main/scala/beam/agentsim/events/ChargingPlugInEvent.scala @@ -1,14 +1,14 @@ package beam.agentsim.events -import java.util - import beam.agentsim.infrastructure.ParkingStall -import org.matsim.api.core.v01.{Coord, Id} import org.matsim.api.core.v01.events.Event import org.matsim.api.core.v01.population.Person +import org.matsim.api.core.v01.{Coord, Id} import org.matsim.core.api.internal.HasPersonId import org.matsim.vehicles.Vehicle +import java.util + case class ChargingPlugInEvent( tick: Double, stall: ParkingStall, @@ -40,6 +40,7 @@ case class ChargingPlugInEvent( attributes.put(ATTRIBUTE_PRICING_MODEL, pricingModelString) attributes.put(ATTRIBUTE_CHARGING_TYPE, chargingPointString) attributes.put(ATTRIBUTE_PARKING_TAZ, stall.tazId.toString) + attributes.put(ATTRIBUTE_PARKING_ZONE_ID, stall.parkingZoneId.toString) attributes } @@ -57,4 +58,5 @@ object ChargingPlugInEvent { val ATTRIBUTE_PRICING_MODEL: String = "pricingModel" val ATTRIBUTE_CHARGING_TYPE: String = "chargingPointType" val ATTRIBUTE_PARKING_TAZ: String = "parkingTaz" + val ATTRIBUTE_PARKING_ZONE_ID: String = "parkingZoneId" } diff --git a/src/main/scala/beam/agentsim/events/ChargingPlugOutEvent.scala b/src/main/scala/beam/agentsim/events/ChargingPlugOutEvent.scala index 51925ee7a95..d3582e62a64 100644 --- a/src/main/scala/beam/agentsim/events/ChargingPlugOutEvent.scala +++ b/src/main/scala/beam/agentsim/events/ChargingPlugOutEvent.scala @@ -1,7 +1,5 @@ package beam.agentsim.events -import java.util - import beam.agentsim.infrastructure.ParkingStall import org.matsim.api.core.v01.Id import org.matsim.api.core.v01.events.Event @@ -9,6 +7,8 @@ import org.matsim.api.core.v01.population.Person import org.matsim.core.api.internal.HasPersonId import org.matsim.vehicles.Vehicle +import java.util + case class ChargingPlugOutEvent( tick: Double, stall: ParkingStall, @@ -49,6 +49,7 @@ case class ChargingPlugOutEvent( attributes.put(ATTRIBUTE_PRICING_MODEL, pricingModelString) attributes.put(ATTRIBUTE_CHARGING_TYPE, chargingPointString) attributes.put(ATTRIBUTE_PARKING_TAZ, stall.tazId.toString) + attributes.put(ATTRIBUTE_PARKING_ZONE_ID, stall.parkingZoneId.toString) attributes } @@ -66,5 +67,5 @@ object ChargingPlugOutEvent { val ATTRIBUTE_PRICING_MODEL: String = "pricingModel" val ATTRIBUTE_CHARGING_TYPE: String = "chargingPointType" val ATTRIBUTE_PARKING_TAZ: String = "parkingTaz" - + val ATTRIBUTE_PARKING_ZONE_ID: String = "parkingZoneId" } diff --git a/src/main/scala/beam/agentsim/events/LeavingParkingEvent.scala b/src/main/scala/beam/agentsim/events/LeavingParkingEvent.scala index 10d29e7cb2b..ddc20ae5720 100755 --- a/src/main/scala/beam/agentsim/events/LeavingParkingEvent.scala +++ b/src/main/scala/beam/agentsim/events/LeavingParkingEvent.scala @@ -23,7 +23,8 @@ case class LeavingParkingEvent( parkingType: ParkingType, pricingModel: Option[PricingModel], ChargingPointType: Option[ChargingPointType], - emissionsProfile: Option[EmissionsProfile] + emissionsProfile: Option[EmissionsProfile], + parkingZoneId: Id[ParkingZoneId] ) extends Event(time) with ScalaEvent { import LeavingParkingEvent._ @@ -42,6 +43,8 @@ case class LeavingParkingEvent( attr.put(ATTRIBUTE_EMISSIONS_PROFILE, emissionsProfile.map(BeamVehicleUtils.buildEmissionsString).getOrElse("")) attr.put(ATTRIBUTE_PARKING_DURATION, parkingDuration.toString) attr.put(ATTRIBUTE_COST, pricingModel.map(_.costInDollars.toString).getOrElse("0")) + attr.put(ATTRIBUTE_PARKING_ZONE_ID, parkingZoneId.toString) + attr } } @@ -74,6 +77,7 @@ object LeavingParkingEvent { val ATTRIBUTE_DRIVER_ID: String = "driver" val ATTRIBUTE_EMISSIONS_PROFILE: String = "emissions" val ATTRIBUTE_PARKING_DURATION: String = "duration" + val ATTRIBUTE_PARKING_ZONE_ID: String = "parkingZoneId" def apply( time: Double, @@ -93,7 +97,8 @@ object LeavingParkingEvent { stall.parkingType, stall.pricingModel, stall.chargingPointType, - emissionsProfile + emissionsProfile, + parkingZoneId = stall.parkingZoneId ) } @@ -124,5 +129,17 @@ object LeavingParkingEvent { chargingPointType, emissionsProfile ) + val parkingZoneId: Id[ParkingZoneId] = Id.create(attr(ATTRIBUTE_PARKING_ZONE_ID), classOf[ParkingZoneId]) + LeavingParkingEvent( + time, + personId, + vehicleId, + tazId, + score, + parkingType, + pricingModel, + chargingPointType, + parkingZoneId + ) } } diff --git a/src/main/scala/beam/agentsim/events/ParkingEvent.scala b/src/main/scala/beam/agentsim/events/ParkingEvent.scala index 7a87d1ef6e3..257c72a7c27 100755 --- a/src/main/scala/beam/agentsim/events/ParkingEvent.scala +++ b/src/main/scala/beam/agentsim/events/ParkingEvent.scala @@ -2,7 +2,7 @@ package beam.agentsim.events import beam.agentsim.infrastructure.ParkingStall import beam.agentsim.infrastructure.charging.ChargingPointType -import beam.agentsim.infrastructure.parking.{ParkingType, PricingModel} +import beam.agentsim.infrastructure.parking.{ParkingType, ParkingZoneId, PricingModel} import beam.agentsim.infrastructure.taz.TAZ import beam.sim.common.GeoUtils import com.typesafe.scalalogging.LazyLogging @@ -22,7 +22,8 @@ case class ParkingEvent( locationWGS: Coord, parkingType: ParkingType, pricingModel: Option[PricingModel], - chargingPointType: Option[ChargingPointType] + chargingPointType: Option[ChargingPointType], + parkingZoneId: Id[ParkingZoneId] ) extends Event(time) with ScalaEvent with LazyLogging { @@ -54,6 +55,7 @@ case class ParkingEvent( attr.put(ATTRIBUTE_PRICING_MODEL, pricingModelString) attr.put(ATTRIBUTE_CHARGING_TYPE, chargingPointString) attr.put(ATTRIBUTE_PARKING_TAZ, tazId.toString) + attr.put(ATTRIBUTE_PARKING_ZONE_ID, parkingZoneId.toString) attr } @@ -71,6 +73,7 @@ object ParkingEvent { val ATTRIBUTE_PRICING_MODEL: String = "pricingModel" val ATTRIBUTE_CHARGING_TYPE: String = "chargingPointType" val ATTRIBUTE_PARKING_TAZ: String = "parkingTaz" + val ATTRIBUTE_PARKING_ZONE_ID: String = "parkingZoneId" def apply( time: Double, @@ -88,7 +91,8 @@ object ParkingEvent { locationWGS = locationWGS, parkingType = stall.parkingType, pricingModel = stall.pricingModel, - chargingPointType = stall.chargingPointType + chargingPointType = stall.chargingPointType, + parkingZoneId = stall.parkingZoneId ) } @@ -105,6 +109,17 @@ object ParkingEvent { val pricingModel: Option[PricingModel] = attr.get(ATTRIBUTE_PRICING_MODEL).flatMap(PricingModel(_, attr.getOrElse(ATTRIBUTE_COST, "0"))) val chargingPointType: Option[ChargingPointType] = attr.get(ATTRIBUTE_CHARGING_TYPE).flatMap(ChargingPointType(_)) - new ParkingEvent(time, driverId, vehicleId, tazId, locationWGS, parkingType, pricingModel, chargingPointType) + val parkingZoneId = Id.create(attr(ATTRIBUTE_PARKING_ZONE_ID), classOf[ParkingZoneId]) + new ParkingEvent( + time, + driverId, + vehicleId, + tazId, + locationWGS, + parkingType, + pricingModel, + chargingPointType, + parkingZoneId + ) } } diff --git a/src/main/scala/beam/agentsim/events/PathTraversalEvent.scala b/src/main/scala/beam/agentsim/events/PathTraversalEvent.scala index 87cfc07dec4..9105910fe6d 100644 --- a/src/main/scala/beam/agentsim/events/PathTraversalEvent.scala +++ b/src/main/scala/beam/agentsim/events/PathTraversalEvent.scala @@ -30,76 +30,69 @@ case class PathTraversalEvent( arrivalTime: Int, mode: BeamMode, legLength: Double, - linkIds: IndexedSeq[Int], - linkTravelTime: IndexedSeq[Double], - startX: Double, - startY: Double, - endX: Double, - endY: Double, - primaryFuelConsumed: Double, - secondaryFuelConsumed: Double, - endLegPrimaryFuelLevel: Double, - endLegSecondaryFuelLevel: Double, - amountPaid: Double, + linkIds: Array[Int], + linkTravelTime: Array[Float], + startX: Float, + startY: Float, + endX: Float, + endY: Float, + primaryFuelConsumed: Float, + secondaryFuelConsumed: Float, + endLegPrimaryFuelLevel: Float, + endLegSecondaryFuelLevel: Float, + amountPaid: Float, fromStopIndex: Option[Int], toStopIndex: Option[Int], currentTripMode: Option[String], - payloadIds: IndexedSeq[Id[PayloadPlan]], - weight: Double, + payloadIds: Array[Id[PayloadPlan]], + weight: Float, emissionsProfile: Option[EmissionsProfile], - riders: IndexedSeq[Id[Person]] = Vector() + riders: Array[Id[Person]] = Array() ) extends Event(time) with ScalaEvent { import PathTraversalEvent._ def capacity: Int = seatingCapacity + standingRoomCapacity - def linkIdsJava: util.List[Int] = linkIds.asJava + def linkIdsJava: util.List[Int] = linkIds.toList.asJava override def getEventType: String = "PathTraversal" - private val filledAttrs: AtomicReference[util.Map[String, String]] = - new AtomicReference[util.Map[String, String]](null) - override def getAttributes: util.Map[String, String] = { - if (filledAttrs.get() != null) filledAttrs.get() - else { - val attr = super.getAttributes() - attr.put(ATTRIBUTE_VEHICLE_ID, vehicleId.toString) - attr.put(ATTRIBUTE_DRIVER_ID, driverId) - attr.put(ATTRIBUTE_VEHICLE_TYPE, vehicleType) - attr.put(ATTRIBUTE_LENGTH, legLength.toString) - attr.put(ATTRIBUTE_NUM_PASS, numberOfPassengers.toString) + val attr = super.getAttributes + attr.put(ATTRIBUTE_VEHICLE_ID, vehicleId.toString) + attr.put(ATTRIBUTE_DRIVER_ID, driverId) + attr.put(ATTRIBUTE_VEHICLE_TYPE, vehicleType) + attr.put(ATTRIBUTE_LENGTH, legLength.toString) + attr.put(ATTRIBUTE_NUM_PASS, numberOfPassengers.toString) - attr.put(ATTRIBUTE_DEPARTURE_TIME, departureTime.toString) - attr.put(ATTRIBUTE_ARRIVAL_TIME, arrivalTime.toString) - attr.put(ATTRIBUTE_MODE, mode.value) - attr.put(ATTRIBUTE_LINK_IDS, linkIds.mkString(",")) - attr.put(ATTRIBUTE_LINK_TRAVEL_TIME, linkTravelTime.map(FormatUtils.DECIMAL_3.format).mkString(",")) - attr.put(ATTRIBUTE_PRIMARY_FUEL_TYPE, primaryFuelType) - attr.put(ATTRIBUTE_SECONDARY_FUEL_TYPE, secondaryFuelType) - attr.put(ATTRIBUTE_PRIMARY_FUEL, primaryFuelConsumed.toString) - attr.put(ATTRIBUTE_SECONDARY_FUEL, secondaryFuelConsumed.toString) - attr.put(ATTRIBUTE_VEHICLE_CAPACITY, capacity.toString) + attr.put(ATTRIBUTE_DEPARTURE_TIME, departureTime.toString) + attr.put(ATTRIBUTE_ARRIVAL_TIME, arrivalTime.toString) + attr.put(ATTRIBUTE_MODE, mode.value) + attr.put(ATTRIBUTE_LINK_IDS, linkIds.mkString(",")) + attr.put(ATTRIBUTE_LINK_TRAVEL_TIME, linkTravelTime.map(FormatUtils.DECIMAL_3.format).mkString(",")) + attr.put(ATTRIBUTE_PRIMARY_FUEL_TYPE, primaryFuelType) + attr.put(ATTRIBUTE_SECONDARY_FUEL_TYPE, secondaryFuelType) + attr.put(ATTRIBUTE_PRIMARY_FUEL, primaryFuelConsumed.toString) + attr.put(ATTRIBUTE_SECONDARY_FUEL, secondaryFuelConsumed.toString) + attr.put(ATTRIBUTE_VEHICLE_CAPACITY, capacity.toString) - attr.put(ATTRIBUTE_START_COORDINATE_X, startX.toString) - attr.put(ATTRIBUTE_START_COORDINATE_Y, startY.toString) - attr.put(ATTRIBUTE_END_COORDINATE_X, endX.toString) - attr.put(ATTRIBUTE_END_COORDINATE_Y, endY.toString) - attr.put(ATTRIBUTE_END_LEG_PRIMARY_FUEL_LEVEL, endLegPrimaryFuelLevel.toString) - attr.put(ATTRIBUTE_END_LEG_SECONDARY_FUEL_LEVEL, endLegSecondaryFuelLevel.toString) - attr.put(ATTRIBUTE_SEATING_CAPACITY, seatingCapacity.toString) - attr.put(ATTRIBUTE_TOLL_PAID, amountPaid.toString) - attr.put(ATTRIBUTE_FROM_STOP_INDEX, fromStopIndex.map(_.toString).getOrElse("")) - attr.put(ATTRIBUTE_TO_STOP_INDEX, toStopIndex.map(_.toString).getOrElse("")) - attr.put(ATTRIBUTE_CURRENT_TRIP_MODE, currentTripMode.getOrElse("")) - attr.put(ATTRIBUTE_PAYLOAD_IDS, payloadIds.mkString(",")) - attr.put(ATTRIBUTE_WEIGHT, weight.toString) - attr.put(ATTRIBUTE_RIDERS, ridersToStr(riders)) - attr.put(EMISSIONS_PROFILE, emissionsProfile.map(BeamVehicleUtils.buildEmissionsString).getOrElse("")) - filledAttrs.set(attr) - attr - } + attr.put(ATTRIBUTE_START_COORDINATE_X, startX.toString) + attr.put(ATTRIBUTE_START_COORDINATE_Y, startY.toString) + attr.put(ATTRIBUTE_END_COORDINATE_X, endX.toString) + attr.put(ATTRIBUTE_END_COORDINATE_Y, endY.toString) + attr.put(ATTRIBUTE_END_LEG_PRIMARY_FUEL_LEVEL, endLegPrimaryFuelLevel.toString) + attr.put(ATTRIBUTE_END_LEG_SECONDARY_FUEL_LEVEL, endLegSecondaryFuelLevel.toString) + attr.put(ATTRIBUTE_SEATING_CAPACITY, seatingCapacity.toString) + attr.put(ATTRIBUTE_TOLL_PAID, amountPaid.toString) + attr.put(ATTRIBUTE_FROM_STOP_INDEX, fromStopIndex.map(_.toString).getOrElse("")) + attr.put(ATTRIBUTE_TO_STOP_INDEX, toStopIndex.map(_.toString).getOrElse("")) + attr.put(ATTRIBUTE_CURRENT_TRIP_MODE, currentTripMode.getOrElse("")) + attr.put(ATTRIBUTE_PAYLOAD_IDS, payloadIds.mkString(",")) + attr.put(ATTRIBUTE_WEIGHT, weight.toString) + attr.put(ATTRIBUTE_RIDERS, ridersToStr(riders)) + attr.put(EMISSIONS_PROFILE, emissionsProfile.map(BeamVehicleUtils.buildEmissionsString).getOrElse("")) + attr } } @@ -146,15 +139,15 @@ object PathTraversalEvent { numPass: Int, beamLeg: BeamLeg, currentTripMode: Option[String], - primaryFuelConsumed: Double, - secondaryFuelConsumed: Double, - endLegPrimaryFuelLevel: Double, - endLegSecondaryFuelLevel: Double, - amountPaid: Double, - payloadIds: IndexedSeq[Id[PayloadPlan]], - weight: Double, + primaryFuelConsumed: Float, + secondaryFuelConsumed: Float, + endLegPrimaryFuelLevel: Float, + endLegSecondaryFuelLevel: Float, + amountPaid: Float, + payloadIds: Array[Id[PayloadPlan]], + weight: Float, emissionsProfile: Option[EmissionsProfile], - riders: IndexedSeq[Id[Person]] + riders: Array[Id[Person]] ): PathTraversalEvent = { new PathTraversalEvent( time = time, @@ -171,11 +164,11 @@ object PathTraversalEvent { mode = beamLeg.mode, legLength = beamLeg.travelPath.distanceInM, linkIds = beamLeg.travelPath.linkIds, - linkTravelTime = beamLeg.travelPath.linkTravelTime, - startX = beamLeg.travelPath.startPoint.loc.getX, - startY = beamLeg.travelPath.startPoint.loc.getY, - endX = beamLeg.travelPath.endPoint.loc.getX, - endY = beamLeg.travelPath.endPoint.loc.getY, + linkTravelTime = beamLeg.travelPath.linkTravelTime.map(_.toFloat), + startX = beamLeg.travelPath.startPoint.loc.getX.toFloat, + startY = beamLeg.travelPath.startPoint.loc.getY.toFloat, + endX = beamLeg.travelPath.endPoint.loc.getX.toFloat, + endY = beamLeg.travelPath.endPoint.loc.getY.toFloat, primaryFuelConsumed = primaryFuelConsumed, secondaryFuelConsumed = secondaryFuelConsumed, endLegPrimaryFuelLevel = endLegPrimaryFuelLevel, @@ -209,23 +202,23 @@ object PathTraversalEvent { val mode: BeamMode = BeamMode.fromString(attr(ATTRIBUTE_MODE)).get val legLength: Double = attr(ATTRIBUTE_LENGTH).toDouble val linkIdsAsStr = Option(attr(ATTRIBUTE_LINK_IDS)).getOrElse("") - val linkIds: IndexedSeq[Int] = if (linkIdsAsStr == "") IndexedSeq.empty else linkIdsAsStr.split(",").map(_.toInt) + val linkIds: Array[Int] = if (linkIdsAsStr == "") Array.empty else linkIdsAsStr.split(",").map(_.toInt) val linkTravelTimeStr = attr.getOrElse(ATTRIBUTE_LINK_TRAVEL_TIME, "") - val linkTravelTime: IndexedSeq[Double] = - if (linkTravelTimeStr == null || linkTravelTimeStr == "") IndexedSeq.empty - else linkTravelTimeStr.split(",").map(_.toDouble) - val startX: Double = attr(ATTRIBUTE_START_COORDINATE_X).toDouble - val startY: Double = attr(ATTRIBUTE_START_COORDINATE_Y).toDouble - val endX: Double = attr(ATTRIBUTE_END_COORDINATE_X).toDouble - val endY: Double = attr(ATTRIBUTE_END_COORDINATE_Y).toDouble - val primaryFuelConsumed: Double = attr(ATTRIBUTE_PRIMARY_FUEL).toDouble - val secondaryFuelConsumed: Double = attr(ATTRIBUTE_SECONDARY_FUEL).toDouble - val endLegPrimaryFuelLevel: Double = attr(ATTRIBUTE_END_LEG_PRIMARY_FUEL_LEVEL).toDouble - val endLegSecondaryFuelLevel: Double = attr(ATTRIBUTE_END_LEG_SECONDARY_FUEL_LEVEL).toDouble - val amountPaid: Double = attr(ATTRIBUTE_TOLL_PAID).toDouble - val payloadIds: IndexedSeq[Id[PayloadPlan]] = payloadsFromStr(attr.getOrElse(ATTRIBUTE_PAYLOAD_IDS, "")) - val weight: Double = attr.get(ATTRIBUTE_WEIGHT).fold(0.0)(_.toDouble) - val riders: IndexedSeq[Id[Person]] = ridersFromStr(attr.getOrElse(ATTRIBUTE_RIDERS, "")) + val linkTravelTime: Array[Float] = + if (linkTravelTimeStr == null || linkTravelTimeStr == "") Array.empty + else linkTravelTimeStr.split(",").map(_.toFloat) + val startX: Float = attr(ATTRIBUTE_START_COORDINATE_X).toFloat + val startY: Float = attr(ATTRIBUTE_START_COORDINATE_Y).toFloat + val endX: Float = attr(ATTRIBUTE_END_COORDINATE_X).toFloat + val endY: Float = attr(ATTRIBUTE_END_COORDINATE_Y).toFloat + val primaryFuelConsumed: Float = attr(ATTRIBUTE_PRIMARY_FUEL).toFloat + val secondaryFuelConsumed: Float = attr(ATTRIBUTE_SECONDARY_FUEL).toFloat + val endLegPrimaryFuelLevel: Float = attr(ATTRIBUTE_END_LEG_PRIMARY_FUEL_LEVEL).toFloat + val endLegSecondaryFuelLevel: Float = attr(ATTRIBUTE_END_LEG_SECONDARY_FUEL_LEVEL).toFloat + val amountPaid: Float = attr(ATTRIBUTE_TOLL_PAID).toFloat + val payloadIds: Array[Id[PayloadPlan]] = payloadsFromStr(attr.getOrElse(ATTRIBUTE_PAYLOAD_IDS, "")) + val weight: Float = attr.get(ATTRIBUTE_WEIGHT).fold(0.0f)(_.toFloat) + val riders: Array[Id[Person]] = ridersFromStr(attr.getOrElse(ATTRIBUTE_RIDERS, "")) val fromStopIndex: Option[Int] = attr.get(ATTRIBUTE_FROM_STOP_INDEX).flatMap(Option(_)).flatMap(x => if (x == "") None else Some(x.toInt)) val toStopIndex: Option[Int] = @@ -268,20 +261,20 @@ object PathTraversalEvent { ) } - private def ridersFromStr(ridersStr: String): IndexedSeq[Id[Person]] = { + private def ridersFromStr(ridersStr: String): Array[Id[Person]] = { if (ridersStr.isEmpty) { - Vector() + Array() } else { - ridersStr.split(":").toIndexedSeq.map(Id.create(_, classOf[Person])) + ridersStr.split(":").map(Id.create(_, classOf[Person])) } } - private def payloadsFromStr(str: String): IndexedSeq[Id[PayloadPlan]] = { - if (str.isEmpty) IndexedSeq.empty + private def payloadsFromStr(str: String): Array[Id[PayloadPlan]] = { + if (str.isEmpty) Array.empty else str.split(',').map(_.createId[PayloadPlan]) } - private def ridersToStr(riders: IndexedSeq[Id[Person]]): String = { + private def ridersToStr(riders: Array[Id[Person]]): String = { riders.mkString(":") } } diff --git a/src/main/scala/beam/agentsim/events/handling/BeamEventsWriterParquet.scala b/src/main/scala/beam/agentsim/events/handling/BeamEventsWriterParquet.scala index 476a353eaf7..1500c147246 100644 --- a/src/main/scala/beam/agentsim/events/handling/BeamEventsWriterParquet.scala +++ b/src/main/scala/beam/agentsim/events/handling/BeamEventsWriterParquet.scala @@ -97,7 +97,13 @@ class BeamEventsWriterParquet( } override def closeFile(): Unit = { - parquetWriter.close() + if (parquetWriter != null) { + try { + parquetWriter.close() + } catch { + case e: Exception => logger.error("Error closing ParquetWriter", e) + } + } } def toGenericDataRecord(event: Event, columnNames: Seq[String]): GenericData.Record = { diff --git a/src/main/scala/beam/agentsim/infrastructure/ChargingFunctions.scala b/src/main/scala/beam/agentsim/infrastructure/ChargingFunctions.scala index 506bd4896bd..afc5fe6b321 100644 --- a/src/main/scala/beam/agentsim/infrastructure/ChargingFunctions.scala +++ b/src/main/scala/beam/agentsim/infrastructure/ChargingFunctions.scala @@ -2,7 +2,7 @@ package beam.agentsim.infrastructure import beam.agentsim.agents.vehicles.FuelType.FuelType import beam.agentsim.agents.vehicles.{BeamVehicleType, VehicleManager} -import beam.agentsim.infrastructure.ParkingInquiry.ParkingActivityType.{Charge, EnRoute, Home, Work} +import beam.agentsim.infrastructure.ParkingInquiry.ParkingActivityType._ import beam.agentsim.infrastructure.ParkingInquiry.ParkingSearchMode import beam.agentsim.infrastructure.charging.ChargingPointType import beam.agentsim.infrastructure.parking.ParkingZoneSearch.{ParkingAlternative, ParkingZoneSearchResult} @@ -121,8 +121,7 @@ class ChargingFunctions( val verifyCharger = inquiry.beamVehicle.isDefined && inquiry.beamVehicle.get.beamVehicleType.chargingCapability.isDefined && ( inquiry.searchMode == ParkingSearchMode.EnRouteCharging || - inquiry.parkingActivityType == Charge || - inquiry.parkingActivityType == EnRoute + inquiry.parkingActivityType == Charge ) if (!verifyCharger) { return true @@ -299,10 +298,12 @@ class ChargingFunctions( import ParkingSearchMode._ if (parkingConfig.forceParkingType && !List(EnRouteCharging, Init).contains(inquiry.searchMode)) { inquiry.parkingActivityType match { - case Home => Set(ParkingType.Residential) - case Work => Set(ParkingType.Workplace) - case Charge => Set(ParkingType.Workplace, ParkingType.Public, ParkingType.Residential) - case _ => Set(ParkingType.Public) + case Home => Set(ParkingType.Residential) + case Work => Set(ParkingType.Workplace) + case Charge => Set(ParkingType.Public) + case Commercial => Set(ParkingType.Commercial) + case Depot => Set(ParkingType.Depot) + case _ => Set(ParkingType.Public) } } else super[ParkingFunctions].getPreferredParkingTypes(inquiry) } diff --git a/src/main/scala/beam/agentsim/infrastructure/HierarchicalParkingManager.scala b/src/main/scala/beam/agentsim/infrastructure/HierarchicalParkingManager.scala index 6afdf1897b1..13a863887dd 100644 --- a/src/main/scala/beam/agentsim/infrastructure/HierarchicalParkingManager.scala +++ b/src/main/scala/beam/agentsim/infrastructure/HierarchicalParkingManager.scala @@ -5,10 +5,8 @@ import beam.agentsim.agents.vehicles.VehicleCategory.VehicleCategory import beam.agentsim.agents.vehicles.VehicleManager.ReservedFor import beam.agentsim.infrastructure.HierarchicalParkingManager._ import beam.agentsim.infrastructure.charging.ChargingPointType -import beam.agentsim.infrastructure.parking.ParkingZone.UbiqiutousParkingAvailability import beam.agentsim.infrastructure.parking._ import beam.agentsim.infrastructure.taz.{TAZ, TAZTreeMap} -import beam.router.BeamRouter.Location import beam.sim.common.GeoUtils import beam.sim.config.BeamConfig import beam.utils.matsim_conversion.ShapeUtils @@ -66,17 +64,10 @@ class HierarchicalParkingManager( ) ) - val DefaultParkingZone: ParkingZone = - ParkingZone.defaultInit( - TAZ.DefaultTAZId, - ParkingType.Public, - UbiqiutousParkingAvailability - ) - /** * For each TAZ it contains a Map: ParkingZoneDescription -> ParkingZoneTreeMap */ - protected val tazSearchMap: Map[Id[TAZ], Map[ParkingZoneDescription, QuadTree[ParkingZone]]] = + private val tazSearchMap: Map[Id[TAZ], Map[ParkingZoneDescription, QuadTree[ParkingZone]]] = createDescriptionToZonesMapForEachTaz(parkingZones, tazMap.idToTAZMapping) if (checkThatNumberOfStallsMatch) { @@ -103,7 +94,7 @@ class HierarchicalParkingManager( searchFunctions.get.searchForParkingStall(inquiry) val (parkingStall: ParkingStall, parkingZone: ParkingZone) = - if (TAZ.isSpecialTazId(tazParkingStall.tazId)) tazParkingStall -> DefaultParkingZone + if (TAZ.isSpecialTazId(tazParkingStall.tazId)) tazParkingStall -> ParkingZone.DefaultParkingZone else { val descriptionToZone = tazSearchMap(tazParkingZone.tazId) findAppropriateLinkParkingZoneWithinTaz(tazParkingZone, descriptionToZone, inquiry.destinationUtm.loc) match { @@ -118,7 +109,8 @@ class HierarchicalParkingManager( "Cannot find link parking parking zone for taz zone {}. Parallel changing of stallsAvailable?", tazParkingZone ) - lastResortStallAndZone(inquiry.destinationUtm.loc) + val (newStall, _) = ParkingStall.lastResortStall(inquiry.destinationUtm.loc, new Random(seed)) + newStall } } @@ -171,7 +163,7 @@ class HierarchicalParkingManager( */ override def processReleaseParkingStall(release: ReleaseParkingStall): Boolean = { val parkingZoneId = release.stall.parkingZoneId - if (parkingZoneId == ParkingZone.DefaultParkingZoneId) { + if (parkingZoneId == ParkingZone.DefaultParkingZone.parkingZoneId) { // this is an infinitely available resource; no update required logger.debug("Releasing a stall in the default/emergency zone") true @@ -238,7 +230,7 @@ object HierarchicalParkingManager { timeRestrictions: Map[VehicleCategory, Range] ) - object ParkingZoneDescription { + private object ParkingZoneDescription { def describeParkingZone(zone: ParkingZone): ParkingZoneDescription = { new ParkingZoneDescription( diff --git a/src/main/scala/beam/agentsim/infrastructure/InfrastructureFunctions.scala b/src/main/scala/beam/agentsim/infrastructure/InfrastructureFunctions.scala index 4c46d8edb25..5cb6f2c7587 100644 --- a/src/main/scala/beam/agentsim/infrastructure/InfrastructureFunctions.scala +++ b/src/main/scala/beam/agentsim/infrastructure/InfrastructureFunctions.scala @@ -3,7 +3,6 @@ package beam.agentsim.infrastructure import beam.agentsim.agents.choice.logit.UtilityFunctionOperation import beam.agentsim.infrastructure.ParkingInquiry.ParkingActivityType import beam.agentsim.infrastructure.charging.ChargingPointType -import beam.agentsim.infrastructure.parking.ParkingZone.UbiqiutousParkingAvailability import beam.agentsim.infrastructure.parking.ParkingZoneSearch._ import beam.agentsim.infrastructure.parking._ import beam.agentsim.infrastructure.taz.{TAZ, TAZTreeMap} @@ -80,14 +79,7 @@ abstract class InfrastructureFunctions( import InfrastructureFunctions._ - val DefaultParkingZone: ParkingZone = - ParkingZone.defaultInit( - TAZ.DefaultTAZId, - ParkingType.Public, - UbiqiutousParkingAvailability - ) - - val parkingZoneSearchConfiguration: ParkingZoneSearchConfiguration = + private val parkingZoneSearchConfiguration: ParkingZoneSearchConfiguration = ParkingZoneSearchConfiguration( minSearchRadius, maxSearchRadius, @@ -245,12 +237,11 @@ abstract class InfrastructureFunctions( zoneCollections.get(parkingZone.tazId).foreach(_.releaseZone(parkingZone)) result } - } object InfrastructureFunctions { - def chargingTypeToNo( + private def chargingTypeToNo( parkingZonesSampled: List[(Id[ParkingZoneId], Option[ChargingPointType], ParkingType, Double)] ): String = { parkingZonesSampled @@ -266,7 +257,7 @@ object InfrastructureFunctions { .mkString(", ") } - def parkingTypeToNo( + private def parkingTypeToNo( parkingZonesSampled: List[(Id[ParkingZoneId], Option[ChargingPointType], ParkingType, Double)] ): String = { parkingZonesSampled @@ -277,7 +268,7 @@ object InfrastructureFunctions { .mkString(", ") } - def listOfCosts( + private def listOfCosts( parkingZonesSampled: List[(Id[ParkingZoneId], Option[ChargingPointType], ParkingType, Double)] ): String = { parkingZonesSampled diff --git a/src/main/scala/beam/agentsim/infrastructure/InfrastructureUtils.scala b/src/main/scala/beam/agentsim/infrastructure/InfrastructureUtils.scala index 589fc8e3f2c..563319926a6 100644 --- a/src/main/scala/beam/agentsim/infrastructure/InfrastructureUtils.scala +++ b/src/main/scala/beam/agentsim/infrastructure/InfrastructureUtils.scala @@ -58,7 +58,10 @@ object InfrastructureUtils extends LazyLogging { ( beamConfig.beam.agentsim.agents.freight.carrierParkingFilePath.getOrElse(""), VehicleManager - .createOrGetReservedFor(beamConfig.beam.agentsim.agents.freight.name, VehicleManager.TypeEnum.Freight), + .createOrGetReservedFor( + beamConfig.beam.agentsim.agents.freight.name, + Some(VehicleManager.TypeEnum.Freight) + ), Seq(ParkingType.Workplace) ) ) @@ -66,7 +69,7 @@ object InfrastructureUtils extends LazyLogging { val ridehailParkingFiles = beamConfig.beam.agentsim.agents.rideHail.managers.map(managerConfig => ( managerConfig.initialization.parking.filePath, - VehicleManager.createOrGetReservedFor(managerConfig.name, VehicleManager.TypeEnum.RideHail), + VehicleManager.createOrGetReservedFor(managerConfig.name, Some(VehicleManager.TypeEnum.RideHail)), Seq(ParkingType.Workplace) ) ) diff --git a/src/main/scala/beam/agentsim/infrastructure/ParallelParkingManager.scala b/src/main/scala/beam/agentsim/infrastructure/ParallelParkingManager.scala index 8639b77d70a..e31ae376b89 100644 --- a/src/main/scala/beam/agentsim/infrastructure/ParallelParkingManager.scala +++ b/src/main/scala/beam/agentsim/infrastructure/ParallelParkingManager.scala @@ -61,7 +61,7 @@ class ParallelParkingManager( ) ) - protected val tazToWorker: Map[Id[_], Worker] = + private val tazToWorker: Map[Id[_], Worker] = mapTazToWorker(workers) + (TAZ.EmergencyTAZId -> emergencyWorker) + (TAZ.DefaultTAZId -> emergencyWorker) protected def createWorker(cluster: ParkingCluster): Worker = { diff --git a/src/main/scala/beam/agentsim/infrastructure/ParkingFunctions.scala b/src/main/scala/beam/agentsim/infrastructure/ParkingFunctions.scala index 613bc503e78..57e3b2684fc 100644 --- a/src/main/scala/beam/agentsim/infrastructure/ParkingFunctions.scala +++ b/src/main/scala/beam/agentsim/infrastructure/ParkingFunctions.scala @@ -10,6 +10,8 @@ import beam.agentsim.infrastructure.taz.{TAZ, TAZTreeMap} import beam.sim.config.BeamConfig.Beam.Agentsim.Agents.Parking import org.locationtech.jts.geom.Envelope import org.matsim.api.core.v01.{Coord, Id} +import org.matsim.core.utils.collections.QuadTree +import beam.agentsim.infrastructure.ParkingInquiry.ParkingActivityType._ import scala.util.Random @@ -109,6 +111,7 @@ class ParkingFunctions( ): Boolean = { if (zone.chargingPointType.isDefined) throw new RuntimeException("ParkingFunctions expect only stalls without charging points") + val preferredParkingTypes = getPreferredParkingTypes(inquiry) val canCarParkHere: Boolean = canThisCarParkHere(zone, inquiry, preferredParkingTypes) canCarParkHere @@ -133,21 +136,20 @@ class ParkingFunctions( ) ParkingZoneSearch.ParkingZoneSearchResult(newStall, DefaultParkingZone) case _ => - inquiry.parkingActivityType match { - case ParkingActivityType.Home if inquiry.searchMode != ParkingSearchMode.EnRouteCharging => - val newStall = ParkingStall.defaultResidentialStall(inquiry.destinationUtm.loc, inquiry.activityType) - ParkingZoneSearch.ParkingZoneSearchResult(newStall, DefaultParkingZone) + val destinationLocation = inquiry.destinationUtm.loc + val taz = tazTreeMap.getTAZ(destinationLocation) + val (newStall, zone) = inquiry.parkingActivityType match { + case ParkingActivityType.Home => + ParkingStall.defaultStallAtLocation(destinationLocation, taz.tazId, ParkingType.Residential) + case ParkingActivityType.Depot => + ParkingStall.defaultStallAtLocation(destinationLocation, taz.tazId, ParkingType.Depot) + case ParkingActivityType.Commercial => + ParkingStall.obstructiveStallAtLocation(destinationLocation, taz.tazId, ParkingType.Commercial) case _ => // didn't find any stalls, so, as a last resort, create a very expensive stall - val boxAroundRequest = new Envelope( - inquiry.destinationUtm.loc.getX + 100, - inquiry.destinationUtm.loc.getX - 100, - inquiry.destinationUtm.loc.getY + 100, - inquiry.destinationUtm.loc.getY - 100 - ) - val newStall = ParkingStall.lastResortStall(boxAroundRequest, new Random(seed)) - ParkingZoneSearch.ParkingZoneSearchResult(newStall, DefaultParkingZone) + ParkingStall.lastResortStall(destinationLocation, new Random(seed)) } + ParkingZoneSearch.ParkingZoneSearchResult(newStall, zone) } Some(output) } @@ -218,7 +220,12 @@ class ParkingFunctions( .forall(_.contains(inquiry.destinationUtm.time % (24 * 3600))) ) - validParkingType && isValidTime + val isValidManager = + inquiry.beamVehicle.forall { vehicle => + zone.reservedFor == VehicleManager.AnyManager || vehicle.vehicleManagerId.get() == zone.reservedFor.managerId + } + + validParkingType && isValidTime && isValidManager } /** @@ -230,19 +237,28 @@ class ParkingFunctions( protected def getPreferredParkingTypes(inquiry: ParkingInquiry): Set[ParkingType] = { // a lookup for valid parking types based on this inquiry if (inquiry.searchMode == ParkingSearchMode.EnRouteCharging) { - Set(ParkingType.Public) + inquiry.parkingActivityType match { + case Commercial => Set(ParkingType.Commercial, ParkingType.Depot) + case Depot => Set(ParkingType.Commercial, ParkingType.Depot) + case _ => Set(ParkingType.Public, ParkingType.Depot) + } } else if (inquiry.searchMode == ParkingSearchMode.Init) { inquiry.parkingActivityType match { - case ParkingActivityType.Home => Set(ParkingType.Residential) - case ParkingActivityType.Work => Set(ParkingType.Workplace) - case _ => Set(ParkingType.Public) + case Home => Set(ParkingType.Residential) + case Work => Set(ParkingType.Workplace) + case Depot => Set(ParkingType.Depot) + case ParkingActivityType.Freight => Set(ParkingType.Depot) + case_ => Set(ParkingType.Public) } } else { inquiry.parkingActivityType match { - case ParkingActivityType.Home => Set(ParkingType.Residential, ParkingType.Public) - case ParkingActivityType.Work => Set(ParkingType.Workplace, ParkingType.Public) - case ParkingActivityType.Charge => Set(ParkingType.Workplace, ParkingType.Public, ParkingType.Residential) - case _ => Set(ParkingType.Public) + case Home => Set(ParkingType.Residential, ParkingType.Public) + case Work => Set(ParkingType.Workplace, ParkingType.Public) + case Charge => Set(ParkingType.Public) + case Commercial => Set(ParkingType.Commercial) + case Depot => Set(ParkingType.Depot) + case ParkingActivityType.Freight => Set(ParkingType.Commercial, ParkingType.Depot) + case_ => Set(ParkingType.Public) } } } diff --git a/src/main/scala/beam/agentsim/infrastructure/ParkingInquiry.scala b/src/main/scala/beam/agentsim/infrastructure/ParkingInquiry.scala index 969154fda97..f9b7b93a4b3 100644 --- a/src/main/scala/beam/agentsim/infrastructure/ParkingInquiry.scala +++ b/src/main/scala/beam/agentsim/infrastructure/ParkingInquiry.scala @@ -42,6 +42,7 @@ case class ParkingInquiry( originUtm: Option[SpaceTime] = None, triggerId: Long ) extends HasTriggerId { + val parkingActivityType: ParkingActivityType = activityTypeStringToEnum(activityType) val departureLocation: Option[Coord] = searchMode match { @@ -69,23 +70,55 @@ object ParkingInquiry extends LazyLogging { case object Wherever extends ParkingActivityType case object Home extends ParkingActivityType case object Work extends ParkingActivityType - case object EnRoute extends ParkingActivityType + case object Commercial extends ParkingActivityType + case object Depot extends ParkingActivityType case object IDLE extends ParkingActivityType + case object Freight extends ParkingActivityType } + // Pre-compiled lookup table for exact matches (O(1) lookup) + private val exactMatches = Map( + "home" -> ParkingActivityType.Home, + "work" -> ParkingActivityType.Work, + "charge" -> ParkingActivityType.Charge, + "wherever" -> ParkingActivityType.Wherever, + "eatout" -> ParkingActivityType.Wherever, + "othdiscr" -> ParkingActivityType.Wherever, + "othmaint" -> ParkingActivityType.Wherever, + "school" -> ParkingActivityType.Wherever, + "escort" -> ParkingActivityType.Wherever, + "social" -> ParkingActivityType.Wherever, + "idle" -> ParkingActivityType.IDLE, + "depot" -> ParkingActivityType.Freight, + "commercial" -> ParkingActivityType.Freight, + "loading" -> ParkingActivityType.Freight, + "unloading" -> ParkingActivityType.Freight, + "warehouse" -> ParkingActivityType.Freight + ) + + // Pre-compiled prefix patterns for startsWith checks + private val freightPrefixes = Set("depot", "commercial", "loading", "unloading", "warehouse") + def activityTypeStringToEnum(activityType: String): ParkingActivityType = { - activityType.toLowerCase match { - case "home" => ParkingActivityType.Home - case "work" => ParkingActivityType.Work - case "charge" => ParkingActivityType.Charge - case "wherever" => ParkingActivityType.Wherever - case "idle" => ParkingActivityType.IDLE - case otherType if otherType.contains("enroute") => ParkingActivityType.Charge - case otherType if otherType.contains("home") => ParkingActivityType.Home - case otherType if otherType.contains("work") => ParkingActivityType.Work - case otherType => - logger.debug(s"This Parking Activity Type ($otherType) has not been defined") - ParkingActivityType.Wherever + val lowerType = activityType.toLowerCase + + // Try exact match first (fastest - O(1)) + exactMatches.get(lowerType) match { + case Some(result) => result + case None => + // Check prefixes (only if exact match failed) + if (freightPrefixes.exists(lowerType.startsWith)) { + ParkingActivityType.Freight + } else if (lowerType.contains("enroute")) { + ParkingActivityType.Charge + } else if (lowerType.contains("home")) { + ParkingActivityType.Home + } else if (lowerType.contains("work")) { + ParkingActivityType.Work + } else { + logger.debug(s"This Parking Activity Type ($lowerType) has not been defined") + ParkingActivityType.Wherever + } } } diff --git a/src/main/scala/beam/agentsim/infrastructure/ParkingStall.scala b/src/main/scala/beam/agentsim/infrastructure/ParkingStall.scala index bbf441038dd..1d2662e8d94 100755 --- a/src/main/scala/beam/agentsim/infrastructure/ParkingStall.scala +++ b/src/main/scala/beam/agentsim/infrastructure/ParkingStall.scala @@ -62,98 +62,93 @@ object ParkingStall { * @param coord the location for the stall * @return a new parking stall with the default Id[Taz] and parkingZoneId */ - def defaultStall(coord: Coord): ParkingStall = ParkingStall( - tazId = TAZ.DefaultTAZId, - parkingZoneId = ParkingZone.DefaultParkingZoneId, - locationUTM = coord, - costInDollars = 0.0, - chargingPointType = None, - pricingModel = None, - parkingType = ParkingType.Public, - activityType = "default", + def defaultStall(coord: Coord): (ParkingStall, ParkingZone) = { + val newStall = ParkingStall( + tazId = TAZ.DefaultTAZId, + parkingZoneId = ParkingZone.DefaultParkingZone.parkingZoneId, + locationUTM = coord, + costInDollars = 0.0, + chargingPointType = None, + pricingModel = None, + parkingType = ParkingType.Public, + activityType = "default", reservedFor = VehicleManager.AnyManager - ) + )(newStall, ParkingZone.DefaultParkingZone) + } /** * take a stall from the infinite parking zone, with a random location by default from planet-wide UTM values * - * @param random random number generator - * @param boundingBox bounding box + * @param generateRandomLocationUsingThis random number generator * @param costInDollars the cost of this stall * @return a stall that costs a lot but at least it exists. it's coordinate can be anywhere on the planet. for routing, the nearest link should be found using Beam Geotools. */ def lastResortStall( - boundingBox: Envelope, - random: Random = Random, + location: Location, + random: Random, costInDollars: Double = 50.0 - ): ParkingStall = { + ): (ParkingStall, ParkingZone) = { + val boundingBox = new Envelope( + location.getX + 2000, + location.getX - 2000, + location.getY + 2000, + location.getY - 2000 + ) val x = random.nextDouble() * (boundingBox.getMaxX - boundingBox.getMinX) + boundingBox.getMinX val y = random.nextDouble() * (boundingBox.getMaxY - boundingBox.getMinY) + boundingBox.getMinY - + val stallLocation = new Coord(x, y) ParkingStall( tazId = TAZ.EmergencyTAZId, - parkingZoneId = ParkingZone.DefaultParkingZoneId, - locationUTM = new Coord(x, y), + parkingZoneId = ParkingZone.DefaultParkingZone.parkingZoneId, + locationUTM = stallLocation, costInDollars = costInDollars, chargingPointType = None, - pricingModel = Some { - PricingModel.FlatFee(costInDollars.toInt) - }, + pricingModel = Some { PricingModel.FlatFee(costInDollars.toInt) }, parkingType = ParkingType.Public, activityType = "emergency", reservedFor = VehicleManager.AnyManager - ) + ) -> ParkingZone.DefaultParkingZone } - //#Art - - /** - * take a stall from the infinite parking zone, with a location at the request (e.g. traveler's home location). - * This should only kick in when all other (potentially non-free, non-colocated) stalls in the search area are - * exhausted - * - * @param locationUTM request location (home) - * @return a stall that is free and located at the person's home. - */ - def defaultResidentialStall(locationUTM: Location, activity: String): ParkingStall = ParkingStall( - tazId = TAZ.DefaultTAZId, - parkingZoneId = ParkingZone.DefaultParkingZoneId, - locationUTM = locationUTM, - costInDollars = 0.0, - chargingPointType = None, - pricingModel = Some(PricingModel.FlatFee(0)), - parkingType = ParkingType.Residential, - activityType = activity, - reservedFor = VehicleManager.AnyManager - ) + def obstructiveStallAtLocation( + location: Location, + tazId: Id[TAZ], + parkingType: ParkingType, + costInDollars: Double = CostOfEmergencyStallInDollars + ): (ParkingStall, ParkingZone) = { + ParkingStall( + tazId = tazId, + parkingZoneId = ParkingZone.ObstructiveParkingZone.parkingZoneId, + locationUTM = location, + costInDollars = costInDollars, + chargingPointType = None, + pricingModel = Some { PricingModel.FlatFee(costInDollars.toInt) }, + parkingType = parkingType, + reservedFor = VehicleManager.AnyManager + ) -> ParkingZone.ObstructiveParkingZone + } - def doubleParkingStall(tazId: Id[TAZ], locationUTM: Location, activity: String): ParkingStall = ParkingStall( - tazId = tazId, - parkingZoneId = ParkingZone.DefaultParkingZoneId, - locationUTM = locationUTM, - costInDollars = 0.0, - chargingPointType = None, - pricingModel = Some(PricingModel.FlatFee(0)), - parkingType = ParkingType.DoubleParking, - activityType = activity, - reservedFor = VehicleManager.AnyManager - ) + def defaultStallAtLocation( + location: Location, + tazId: Id[TAZ], + parkingType: ParkingType, + costInDollars: Double = CostOfEmergencyStallInDollars + ): (ParkingStall, ParkingZone) = { + ParkingStall( + tazId = tazId, + parkingZoneId = ParkingZone.DefaultParkingZone.parkingZoneId, + locationUTM = location, + costInDollars = costInDollars, + chargingPointType = None, + pricingModel = Some { + PricingModel.FlatFee(costInDollars.toInt) + }, + parkingType = parkingType, + reservedFor = VehicleManager.AnyManager + ) -> ParkingZone.DefaultParkingZone + } - /** - * @param locationUTM Location - * @return - */ - def defaultFastChargingStall(locationUTM: Location): ParkingStall = ParkingStall( - tazId = TAZ.DefaultTAZId, - parkingZoneId = ParkingZone.DefaultParkingZoneId, - locationUTM = locationUTM, - costInDollars = 0.0, - chargingPointType = Some(ChargingPointType.ChargingStationCcsComboType2), - pricingModel = Some(PricingModel.FlatFee(0)), - parkingType = ParkingType.Public, - activityType = "charging", - reservedFor = VehicleManager.AnyManager - ) + //#Art /** * Convenience method to convert a [[ParkingAlternative]] to a [[ParkingStall]] @@ -178,5 +173,4 @@ object ParkingStall { parkingAlternative.parkingZone.reservedFor ) } - } diff --git a/src/main/scala/beam/agentsim/infrastructure/RideHailDepotFunctions.scala b/src/main/scala/beam/agentsim/infrastructure/RideHailDepotFunctions.scala index 01ab0f951f4..c5338a00ed4 100644 --- a/src/main/scala/beam/agentsim/infrastructure/RideHailDepotFunctions.scala +++ b/src/main/scala/beam/agentsim/infrastructure/RideHailDepotFunctions.scala @@ -144,14 +144,8 @@ class RideHailDepotFunctions( result.copy(parkingStall = updatedParkingStall) case _ => // didn't find any stalls, so, as a last resort, create a very expensive stall - val boxAroundRequest = new Envelope( - inquiry.destinationUtm.loc.getX + 100, - inquiry.destinationUtm.loc.getX - 100, - inquiry.destinationUtm.loc.getY + 100, - inquiry.destinationUtm.loc.getY - 100 - ) - val newStall = ParkingStall.lastResortStall(boxAroundRequest, new Random(seed)) - ParkingZoneSearch.ParkingZoneSearchResult(newStall, DefaultParkingZone) + val (newStall, defaultZone) = ParkingStall.lastResortStall(inquiry.destinationUtm.loc, new Random(seed)) + ParkingZoneSearch.ParkingZoneSearchResult(newStall, defaultZone) } Some(output) } @@ -182,7 +176,7 @@ class RideHailDepotFunctions( * @param tick Int * @return */ - def secondsToServiceQueueAndChargingVehicles( + private def secondsToServiceQueueAndChargingVehicles( parkingZone: ParkingZone, tick: Int ): Int = { @@ -219,7 +213,7 @@ class RideHailDepotFunctions( * @param parkingZoneId ID of the parking zone * @return Parking zone location in UTM. */ - def getParkingZoneLocationUtm(parkingZoneId: Id[ParkingZoneId]): Coord = { + private def getParkingZoneLocationUtm(parkingZoneId: Id[ParkingZoneId]): Coord = { val parkingZone = parkingZones(parkingZoneId) parkingZone.link.fold { tazTreeMap.idToTAZMapping(parkingZone.tazId).coord diff --git a/src/main/scala/beam/agentsim/infrastructure/RideHailDepotNetwork.scala b/src/main/scala/beam/agentsim/infrastructure/RideHailDepotNetwork.scala index 9fa505ca79e..b41779cc44a 100644 --- a/src/main/scala/beam/agentsim/infrastructure/RideHailDepotNetwork.scala +++ b/src/main/scala/beam/agentsim/infrastructure/RideHailDepotNetwork.scala @@ -1,11 +1,10 @@ package beam.agentsim.infrastructure import beam.agentsim.infrastructure.parking.{ParkingZone, ParkingZoneId} -import beam.agentsim.infrastructure.taz.{TAZ, TAZTreeMap} +import beam.agentsim.infrastructure.taz.TAZTreeMap import beam.sim.BeamServices import org.locationtech.jts.geom.Envelope import org.matsim.api.core.v01.Id -import org.matsim.core.utils.collections.QuadTree class RideHailDepotNetwork(override val parkingZones: Map[Id[ParkingZoneId], ParkingZone]) extends ChargingNetwork(parkingZones) { @@ -18,10 +17,10 @@ object RideHailDepotNetwork { // a ride hail agent is searching for a charging depot and is not in service of an activity. // for this reason, a higher max radius is reasonable. - val SearchStartRadius: Double = 40000.0 // meters - val SearchMaxRadius: Int = 80465 // 50 miles, in meters - val FractionOfSameTypeZones: Double = 0.2 // 20% - val MinNumberOfSameTypeZones: Int = 5 + private val SearchStartRadius: Double = 40000.0 // meters + private val SearchMaxRadius: Int = 80465 // 50 miles, in meters + private val FractionOfSameTypeZones: Double = 0.2 // 20% + private val MinNumberOfSameTypeZones: Int = 5 def apply( parkingZones: Map[Id[ParkingZoneId], ParkingZone], diff --git a/src/main/scala/beam/agentsim/infrastructure/TrivialParkingManager.scala b/src/main/scala/beam/agentsim/infrastructure/TrivialParkingManager.scala index 9d6c3f27ff3..3bbc012587a 100644 --- a/src/main/scala/beam/agentsim/infrastructure/TrivialParkingManager.scala +++ b/src/main/scala/beam/agentsim/infrastructure/TrivialParkingManager.scala @@ -9,7 +9,7 @@ class TrivialParkingManager extends Actor { private var nextStallNum = 0 override def receive: Receive = { case request: ParkingInquiry => - val stall = ParkingStall.defaultStall(request.destinationUtm.loc) + val stall = ParkingStall.defaultStall(request.destinationUtm.loc)._1 sender ! ParkingInquiryResponse(stall, request.requestId, request.triggerId) nextStallNum += 1 } @@ -20,7 +20,7 @@ class AnotherTrivialParkingManager(location: Coord) extends LoggingMessageActor private var nextStallNum = 0 override def loggedReceive: Receive = { case request: ParkingInquiry => - val stall = ParkingStall.defaultStall(location) + val stall = ParkingStall.defaultStall(location)._1 sender ! ParkingInquiryResponse(stall, request.requestId, request.triggerId) nextStallNum += 1 } diff --git a/src/main/scala/beam/agentsim/infrastructure/charging/ChargingPointType.scala b/src/main/scala/beam/agentsim/infrastructure/charging/ChargingPointType.scala index 708c888ec70..f644d020135 100644 --- a/src/main/scala/beam/agentsim/infrastructure/charging/ChargingPointType.scala +++ b/src/main/scala/beam/agentsim/infrastructure/charging/ChargingPointType.scala @@ -71,17 +71,17 @@ object ChargingPointType { // these were breaking some tests with a ChargingPoint parsing error caused by Event handlers def apply(s: String): Option[ChargingPointType] = { s.trim.toLowerCase match { - case "householdsocket" => Some(HouseholdSocket) - case "bluehouseholdsocket" => Some(BlueHouseholdSocket) - case "cee16asocket" => Some(Cee16ASocket) - case "cee32asocket" => Some(Cee32ASocket) - case "cee63asocket" => Some(Cee63ASocket) - case "chargingstationtype1" => Some(ChargingStationType1) - case "chargingstationtype2" => Some(ChargingStationType2) - case "chargingstationccscombotype1" => Some(ChargingStationCcsComboType1) - case "chargingstationccscombotype2" => Some(ChargingStationCcsComboType2) - case "teslasupercharger" => Some(TeslaSuperCharger) - case "nocharger" | "none" | "" => None + case "householdsocket" => Some(HouseholdSocket) + case "bluehouseholdsocket" => Some(BlueHouseholdSocket) + case "cee16asocket" => Some(Cee16ASocket) + case "cee32asocket" => Some(Cee32ASocket) + case "cee63asocket" => Some(Cee63ASocket) + case "chargingstationtype1" | "level1" => Some(ChargingStationType1) + case "chargingstationtype2" | "level2" => Some(ChargingStationType2) + case "chargingstationccscombotype1" => Some(ChargingStationCcsComboType1) + case "chargingstationccscombotype2" => Some(ChargingStationCcsComboType2) + case "teslasupercharger" => Some(TeslaSuperCharger) + case "nocharger" | "none" | "" => None case CustomChargingPointRegex(id, installedCapacity, currentType) => Some(CustomChargingPoint(id, installedCapacity, currentType)) case _ => diff --git a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingNetwork.scala b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingNetwork.scala index a43ff3d1ab4..9c588b5a4ed 100644 --- a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingNetwork.scala +++ b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingNetwork.scala @@ -12,8 +12,8 @@ abstract class ParkingNetwork(parkingZones: Map[Id[ParkingZoneId], ParkingZone]) protected val searchFunctions: Option[InfrastructureFunctions] // Core - protected var totalStallsInUse: Long = 0L - protected var totalStallsAvailable: Long = parkingZones.map(_._2.stallsAvailable).sum + private var totalStallsInUse: Long = 0L + private var totalStallsAvailable: Long = parkingZones.map(_._2.stallsAvailable).sum /** * @param inquiry ParkingInquiry @@ -51,7 +51,7 @@ abstract class ParkingNetwork(parkingZones: Map[Id[ParkingZoneId], ParkingZone]) */ def processReleaseParkingStall(release: ReleaseParkingStall): Boolean = { val parkingZoneId = release.stall.parkingZoneId - val released: Boolean = if (parkingZoneId == ParkingZone.DefaultParkingZoneId) { + val released: Boolean = if (parkingZoneId == ParkingZone.DefaultParkingZone.parkingZoneId) { // this is an infinitely available resource; no update required logger.debug("Releasing a stall in the default/emergency zone") true diff --git a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingType.scala b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingType.scala index 36491bae9b4..215a6808597 100644 --- a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingType.scala +++ b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingType.scala @@ -31,11 +31,11 @@ object ParkingType { def apply(s: String): ParkingType = { s match { - case "Residential" => Residential - case "Public" => Public - case "Workplace" => Workplace - case "Commercial" => Commercial - case "Depot" => Depot + case "Residential" => Residential + case "Public" => Public + case "Workplace" => Workplace + case "Commercial" => Commercial + case "Depot" => Depot case "DoubleParking" => DoubleParking } } diff --git a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZone.scala b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZone.scala index e8489cab6b0..ab30387b5bc 100644 --- a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZone.scala +++ b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZone.scala @@ -4,7 +4,6 @@ import beam.agentsim.agents.vehicles.VehicleCategory.VehicleCategory import beam.agentsim.agents.vehicles.VehicleManager import beam.agentsim.agents.vehicles.VehicleManager.ReservedFor import beam.agentsim.infrastructure.charging.ChargingPointType -import beam.agentsim.infrastructure.power.SitePowerManager import beam.agentsim.infrastructure.taz.TAZ import com.typesafe.scalalogging.LazyLogging import org.matsim.api.core.v01.Id @@ -34,6 +33,7 @@ class ParkingZone( val pricingModel: Option[PricingModel], val timeRestrictions: Map[VehicleCategory, Range], val link: Option[Link], + val siteId: Id[SitePowerManager], val sitePowerManager: Option[String], val energyStorageCapacityInKWh: Option[Double], val energyStorageSOC: Option[Double] @@ -68,14 +68,48 @@ class ParkingZone( object ParkingZone extends LazyLogging { - val DefaultParkingZoneId: Id[ParkingZoneId] = Id.create("default", classOf[ParkingZoneId]) - // used in place of Int.MaxValue to avoid possible buffer overrun due to async failures // in other words, while stallsAvailable of a ParkingZone should never exceed the numStalls // it started with, it could be possible in the system to happen due to scheduler issues. if // it does, it would be more helpful for it to reflect with a reasonable number, ie., 1000001, // which would tell us that we had 1 extra releaseStall event. - val UbiqiutousParkingAvailability: Int = 1000000 + val UbiquitousParkingAvailability: Int = 1000000 + + val DefaultParkingZone: ParkingZone = { + val defaultParkingZoneId: Id[ParkingZoneId] = Id.create("default", classOf[ParkingZoneId]) + init( + Some(defaultParkingZoneId), + TAZ.DefaultTAZId, + ParkingType.Public, + VehicleManager.AnyManager, + Some(SitePowerManager.createId(defaultParkingZoneId.toString)), + UbiquitousParkingAvailability + ) + } + + val ObstructiveParkingZone: ParkingZone = { + val defaultParkingZoneId: Id[ParkingZoneId] = Id.create("obstructive", classOf[ParkingZoneId]) + init( + Some(defaultParkingZoneId), + TAZ.DefaultTAZId, + ParkingType.Public, + VehicleManager.AnyManager, + Some(SitePowerManager.createId(defaultParkingZoneId.toString)), + UbiquitousParkingAvailability + ) + } + + val EmergencyParkingZone: ParkingZone = { + val defaultParkingZoneId: Id[ParkingZoneId] = Id.create("emergency", classOf[ParkingZoneId]) + init( + Some(defaultParkingZoneId), + TAZ.EmergencyTAZId, + ParkingType.Public, + VehicleManager.AnyManager, + Some(SitePowerManager.createId(defaultParkingZoneId.toString)), + UbiquitousParkingAvailability + ) + } /** * creates a new StallValues object @@ -115,20 +149,6 @@ object ParkingZone extends LazyLogging { energyStorageSOC ) - def defaultInit( - geoId: Id[TAZ], - parkingType: ParkingType, - numStalls: Int - ): ParkingZone = { - init( - Some(DefaultParkingZoneId), - geoId, - parkingType, - VehicleManager.AnyManager, - numStalls - ) - } - def init( parkingZoneIdMaybe: Option[Id[ParkingZoneId]], geoId: Id[TAZ], @@ -171,7 +191,7 @@ object ParkingZone extends LazyLogging { * @return True|False (representing success) wrapped in an effect type */ def releaseStall(parkingZone: ParkingZone): Boolean = - if (parkingZone.parkingZoneId == DefaultParkingZoneId) { + if (parkingZone.parkingZoneId == DefaultParkingZone.parkingZoneId) { // this zone does not exist in memory but it has infinitely many stalls to release true } else if (parkingZone.stallsAvailable + 1 > parkingZone.maxStalls) { @@ -189,7 +209,7 @@ object ParkingZone extends LazyLogging { * @return True|False (representing success) wrapped in an effect type */ def claimStall(parkingZone: ParkingZone): Boolean = - if (parkingZone.parkingZoneId == DefaultParkingZoneId) { + if (parkingZone.parkingZoneId == DefaultParkingZone.parkingZoneId) { // this zone does not exist in memory but it has infinitely many stalls to release true } else if (parkingZone.stallsAvailable - 1 >= 0) { @@ -200,24 +220,6 @@ object ParkingZone extends LazyLogging { false } - /** - * Option-wrapped Array index lookup for Array[ParkingZone] - * - * @param parkingZones collection of parking zones - * @param parkingZoneId an array index - * @return Optional ParkingZone - */ - def getParkingZone( - parkingZones: Map[Id[ParkingZoneId], ParkingZone], - parkingZoneId: Id[ParkingZoneId] - ): Option[ParkingZone] = { - val result = parkingZones.get(parkingZoneId) - if (result.isEmpty) { - logger.warn(s"attempting to access parking zone with illegal parkingZoneId $parkingZoneId, will be ignored") - } - result - } - /** * construct ID of a Parking Zone * @param geoId TAZ ID @@ -238,9 +240,7 @@ object ParkingZone extends LazyLogging { val chargingPointType = chargingPointTypeMaybe.getOrElse("NoCharger") val pricingModel = pricingModelMaybe.getOrElse("Free") val costInCents = pricingModelMaybe.map(x => (x.costInDollars * 100).toInt).getOrElse(0) - createId( - s"zone-${reservedFor}-${geoId}-${parkingType}-${chargingPointType}-${pricingModel}-${costInCents}-$numStalls" - ) + createId(s"zone-$reservedFor-$geoId-$parkingType-$chargingPointType-$pricingModel-$costInCents-$numStalls") } /** diff --git a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZoneFileUtils.scala b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZoneFileUtils.scala index 21410858363..7a871d426c9 100644 --- a/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZoneFileUtils.scala +++ b/src/main/scala/beam/agentsim/infrastructure/parking/ParkingZoneFileUtils.scala @@ -5,7 +5,6 @@ import beam.agentsim.agents.vehicles.VehicleManager.ReservedFor import beam.agentsim.agents.vehicles.{VehicleCategory, VehicleManager} import beam.agentsim.infrastructure.charging.ChargingPointType import beam.agentsim.infrastructure.parking.ParkingZoneSearch.ZoneSearchTree -import beam.agentsim.infrastructure.power.SitePowerManager import beam.agentsim.infrastructure.taz.TAZ import beam.sim.BeamServices import beam.sim.config.BeamConfig @@ -59,7 +58,7 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { * @param maybeChargingPoint charging point type * @return a row describing infinite free parking at this TAZ */ - def defaultParkingRow( + private def defaultParkingRow( geoId: Id[TAZ], parkingType: ParkingType, maybeChargingPoint: Option[ChargingPointType], @@ -70,7 +69,7 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { parkingType.toString, // parkingType PricingModel.FlatFee(0).toString, // pricingModel maybeChargingPoint.map(_.toString).getOrElse("NoCharger"), // chargingPointType - ParkingZone.UbiqiutousParkingAvailability.toString, // numStalls + ParkingZone.UbiquitousParkingAvailability.toString, // numStalls "0", // feeInCents defaultReservedFor.toString, // reservedFor "", // timeRestrictions @@ -413,7 +412,7 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { } } - // values look like Class456Vocational:00:00-14:00|Car:14:00-18:00|Bike:18:00-24:00 + // values look like Class456Vocational|00:00-14:00;Car|14:00-18:00;Bike|18:00-24:00; Option(timeRestrictionsString) .getOrElse("") .split(';') @@ -487,7 +486,6 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { val newCostInDollarsString = (feeInCents * parkingCostScalingFactor / 100.0).toString val reservedFor = validateReservedFor(reservedForString, beamConfig, defaultReservedFor) // parse this row from the source file - val taz = tazString.toUpperCase.createId[TAZ] val parkingType = ParkingType(parkingTypeString) val pricingModel = PricingModel(pricingModelString, newCostInDollarsString) val timeRestrictions = parseTimeRestrictions(timeRestrictionsString) @@ -496,11 +494,18 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { val parkingZoneIdMaybe = if (isBlank(parkingZoneIdString)) Some(ParkingZone.createId(rowNumber.toString)) else Some(ParkingZone.createId(parkingZoneIdString)) - val linkMaybe = !isBlank(locationXString) && !isBlank(locationYString) match { - case true if beamServices.isDefined => - val coord = new Coord(locationXString.toDouble, locationYString.toDouble) + + val coordMaybe: Option[Coord] = for { + xLoc <- Option(locationXString).filterNot(isBlank) + yLoc <- Option(locationYString).filterNot(isBlank) + x <- Try(xLoc.toDouble).toOption + y <- Try(yLoc.toDouble).toOption + } yield new Coord(x, y) + + val linkMaybe = coordMaybe match { + case Some(coord) if beamServices.isDefined => Some(NetworkUtils.getNearestLink(beamServices.get.beamScenario.network, beamServices.get.geo.wgs2Utm(coord))) - case false if beamServices.isDefined && reservedFor.managerType == VehicleManager.TypeEnum.Household => + case None if beamServices.isDefined && reservedFor.managerType == VehicleManager.TypeEnum.Household => getHouseholdLocation(beamServices.get, reservedFor.managerId) map { homeCoord => NetworkUtils.getNearestLink( beamServices.get.beamScenario.network, @@ -509,6 +514,41 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { } case _ => None } + + val geoMap = beamServices.map(_.beamScenario.tazTreeMap) + + val tazMaybe: Option[Id[TAZ]] = (Option(tazString), geoMap) match { + case (Some(tazId), _) => + Some(tazId.toUpperCase.createId[TAZ]) + case (None, Some(tazTreeMap)) => + // Try to get TAZ from link + val tazFromLink = for { + link <- linkMaybe + taz <- tazTreeMap.getTAZfromLink(link.getId) + } yield taz.tazId + + // If that fails, try getting TAZ from coordinates + tazFromLink.orElse { + for { + bs <- beamServices + coord <- coordMaybe + utmCoord = bs.geo.wgs2Utm(coord) + taz = tazTreeMap.getTAZ(utmCoord) + } yield taz.tazId + } + case _ => None + } + + // Handle the taz result separately, with meaningful error messages if needed + val taz = tazMaybe.getOrElse { + if (geoMap.isEmpty) + throw new IllegalArgumentException("Missing tazTreeMap: cannot determine TAZ for parking zone") + else if (linkMaybe.isEmpty && coordMaybe.isEmpty) + throw new IllegalArgumentException("Missing location data: cannot determine TAZ for parking zone") + else + throw new IllegalArgumentException("Failed to determine TAZ for parking zone") + } + val sitePowerManagerMaybe = if (isBlank(sitePowerManagerString)) None else Some(sitePowerManagerString) val energyStorageCapacityMaybe = if (isBlank(energyStorageCapacityString)) None else Some(energyStorageCapacityString.toDouble) @@ -568,14 +608,34 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { } private def validateCsvRow(csvRow: jMap): Boolean = { - val allRequiredPresented = Seq("taz", "parkingType", "pricingModel", "chargingPointType", "numStalls", "feeInCents") + // Check required fields are present and non-empty + val allRequiredPresented = Seq("parkingType", "pricingModel", "chargingPointType", "numStalls", "feeInCents") .forall(key => { val value = csvRow.get(key) value != null && value.nonEmpty }) - allRequiredPresented && - Try(csvRow.get("numStalls").toDouble).toOption.exists(_ >= 0) && - Try(csvRow.get("feeInCents").toDouble).toOption.exists(_ >= 0) + + // Check that either TAZ or both location coordinates are provided + val hasTaz = Option(csvRow.get("taz")).exists(_.nonEmpty) + val hasLocationX = Option(csvRow.get("locationX")).exists(_.nonEmpty) + val hasLocationY = Option(csvRow.get("locationY")).exists(_.nonEmpty) + val hasCoordinates = hasLocationX && hasLocationY + + // Validate that at least one location identifier is present + val hasLocationIdentifier = hasTaz || hasCoordinates + + // Validate numeric fields + val validNumericFields = + Try(csvRow.get("numStalls").toDouble).toOption.exists(_ >= 0) && + Try(csvRow.get("feeInCents").toDouble).toOption.exists(_ >= 0) + + // Coordinates must be valid numbers if provided + val validCoordinates = (!hasLocationX && !hasLocationY) || + (hasCoordinates && + Try(csvRow.get("locationX").toDouble).isSuccess && + Try(csvRow.get("locationY").toDouble).isSuccess) + + allRequiredPresented && hasLocationIdentifier && validNumericFields && validCoordinates } /** @@ -720,17 +780,17 @@ object ParkingZoneFileUtils extends ExponentialLazyLogging { def rideHailParkingOutputDataDescriptor: OutputDataDescriptor = OutputDataDescriptorObject("ParkingZoneFileUtils", s"ridehailParking.csv")( """ - taz | Taz id where the parking zone resides - parkingType | Parking type: Residential, Workplace, Public - pricingModel | Pricing model - chargingPointType | Charging point type - numStalls | Number of stalls - feeInCents | Fee in cents - reservedFor | Id of Vehicle Manager this zone is reserver for - timeRestrictions | Time restrictions for vehicle categories - parkingZoneId | Parking zone id - locationX | X part of a concrete location of this parking zone (if defined) - locationY | Y part of a concrete location of this parking zone (if defined) + taz | Taz id where the parking zone resides + parkingType | Parking type: Residential, Workplace, Public + pricingModel | Pricing model + chargingPointType | Charging point type + numStalls | Number of stalls + feeInCents | Fee in cents + reservedFor | Id of Vehicle Manager this zone is reserver for + timeRestrictions | Time restrictions for vehicle categories + parkingZoneId | Parking zone id + locationX | X part of a concrete location of this parking zone (if defined) + locationY | Y part of a concrete location of this parking zone (if defined) sitePowerManager | Site power manager energyStorageCapacityInKWh | Energy storage capacity in KWh energyStorageSOC | Energy storage state of charge diff --git a/src/main/scala/beam/analysis/RideHailFleetAnalysis.scala b/src/main/scala/beam/analysis/RideHailFleetAnalysis.scala index 76de8c353ec..d7bed223c4c 100644 --- a/src/main/scala/beam/analysis/RideHailFleetAnalysis.scala +++ b/src/main/scala/beam/analysis/RideHailFleetAnalysis.scala @@ -109,28 +109,28 @@ class RideHailFleetAnalysisInternal( if (ev && isCAV) { collectEvent( rideHailEvCav, - pathTraversalEvent.copy(time = pathTraversalEvent.departureTime.toDouble - 0.5), + pathTraversalEvent.copy(time = pathTraversalEvent.departureTime - 0.5f), vehicle, pathTraversalEvent.time ) } else if (ev && !isCAV) { collectEvent( ridehailEvNonCav, - pathTraversalEvent.copy(time = pathTraversalEvent.departureTime.toDouble - 0.5), + pathTraversalEvent.copy(time = pathTraversalEvent.departureTime - 0.5f), vehicle, pathTraversalEvent.time ) } else if (!ev && isCAV) { collectEvent( rideHailNonEvCav, - pathTraversalEvent.copy(time = pathTraversalEvent.departureTime.toDouble - 0.5), + pathTraversalEvent.copy(time = pathTraversalEvent.departureTime - 0.5f), vehicle, pathTraversalEvent.time ) } else if (!ev && !isCAV) { collectEvent( rideHailNonEvNonCav, - pathTraversalEvent.copy(time = pathTraversalEvent.departureTime.toDouble - 0.5), + pathTraversalEvent.copy(time = pathTraversalEvent.departureTime - 0.5f), vehicle, pathTraversalEvent.time ) diff --git a/src/main/scala/beam/replanning/ReplanningUtil.scala b/src/main/scala/beam/replanning/ReplanningUtil.scala index 893461aaeac..df3726b3433 100644 --- a/src/main/scala/beam/replanning/ReplanningUtil.scala +++ b/src/main/scala/beam/replanning/ReplanningUtil.scala @@ -2,6 +2,7 @@ package beam.replanning import beam.router.model.EmbodiedBeamTrip import beam.utils.DebugLib +import com.typesafe.scalalogging.LazyLogging import org.matsim.api.core.v01.population._ import org.matsim.core.config.groups.PlanCalcScoreConfigGroup import org.matsim.core.population.PopulationUtils @@ -9,7 +10,7 @@ import org.matsim.core.replanning.selectors.RandomPlanSelector import scala.collection.JavaConverters._ -object ReplanningUtil { +object ReplanningUtil extends LazyLogging { def makeExperiencedMobSimCompatible[T <: Plan, I](person: HasPlansAndId[T, I]): Unit = { val experiencedPlan = person.getSelectedPlan.getCustomAttributes @@ -19,14 +20,21 @@ object ReplanningUtil { if (experiencedPlan != null && experiencedPlan.getPlanElements.size() > 0) { // keep track of the vehicles that been used during previous simulation for (i <- 0 until (experiencedPlan.getPlanElements.size() - 1)) { - experiencedPlan.getPlanElements.get(i) match { - case leg: Leg => - // Make sure it is not `null` - Option(x = person.getSelectedPlan.getPlanElements.get(i).getAttributes.getAttribute("vehicles")).foreach { - attibValue => - leg.getAttributes.putAttribute("vehicles", attibValue) - } - case _ => + if (i >= person.getSelectedPlan.getPlanElements.size() || i >= experiencedPlan.getPlanElements.size()) { + logger.error(s"Skipping index $i: experiencedPlan has more elements (${experiencedPlan.getPlanElements + .size()}) than selectedPlan (${person.getSelectedPlan.getPlanElements.size()}) for person ${person.getId}") + // Skip this iteration instead of exiting the function + // Use "return" only if you want to stop processing the entire function + } else { + experiencedPlan.getPlanElements.get(i) match { + case leg: Leg => + // Make sure it is not `null` + Option(x = person.getSelectedPlan.getPlanElements.get(i).getAttributes.getAttribute("vehicles")).foreach { + attibValue => + leg.getAttributes.putAttribute("vehicles", attibValue) + } + case _ => + } } } // BeamMobsim needs activities with coords diff --git a/src/main/scala/beam/router/BeamTravelTime.scala b/src/main/scala/beam/router/BeamTravelTime.scala new file mode 100644 index 00000000000..735a4fe9f37 --- /dev/null +++ b/src/main/scala/beam/router/BeamTravelTime.scala @@ -0,0 +1,71 @@ +package beam.router + +import beam.utils.NetworkHelper +import org.matsim.api.core.v01.network.Link +import org.matsim.api.core.v01.population.Person +import org.matsim.core.router.util.TravelTime +import org.matsim.vehicles.Vehicle + +/** + * Extension of MATSim's TravelTime interface that adds methods for more efficient + * travel time lookups using integer link IDs directly. + */ +trait BeamTravelTime extends TravelTime { + + /** + * Get travel time using integer link ID directly. + * This avoids the overhead of Link object lookups and string parsing. + */ + def getLinkTravelTime(linkId: Int, time: Double): Double + + /** + * Optional method that can also accept pre-computed link length for further optimization. + */ + def getLinkTravelTime(linkId: Int, time: Double, linkLengthMeters: Double): Double = + getLinkTravelTime(linkId, time) +} + +/** + * Free flow travel time implementation optimized for direct integer ID access. + */ +class BeamFreeFlowTravelTime(networkHelper: NetworkHelper) extends BeamTravelTime { + + // Cache link lengths for faster access + private val linkLengths: Array[Double] = { + val maxLinkId = networkHelper.allLinks.map(link => Integer.parseInt(link.getId.toString)).max + + val lengths = new Array[Double](maxLinkId + 1) + networkHelper.allLinks.foreach { link => + val id = Integer.parseInt(link.getId.toString) + lengths(id) = link.getLength + } + lengths + } + + // Cache link free speeds for faster access + private val linkFreeSpeeds: Array[Double] = { + val maxLinkId = networkHelper.allLinks.map(link => Integer.parseInt(link.getId.toString)).max + + val speeds = new Array[Double](maxLinkId + 1) + networkHelper.allLinks.foreach { link => + val id = Integer.parseInt(link.getId.toString) + speeds(id) = link.getFreespeed + } + speeds + } + + // Original MATSim interface method + override def getLinkTravelTime(link: Link, time: Double, person: Person, vehicle: Vehicle): Double = { + link.getLength / link.getFreespeed + } + + // Optimized method using integer ID + override def getLinkTravelTime(linkId: Int, time: Double): Double = { + linkLengths(linkId) / linkFreeSpeeds(linkId) + } + + // Further optimized method with pre-computed length + override def getLinkTravelTime(linkId: Int, time: Double, linkLengthMeters: Double): Double = { + linkLengthMeters / linkFreeSpeeds(linkId) + } +} diff --git a/src/main/scala/beam/router/LinkTravelTimeContainer.scala b/src/main/scala/beam/router/LinkTravelTimeContainer.scala index caf58b1131f..9bf70685d28 100755 --- a/src/main/scala/beam/router/LinkTravelTimeContainer.scala +++ b/src/main/scala/beam/router/LinkTravelTimeContainer.scala @@ -14,13 +14,13 @@ import scala.collection.mutable import scala.util.Try class LinkTravelTimeContainer(fileName: String, timeBinSizeInSeconds: Int, maxHour: Int) - extends TravelTime + extends BeamTravelTime with LazyLogging { - private val travelTimeCalculator: TravelTime = + private val travelTimeCalculator: BeamTravelTime = TravelTimeCalculatorHelper.CreateTravelTimeCalculator(timeBinSizeInSeconds, loadLinkStats().asJava) - def loadLinkStats(): scala.collection.Map[String, Array[Double]] = { + private def loadLinkStats(): scala.collection.Map[String, Array[Double]] = { val start = System.currentTimeMillis() val linkTravelTimeMap: mutable.HashMap[String, Array[Double]] = mutable.HashMap() logger.info(s"Stats fileName [$fileName] is being loaded") @@ -58,4 +58,11 @@ class LinkTravelTimeContainer(fileName: String, timeBinSizeInSeconds: Int, maxHo travelTimeCalculator.getLinkTravelTime(link, time, person, vehicle) } + /** + * Get travel time using integer link ID directly. + * This avoids the overhead of Link object lookups and string parsing. + */ + def getLinkTravelTime(linkId: Int, time: Double): Double = { + travelTimeCalculator.getLinkTravelTime(linkId, time) + } } diff --git a/src/main/scala/beam/router/Modes.scala b/src/main/scala/beam/router/Modes.scala index 439ebb7dce6..084b0d0b0d0 100644 --- a/src/main/scala/beam/router/Modes.scala +++ b/src/main/scala/beam/router/Modes.scala @@ -379,9 +379,10 @@ object TourModes { ) ) case _ => - val retainedVehicle = availableVehicles - .find(v => currentTourPersonalVehicle.find(availableVehicles.map(_.id).contains).contains(v.id)) - .map(_.vehicle) +// val retainedVehicle = availableVehicles +// .find(v => currentTourPersonalVehicle.find(availableVehicles.map(_.id).contains).contains(v.id)) +// .map(_.vehicle) + val retainedVehicle = None // TEMP: Trying out not retaining parent tour vehicles on subtours outcome .getOrElseUpdate(Some(WALK_BASED), mutable.Map.empty[EmbodiedBeamTrip, Option[BeamVehicle]]) diff --git a/src/main/scala/beam/router/RoutingWorker.scala b/src/main/scala/beam/router/RoutingWorker.scala index d2db72ed2ba..1f8cdbcc3f3 100755 --- a/src/main/scala/beam/router/RoutingWorker.scala +++ b/src/main/scala/beam/router/RoutingWorker.scala @@ -83,17 +83,20 @@ class RoutingWorker(workerParams: R5Parameters, networks2: Option[(TransportNetw private var r5: R5Wrapper = new R5Wrapper( workerParams, - new FreeFlowTravelTime, + new BeamFreeFlowTravelTime(networkHelper = workerParams.networkHelper), workerParams.beamConfig.beam.routing.r5.travelTimeNoiseFraction ) private var secondR5: Option[R5Wrapper] = for { (transportNetwork, network) <- networks2 - } yield new R5Wrapper( - workerParams.copy(transportNetwork = transportNetwork, networkHelper = new NetworkHelperImpl(network)), - new FreeFlowTravelTime, - workerParams.beamConfig.beam.routing.r5.travelTimeNoiseFraction - ) + } yield { + val networkHelperImpl = new NetworkHelperImpl(network) + new R5Wrapper( + workerParams.copy(transportNetwork = transportNetwork, networkHelper = networkHelperImpl), + new BeamFreeFlowTravelTime(networkHelperImpl), + workerParams.beamConfig.beam.routing.r5.travelTimeNoiseFraction + ) + } private val graphHopperDir: String = Paths.get(workerParams.beamConfig.beam.inputDirectory, "graphhopper").toString private val carGraphHopperDir: String = Paths.get(graphHopperDir, "car").toString diff --git a/src/main/scala/beam/router/r5/BikeLanesAdjustment.scala b/src/main/scala/beam/router/r5/BikeLanesAdjustment.scala index bc754a56d43..c336631031a 100644 --- a/src/main/scala/beam/router/r5/BikeLanesAdjustment.scala +++ b/src/main/scala/beam/router/r5/BikeLanesAdjustment.scala @@ -26,6 +26,10 @@ class BikeLanesAdjustment @Inject() (bikeLanesData: BikeLanesData) { } } + def bikeScaleFactor(linkId: LinkId): Double = { + scaleFactor(linkId) + } + def scaleFactor(vehicleType: BeamVehicleType, linkId: LinkId): Double = { if (vehicleType.vehicleCategory == VehicleCategory.Bike) { scaleFactor(linkId) diff --git a/src/main/scala/beam/router/r5/CarWeightCalculator.scala b/src/main/scala/beam/router/r5/CarWeightCalculator.scala index 709adae481b..5c6a43f1b8d 100644 --- a/src/main/scala/beam/router/r5/CarWeightCalculator.scala +++ b/src/main/scala/beam/router/r5/CarWeightCalculator.scala @@ -1,11 +1,9 @@ package beam.router.r5 -import beam.agentsim.agents.vehicles.BeamVehicleType +import beam.router.BeamTravelTime import org.matsim.core.router.util.TravelTime import java.util.concurrent.ThreadLocalRandom -import java.util.concurrent.atomic.AtomicInteger -import scala.util.Try class CarWeightCalculator(workerParams: R5Parameters, travelTimeNoiseFraction: Double = 0d) { private val networkHelper = workerParams.networkHelper @@ -14,49 +12,60 @@ class CarWeightCalculator(workerParams: R5Parameters, travelTimeNoiseFraction: D val maxFreeSpeed: Double = networkHelper.allLinks.map(_.getFreespeed).max / 0.621371 // Convert kph to mph private val minSpeed = workerParams.beamConfig.beam.physsim.minCarSpeedInMetersPerSecond - private val noiseIdx: AtomicInteger = new AtomicInteger(0) - - private val travelTimeNoises: Array[Double] = if (travelTimeNoiseFraction.equals(0d)) { - Array.empty - } else { - Array.fill(1000000) { - ThreadLocalRandom.current().nextDouble(1 - travelTimeNoiseFraction, 1 + travelTimeNoiseFraction) - } - } + // Pre-compute noise bounds for faster generation + private val noiseLowerBound = 1 - travelTimeNoiseFraction + private val noiseUpperBound = 1 + travelTimeNoiseFraction def calcTravelTime(linkId: Int, travelTime: TravelTime, time: Double): Double = { - calcTravelTime(linkId, travelTime, None, time, shouldAddNoise = false) + calcTravelTime(linkId, travelTime, maxFreeSpeed, time, shouldAddNoise = false) } def calcTravelTime( linkId: Int, travelTime: TravelTime, - vehicleType: Option[BeamVehicleType], + maxSpeed: Double, time: Double, - shouldAddNoise: Boolean + shouldAddNoise: Boolean, + edgeLength: Double = -1 // Allow passing pre-computed edge length ): Double = { val link = networkHelper.getLinkUnsafe(linkId) assert(link != null) - val edge = transportNetwork.streetLayer.edgeStore.getCursor(linkId) - val maxTravelTime = edge.getLengthM / minSpeed - val maxSpeed: Double = vehicleType match { - case Some(vType) => vType.maxVelocity.getOrElse(maxFreeSpeed) - case None => maxFreeSpeed - } + // Use provided edge length if available, otherwise look it up + val lengthM = + if (edgeLength > 0) edgeLength + else { + transportNetwork.streetLayer.edgeStore.lengths_mm.get(linkId / 2) / 1000.0 + } - val minTravelTime = edge.getLengthM / maxSpeed + // Pre-compute these values once + val maxTravelTime = lengthM / minSpeed + val minTravelTime = lengthM / maxSpeed - val physSimTravelTime = travelTime.getLinkTravelTime(link, time, null, null) + // Get travel time - use optimized method if available + val physSimTravelTime = travelTime match { + case beamTT: BeamTravelTime => + // Use the optimized method with pre-computed length + beamTT.getLinkTravelTime(linkId, time, lengthM) + case _ => + // Fall back to the original method + val link = networkHelper.getLinkUnsafe(linkId) + if (link == null) { + lengthM / maxSpeed // Default to free flow if link not found + } else { + travelTime.getLinkTravelTime(link, time, null, null) + } + } + + // Generate noise only if needed val physSimTravelTimeWithNoise = - if (travelTimeNoiseFraction.equals(0d) || !shouldAddNoise) { - physSimTravelTime + if (travelTimeNoiseFraction > 0d && shouldAddNoise) { + // Generate a value between 0 and 1, scale it to the noise range, then shift it + physSimTravelTime * ThreadLocalRandom.current().nextDouble(noiseLowerBound, noiseUpperBound) } else { - val idx = Math.abs(noiseIdx.getAndIncrement() % travelTimeNoises.length) - physSimTravelTime * travelTimeNoises(idx) + physSimTravelTime } - val linkTravelTime = Math.max(physSimTravelTimeWithNoise, minTravelTime) - val result = Math.min(linkTravelTime, maxTravelTime) - result + // Use Math.min/max for cleaner clamping + Math.min(Math.max(physSimTravelTimeWithNoise, minTravelTime), maxTravelTime) } } diff --git a/src/main/scala/beam/router/r5/R5Wrapper.scala b/src/main/scala/beam/router/r5/R5Wrapper.scala index cc27bfac222..5e7549647ad 100644 --- a/src/main/scala/beam/router/r5/R5Wrapper.scala +++ b/src/main/scala/beam/router/r5/R5Wrapper.scala @@ -34,6 +34,7 @@ import org.matsim.vehicles.Vehicle import java.time.ZonedDateTime import java.time.temporal.ChronoUnit import java.util +import java.util.concurrent.ConcurrentHashMap import java.util.function.IntFunction import java.util.{Collections, Optional} import scala.collection.JavaConverters._ @@ -83,6 +84,19 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo ) }.toMap + private lazy val precomputedRestrictions: Map[RoutingVehicleCategory, Map[Long, Boolean]] = { + val categories = RoutingVehicleCategory.values + categories.map { category => + val categoryRestrictions = osmIdToRoadRestriction.map { case (osmId, restrictions) => + osmId -> restrictions.isRestricted( + category, + Double.MaxValue + ) + } + category -> categoryRestrictions + }.toMap + } + private val linkRadiusMeters: Double = beamConfig.beam.routing.r5.linkRadiusMeters @@ -493,6 +507,7 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo profileRequest.fromLat = from.getY profileRequest.toLon = to.getX profileRequest.toLat = to.getY + val walkToVehicleDuration = maybeWalkToVehicle(vehicle).map(leg => leg.beamLeg.duration).getOrElse(0) profileRequest.fromTime = request.departureTime + walkToVehicleDuration profileRequest.toTime = @@ -620,10 +635,16 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo val egressRouters = mutable.Map[LegMode, StreetRouter]() val egressStopsByMode = mutable.Map[LegMode, StopVisitor]() profileRequest.reverseSearch = true + val isCarEgress = egressVehicles.exists(_.mode == CAR) for (vehicle <- egressVehicles) { val (costPerMile, costPerMinute) = getVehicleCosts(vehicle) val theDestination = if (mainRouteToVehicle) { - destinationVehicle.get.locationUTM.loc + if (destinationVehicle.isDefined) { + destinationVehicle.get.locationUTM.loc + } else { + logger.error("Route requested with egress vehicles that don't exist") + request.destinationUTM + } } else { request.destinationUTM } @@ -678,10 +699,20 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo egressStopsByMode.put(legMode, stopVisitor) } } + if (isCarEgress) { + profileRequest.maxRides = 2 + profileRequest.suboptimalMinutes = beamConfig.beam.routing.r5.suboptimalMinutesForDriveAccess + } else { + profileRequest.maxRides = 3 + profileRequest.suboptimalMinutes = beamConfig.beam.routing.r5.suboptimalMinutes + } val departureTimeToDominatingList: IntFunction[DominatingList] = (departureTime: Int) => beamConfig.beam.routing.r5.transitAlternativeList.toLowerCase match { - case "suboptimal" if !mainRouteRideHailTransit => + case "suboptimal" if !mainRouteRideHailTransit && !isCarEgress => + // Note: We now disallow multiple responses for + // drive_transit. We should turn this back on if it is + // very important to the analysis new SuboptimalDominatingList( profileRequest.suboptimalMinutes ) @@ -693,9 +724,6 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo ) } - val transitPaths = latency("getpath-transit-time", Metrics.VerboseLevel) { - profileRequest.fromTime = request.departureTime - accessStopsByMode.flatMap { case (mode, stopVisitor) => val modeSpecificBuffer = mode match { case LegMode.WALK => beamConfig.beam.routing.r5.accessBufferTimeSeconds.walk case LegMode.BICYCLE => beamConfig.beam.routing.r5.accessBufferTimeSeconds.bike @@ -704,6 +732,7 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo case LegMode.CAR => beamConfig.beam.routing.r5.accessBufferTimeSeconds.car case _ => 0 } + profileRequest.fromTime = request.departureTime profileRequest.toTime = request.departureTime + modeSpecificBuffer + 61 // Important to allow 61 seconds for transit schedules to be considered! Along with any other buffers val router = new McRaptorSuboptimalPathProfileRouter( @@ -1270,7 +1299,7 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo streetMode: StreetMode, req: ProfileRequest ): Float = { - ttc(startTime + durationSeconds, edge.getEdgeIndex, streetMode).floatValue().ceil + math.ceil(ttc(startTime + durationSeconds, edge.getEdgeIndex, streetMode).toFloat).toFloat } } } @@ -1281,15 +1310,28 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo shouldApplyBicycleScaleFactor: Boolean = false ): TravelTimeByLinkCalculator = { val profileRequest = createProfileRequest + + // Cache the maximum velocity for this vehicle type + val vehicleMaxSpeed = vehicleType.maxVelocity.getOrElse(Double.MaxValue) + (time: Double, linkId: Int, streetMode: StreetMode) => { - val edge = transportNetwork.streetLayer.edgeStore.getCursor(linkId) - val maxSpeed: Double = vehicleType.maxVelocity.getOrElse(profileRequest.getSpeedForMode(streetMode)) - val minTravelTime = edge.getLengthM / maxSpeed - if (streetMode == StreetMode.CAR) { - carWeightCalculator.calcTravelTime(linkId, travelTime, Some(vehicleType), time, shouldAddNoise) - } else if (streetMode == StreetMode.BICYCLE && shouldApplyBicycleScaleFactor) { - val scaleFactor = bikeLanesAdjustment.scaleFactor(vehicleType, linkId) - minTravelTime * scaleFactor + // Get the edge length, using the cache + val edgeLength = transportNetwork.streetLayer.edgeStore.lengths_mm.get(linkId / 2) / 1000.0 + + // Calculate the mode-specific speed + val maxSpeed: Double = if (streetMode == StreetMode.CAR) { + Math.min(vehicleMaxSpeed, profileRequest.getSpeedForMode(streetMode)) + } else { + profileRequest.getSpeedForMode(streetMode) + } + + val minTravelTime = edgeLength / maxSpeed + + if (streetMode == StreetMode.BICYCLE && shouldApplyBicycleScaleFactor) { + //note we're not explicitly checking that it is a Bike VehicleType + minTravelTime * bikeLanesAdjustment.bikeScaleFactor(linkId) + } else if (streetMode == StreetMode.CAR) { + carWeightCalculator.calcTravelTime(linkId, travelTime, maxSpeed, time, shouldAddNoise, edgeLength) } else { minTravelTime } @@ -1309,19 +1351,20 @@ class R5Wrapper(workerParams: R5Parameters, travelTime: TravelTime, travelTimeNo perMinuteCost: Double = 0.0 ): TravelCostCalculator = { (edge: EdgeStore#Edge, legDurationSeconds: Int, traversalTimeSeconds: Float) => { + val osmId = edge.getOSMID + val category = RoutingVehicleCategory.fromCategory(vehicleType.vehicleCategory) val roadRestrictionWeightMultiplier: Float = - if ( - osmIdToRoadRestriction - .get(edge.getOSMID) - .exists( - _.isRestricted( - vehicleType.vehicleCategory, - vehicleType.restrictRoadsByFreeSpeedInMeterPerSecond.getOrElse(Double.MaxValue) - ) - ) - ) + if (precomputedRestrictions.getOrElse(category, Map.empty).getOrElse(osmId, false)) { workerParams.beamConfig.beam.agentsim.agents.vehicles.roadRestrictionWeightMultiplier.toFloat - else 1f + } else { + vehicleType.restrictRoadsByFreeSpeedInMeterPerSecond.map(maxSpeed => + osmIdToRoadRestriction.get(osmId).exists(_.isRestricted(vehicleType.vehicleCategory, maxSpeed)) + ) match { + case Some(true) => + workerParams.beamConfig.beam.agentsim.agents.vehicles.roadRestrictionWeightMultiplier.toFloat + case _ => 1f + } + } val fare: Double = traversalTimeSeconds / 60.0 * perMinuteCost + edge.getLengthM / METERS_IN_MILE * perMileCost @@ -1345,16 +1388,34 @@ object R5Wrapper { private val HeavyHeavyDutyTruckTag = "hgv" private val LightAndMediumHeavyDutyTruckTag = "mdv" + sealed trait RoutingVehicleCategory + + private object RoutingVehicleCategory { + case object HeavyDuty extends RoutingVehicleCategory + case object MediumDuty extends RoutingVehicleCategory + case object Other extends RoutingVehicleCategory + + val values: Set[RoutingVehicleCategory] = Set(HeavyDuty, MediumDuty, Other) + + def fromCategory(category: VehicleCategory.VehicleCategory): RoutingVehicleCategory = category match { + case VehicleCategory.Class78Tractor | VehicleCategory.Class78Vocational => HeavyDuty + case VehicleCategory.Class456Vocational | VehicleCategory.Class2b3Vocational => MediumDuty + case _ => Other + } + } + private case class RoadRestrictions(hhdt: Boolean, lmhdt: Boolean, freeSpeed: Double) { - def isRestricted(category: VehicleCategory.VehicleCategory, speedThreshold: Double): Boolean = { + def isRestricted(category: RoutingVehicleCategory, speedThreshold: Double): Boolean = { category match { - case VehicleCategory.Class78Tractor => !hhdt - case VehicleCategory.Class78Vocational => !hhdt - case VehicleCategory.Class456Vocational => !lmhdt - case VehicleCategory.Class2b3Vocational => !lmhdt - case _ => freeSpeed > speedThreshold + case RoutingVehicleCategory.HeavyDuty => !hhdt + case RoutingVehicleCategory.MediumDuty => !lmhdt + case RoutingVehicleCategory.Other => freeSpeed > speedThreshold } } + + def isRestricted(category: VehicleCategory.VehicleCategory, speedThreshold: Double): Boolean = { + isRestricted(RoutingVehicleCategory.fromCategory(category), speedThreshold) + } } } diff --git a/src/main/scala/beam/router/skim/ActivitySimPathType.scala b/src/main/scala/beam/router/skim/ActivitySimPathType.scala index 1d17ca5ed3b..43fcee74eae 100644 --- a/src/main/scala/beam/router/skim/ActivitySimPathType.scala +++ b/src/main/scala/beam/router/skim/ActivitySimPathType.scala @@ -2,9 +2,7 @@ package beam.router.skim import beam.agentsim.agents.ridehail.RideHailVehicleId import beam.router.Modes.BeamMode -import beam.router.Modes.BeamMode._ import beam.router.model.{EmbodiedBeamLeg, EmbodiedBeamTrip} -import beam.router.skim.ActivitySimMetric._ import org.matsim.api.core.v01.population.Activity sealed trait ActivitySimPathType @@ -48,7 +46,9 @@ object ActivitySimPathType { val (_, longestCarLegId) = tryGetLongestLegId(trip, isCar) val (longestWalkTransitLeg, longestWalkTransitLegId) = tryGetLongestLegId(trip, isTransit) - if (longestCarLegId.isEmpty || longestWalkTransitLeg.isEmpty || longestWalkTransitLegId.isEmpty) { + if (trip.legs.exists(_.isRideHail)) { + OTHER // Stub for when we merge in RH_TRANSIT mode from the Cruise branch + } else if (longestCarLegId.isEmpty || longestWalkTransitLeg.isEmpty || longestWalkTransitLegId.isEmpty) { OTHER } else if (longestCarLegId.get > longestWalkTransitLegId.get) { longestWalkTransitLeg.map(leg => leg.beamLeg.mode) match { diff --git a/src/main/scala/beam/router/skim/ActivitySimSkimmer.scala b/src/main/scala/beam/router/skim/ActivitySimSkimmer.scala index 7135752d417..a291faf0bd3 100644 --- a/src/main/scala/beam/router/skim/ActivitySimSkimmer.scala +++ b/src/main/scala/beam/router/skim/ActivitySimSkimmer.scala @@ -2,7 +2,7 @@ package beam.router.skim import beam.router.skim.ActivitySimPathType.{isWalkTransit, TNC_SHARED, TNC_SINGLE, WLK_TRN_WLK} import beam.router.skim.core.{AbstractSkimmer, AbstractSkimmerInternal, AbstractSkimmerKey, AbstractSkimmerReadOnly} -import beam.router.skim.urbansim.ActivitySimOmxWriter +import beam.router.skim.urbansim.{ActivitySimOmxWriter, ActivitySimZarrWriter} import beam.router.Modes.BeamMode import beam.router.Modes.BeamMode.{RIDE_HAIL, RIDE_HAIL_POOLED} import beam.sim.BeamScenario @@ -45,7 +45,11 @@ class ActivitySimSkimmer @Inject() (matsimServices: MatsimServices, beamScenario override def writeToDisk(event: IterationEndsEvent): Unit = if (config.writeSkimsInterval > 0 && event.getIteration % config.writeSkimsInterval == 0) { - val extension = if (config.activity_sim_skimmer.fileOutputFormat.equalsIgnoreCase("csv")) "csv.gz" else "omx" + val extension = config.activity_sim_skimmer.fileOutputFormat.toLowerCase match { + case "csv" => "csv.gz" + case "zarr" => "zarr" + case _ => "omx" + } val filePath = event.getServices.getControlerIO .getIterationFilename(event.getServices.getIterationNumber, s"${skimFileBaseName}_current.$extension") writePresentedSkims(filePath) @@ -284,8 +288,12 @@ class ActivitySimSkimmer @Inject() (matsimServices: MatsimServices, beamScenario case "csv" => val csvWriter = new CsvWriter(filePath, ExcerptData.csvHeaderSeq) csvWriter.writeAllAndClose(data.map(_.toCsvSeq)) - case _ => + case "zarr" => + ActivitySimZarrWriter.writeToZarr(filePath, data.iterator, geoUnits) + case "omx" => ActivitySimOmxWriter.writeToOmx(filePath, data.iterator, geoUnits) + case _ => + logger.warn("Not writing skims") } } catch { case exception: Exception => diff --git a/src/main/scala/beam/router/skim/urbansim/ActivitySimOmxWriter.scala b/src/main/scala/beam/router/skim/urbansim/ActivitySimOmxWriter.scala index 639cce67874..b8859ae0007 100644 --- a/src/main/scala/beam/router/skim/urbansim/ActivitySimOmxWriter.scala +++ b/src/main/scala/beam/router/skim/urbansim/ActivitySimOmxWriter.scala @@ -5,25 +5,26 @@ import beam.router.skim.ActivitySimPathType._ import beam.router.skim.ActivitySimSkimmer.ExcerptData import beam.router.skim.ActivitySimTimeBin._ import beam.router.skim.{ActivitySimMetric, ActivitySimPathType, ActivitySimTimeBin} -import beam.utils.FileUtils import beam.utils.csv.CsvWriter +import com.typesafe.scalalogging.LazyLogging import omx.hdf5.HDF5Loader import omx.{OmxFile, OmxMatrix} -import scala.collection.mutable -import scala.util.Try - /** * @author Dmitry Openkov */ -object ActivitySimOmxWriter { +object ActivitySimOmxWriter extends LazyLogging { def writeToOmx( filePath: String, skimData: Iterator[ExcerptData], geoUnits: Seq[String] - ): Try[Unit] = Try { + ): Unit = try { + logger.info(s"Starting writeToOmx with filePath: $filePath") + logger.info(s"HDF5 library preparation starting...") HDF5Loader.prepareHdf5Library() + logger.info(s"HDF5 library prepared successfully") + val pathTypeToMatrixData: Map[ActivitySimPathType, MatrixData] = ( for { data <- activitySimMatrixData @@ -31,38 +32,93 @@ object ActivitySimOmxWriter { limitedData = data.copy(metrics = data.metrics & ExcerptData.supportedActivitySimMetric) } yield pathType -> limitedData ).toMap - FileUtils.using( - new OmxFile(filePath) - ) { omxFile => - val shape: Array[Int] = Array.fill(geoUnits.size)(geoUnits.size) + logger.info(s"Matrix data map created with ${pathTypeToMatrixData.size} entries") + + logger.info(s"Creating new OmxFile instance for path: $filePath") + val omxFile = new OmxFile(filePath) + logger.info("OmxFile instance created successfully") + + logger.info(s"Shape size will be: ${geoUnits.size}x${geoUnits.size}") + + val shape: Array[Int] = Array.fill(geoUnits.size)(geoUnits.size) + logger.info("Attempting to open new file...") + try { omxFile.openNew(shape) - val geoUnitMapping = geoUnits.zipWithIndex.toMap + logger.info("File opened successfully") + } catch { + case e: Exception => + logger.error(s"Failed to open file: ${e.getMessage}") + logger.error(s"Exception class: ${e.getClass.getName}") + e.printStackTrace() + } + + val geoUnitMapping = geoUnits.zipWithIndex.toMap + + // Group the data by matrix key to process each matrix once + val groupedData = skimData.toSeq.groupBy { excerptData => + val pathType = excerptData.pathType match { + case rideHailMode @ (TNC_SINGLE | TNC_SHARED) => + f"${rideHailMode.toString}_${excerptData.fleetName.toUpperCase}" + case _ => excerptData.pathType.toString + } + ( + pathType, + excerptData.timePeriodString, + pathTypeToMatrixData.get(excerptData.pathType).map(_.metrics).getOrElse(Set.empty[ActivitySimMetric]) + ) + } - val allMatrices = mutable.Map.empty[String, OmxMatrix.OmxFloatMatrix] + // Process each matrix + for { + ((pathType, timePeriod, metrics), excerpts) <- groupedData + metric <- metrics + } { + val matrixName = s"${pathType}_${metric}__$timePeriod" + val valuesFloat = Array.fill[Float](shape(0), shape(1))(Float.NaN) + val matrix = new OmxMatrix.OmxFloatMatrix(matrixName, valuesFloat, -1.0f) + + matrix.setAttribute("mode", pathType) + matrix.setAttribute("timePeriod", timePeriod) + matrix.setAttribute("measure", metric.toString) + + // Fill the matrix for { - excerptData <- skimData - matrixData <- pathTypeToMatrixData.get(excerptData.pathType).toIterable - row <- geoUnitMapping.get(excerptData.originId).toIterable - column <- geoUnitMapping.get(excerptData.destinationId).toIterable - metric <- matrixData.metrics + excerptData <- excerpts + row <- geoUnitMapping.get(excerptData.originId) + column <- geoUnitMapping.get(excerptData.destinationId) } { - val pathType = excerptData.pathType match { - case rideHailMode @ (TNC_SINGLE | TNC_SHARED) => - f"${rideHailMode.toString}_${excerptData.fleetName.toUpperCase}" - case _ => excerptData.pathType.toString - } - val matrix = getOrCreateMatrix(allMatrices, pathType, excerptData.timePeriodString, metric, shape) - matrix.setAttribute("mode", pathType) - matrix.setAttribute("timePeriod", excerptData.timePeriodString) - matrix.setAttribute("measure", metric.toString) matrix.getData()(row)(column) = excerptData.getValue(metric).toFloat * getUnitConversion(metric) } - allMatrices.values.foreach(omxFile.addMatrix) - // we cannot add a lookup because string arrays are not supported by hdf5lib java - // omxFile.addLookup(new OmxStringLookup("zone_id", geoUnits.toArray, "")) + + omxFile.addMatrix(matrix) } - // we write geo unit mapping as a csv file next to the omx file + + logger.info("Saving OMX file...") + omxFile.save() + logger.info("OMX file saved successfully") + omxFile.close() + logger.info("OMX file closed") + + // Write geo unit mapping as before CsvWriter(filePath + ".mapping", "zone_id").writeAllAndClose(geoUnits.map(Seq(_))) + } catch { + case e: java.io.FileNotFoundException => + e.printStackTrace() + throw new RuntimeException(s"Failed to create or access file at path: $filePath. Error: ${e.getMessage}", e) + case e: java.io.IOException => + e.printStackTrace() + throw new RuntimeException(s"IO error while writing to OMX file: ${e.getMessage}", e) + case e: IllegalArgumentException => + throw new RuntimeException(s"Invalid argument provided: ${e.getMessage}", e) + case e: NoSuchElementException => + throw new RuntimeException(s"Missing required data: ${e.getMessage}", e) + case e: OutOfMemoryError => + throw new RuntimeException(s"Insufficient memory to process the matrix data.", e) + case e: Exception => + throw new RuntimeException( + s"Unexpected error while writing OMX file: ${e.getMessage}. Error type: ${e.getClass.getSimpleName}", + e + ) } private def getUnitConversion(metric: ActivitySimMetric): Float = { @@ -72,22 +128,6 @@ object ActivitySimOmxWriter { } } - private def getOrCreateMatrix( - matrixMap: mutable.Map[String, OmxMatrix.OmxFloatMatrix], - pathType: String, - timeBin: String, - metric: ActivitySimMetric, - shape: Array[Int] - ): OmxMatrix.OmxFloatMatrix = { - val matrixName = s"${pathType}_${metric}__$timeBin" - matrixMap.getOrElseUpdate( - matrixName, { - val valuesFloat = Array.fill[Float](shape(0), shape(1))(Float.NaN) - new OmxMatrix.OmxFloatMatrix(matrixName, valuesFloat, -1.0f) - } - ) - } - /** * Contains data types that is used by ActivitySim: path types, time bins and metrics * @param pathTypes possible path types diff --git a/src/main/scala/beam/router/skim/urbansim/ActivitySimZarrWriter.scala b/src/main/scala/beam/router/skim/urbansim/ActivitySimZarrWriter.scala new file mode 100644 index 00000000000..2ba568fad49 --- /dev/null +++ b/src/main/scala/beam/router/skim/urbansim/ActivitySimZarrWriter.scala @@ -0,0 +1,211 @@ +package beam.router.skim.urbansim + +import beam.router.skim.ActivitySimMetric._ +import beam.router.skim.ActivitySimPathType._ +import beam.router.skim.ActivitySimSkimmer.ExcerptData +import beam.router.skim.{ActivitySimMetric, ActivitySimPathType, ActivitySimTimeBin} +import beam.router.skim.ActivitySimTimeBin._ +import com.bc.zarr.DataType +import com.typesafe.scalalogging.LazyLogging +import com.bc.zarr.storage.FileSystemStore + +import java.nio.file.Paths + +object ActivitySimZarrWriter extends LazyLogging { + + def writeToZarr( + filePath: String, + skimData: Iterator[ExcerptData], + geoUnits: Seq[String] + ): Unit = try { + logger.info(s"Starting writeToZarr with filePath: $filePath") + + // Build a map from path type to MatrixData for quick lookup + val pathTypeToMatrixData: Map[ActivitySimPathType, MatrixData] = + activitySimMatrixData.flatMap(md => md.pathTypes.map(_ -> md)).toMap + + val geoUnitMapping = geoUnits.zipWithIndex.toMap + val timePeriods = ActivitySimTimeBin.values.toIndexedSeq // Keep as enum values for index lookup + val timePeriodNames = timePeriods.map(_.entryName) + + val groupedData = skimData.toSeq.groupBy { excerptData => + val pathType = excerptData.pathType match { // Standardize TNC names with fleet suffix + case rideHailMode @ (TNC_SINGLE | TNC_SHARED) => + f"${rideHailMode.toString}_${excerptData.fleetName.toUpperCase}" + case _ => excerptData.pathType.toString + } + ( + pathType, + pathTypeToMatrixData.get(excerptData.pathType).map(_.metrics).getOrElse(Set.empty[ActivitySimMetric]) + ) + } + + // --- Zarr Directory Store Implementation using com.bc.zarr --- + + val store = new FileSystemStore(Paths.get(filePath)) + logger.info(s"Zarr Directory Store created/opened at: $filePath") + + var rootGroup: com.bc.zarr.ZarrGroup = null + try { + rootGroup = com.bc.zarr.ZarrGroup.create(store) + logger.info("Root Zarr group created successfully") + + var dataset_count = 0 + + groupedData.par.foreach { case ((pathType, metrics), excerpts) => + metrics.par.foreach { metric => + val matrixName = s"${pathType}_${metric}" + val shape = Array[Int](geoUnits.size, geoUnits.size, timePeriods.size) + logger.debug(s"Creating dataset '$matrixName' with shape ${shape.mkString("x")}") + dataset_count += 1 + + val compressor = com.bc.zarr.CompressorFactory.create( + "zlib" + ) +// val compressor = com.bc.zarr.CompressorFactory.create( +// "blosc", +// "cname", +// "zstd", +// "clevel", +// "5", +// "shuffle", +// "1" +// ) + val chunkShape = Array[Int](shape(0), shape(1), 1) + + val arrayParams = new com.bc.zarr.ArrayParams() + .shape(shape: _*) + .chunks(chunkShape: _*) + .dataType(DataType.f4) + .compressor(compressor) + .fillValue(Float.NaN) + + val zarrArray = rootGroup.createArray(matrixName, arrayParams) + + excerpts.foreach { excerptData => + for { + row <- geoUnitMapping.get(excerptData.originId) + column <- geoUnitMapping.get(excerptData.destinationId) + timeBinOpt = ActivitySimTimeBin.values.find(_.entryName == excerptData.timePeriodString) + if timeBinOpt.isDefined + timeIdx = timePeriods.indexOf(timeBinOpt.get) + if timeIdx >= 0 + } { + val offset = Array[Int](row, column, timeIdx) + val dataShape = Array[Int](1, 1, 1) // Single value shape + val value = excerptData.getValue(metric).toFloat * getUnitConversion(metric) + val javaFloatArray = Array[Float](value) // Create primitive float array directly + try { + zarrArray.write(javaFloatArray, dataShape, offset) + } catch { + case e: java.lang.RuntimeException => + val value = excerptData.getValue(metric) + val conversion = getUnitConversion(metric) + logger.info(s"Writing value: $value (${value.getClass.getName}) with conversion: $conversion") + logger.error(s"Failed to initialize data for $matrixName at offset $offset: ${e.getMessage}", e) + } + } + } + + val attrs = zarrArray.getAttributes() + attrs.put("mode", pathType) + attrs.put("measure", metric.toString) + attrs.put("timePeriods", timePeriodNames.toList) + // No attrs.write() needed + + logger.debug(s"Successfully wrote dataset and attributes for '$matrixName'") + } + } // ADD SECOND BLOCK HERE + + logger.info( + s"Zarr Directory Store written successfully with $dataset_count datasets." + ) // Report actual dataset count + + } finally { + // No close method needed for rootGroup + } + + } catch { + case e: Exception => + logger.error(s"Unexpected error while writing Zarr file: ${e.getMessage}", e) + throw new RuntimeException( + s"Unexpected error while writing Zarr file: ${e.getMessage}. Error type: ${e.getClass.getSimpleName}", + e + ) + } + + private def getUnitConversion(metric: ActivitySimMetric): Float = { + metric match { + case DIST | DDIST => 1f / 1609.34f + case _ => 1f + } + } + + // --- Definitions copied from ActivitySimOmxWriter --- + // Contains data types that is used by ActivitySim: path types, time bins and metrics + // @param pathTypes possible path types + // @param timeBins we don't use time bins now because data can be defined for all time bins for all path types + // that Beam produces + // @param metrics possible metrics + case class MatrixData( + pathTypes: Set[ActivitySimPathType], + timeBins: Set[ActivitySimTimeBin], + metrics: Set[ActivitySimMetric] + ) + + // Configuration for which metrics are expected for which path types for ActivitySim export + private val activitySimMatrixData = IndexedSeq( + MatrixData( + Set(DRV_COM_WLK, DRV_EXP_WLK, DRV_HVY_WLK, WLK_COM_DRV, WLK_EXP_DRV, WLK_HVY_DRV), + ActivitySimTimeBin.values.toSet, + Set(TOTIVT, FAR, XWAIT, KEYIVT, IWAIT, DTIM, BOARDS, DDIST, WAUX, TRIPS, FAILURES) + ), + MatrixData( + Set(DRV_LOC_WLK, WLK_LOC_DRV), + ActivitySimTimeBin.values.toSet, + Set(TOTIVT, FAR, XWAIT, IWAIT, DTIM, BOARDS, DDIST, WAUX, TRIPS, FAILURES) + ), + MatrixData( + Set(DRV_LRF_WLK, WLK_LRF_DRV), + ActivitySimTimeBin.values.toSet, + Set(TOTIVT, FERRYIVT, FAR, XWAIT, KEYIVT, DTIM, IWAIT, BOARDS, DDIST, WAUX, TRIPS, FAILURES) + ), + MatrixData( + Set(HOV2TOLL, HOV3TOLL, SOVTOLL), + ActivitySimTimeBin.values.toSet, + Set(BTOLL, VTOLL, TIME, DIST) + ), + MatrixData( + Set(BIKE), + ActivitySimTimeBin.values.toSet, + Set(TIME, DIST) + ), + MatrixData(Set(HOV2, HOV3, SOV), ActivitySimTimeBin.values.toSet, Set(BTOLL, TIME, DIST, TRIPS, FAILURES)), + MatrixData( + Set(WLK_COM_WLK, WLK_EXP_WLK, WLK_HVY_WLK), + ActivitySimTimeBin.values.toSet, + Set(TOTIVT, FAR, XWAIT, KEYIVT, IWAIT, BOARDS, WAUX, TRIPS, FAILURES) + ), + MatrixData( + Set(WLK_LOC_WLK), + ActivitySimTimeBin.values.toSet, + Set(TOTIVT, FAR, XWAIT, IWAIT, BOARDS, WAUX, TRIPS, FAILURES) + ), + MatrixData( + Set(WLK_LRF_WLK), + ActivitySimTimeBin.values.toSet, + Set(TOTIVT, FERRYIVT, FAR, XWAIT, KEYIVT, IWAIT, BOARDS, WAUX, TRIPS, FAILURES) + ), + MatrixData( + Set(WLK_TRN_WLK), + Set(PM_PEAK, MIDDAY, AM_PEAK), + Set(WACC, IVT, XWAIT, IWAIT, WEGR, WAUX, TRIPS, FAILURES) + ), + MatrixData( + Set(TNC_SINGLE, TNC_SHARED), + ActivitySimTimeBin.values.toSet, + Set(IWAIT, TOTIVT, DDIST, FAR, TRIPS, FAILURES) + ) + ) + // --- End of definitions copied from ActivitySimOmxWriter --- +} diff --git a/src/main/scala/beam/scoring/BeamScoringFunctionFactory.scala b/src/main/scala/beam/scoring/BeamScoringFunctionFactory.scala index d8d8f12f9cd..8e5013eae1d 100755 --- a/src/main/scala/beam/scoring/BeamScoringFunctionFactory.scala +++ b/src/main/scala/beam/scoring/BeamScoringFunctionFactory.scala @@ -11,6 +11,7 @@ import beam.sim.population.AttributesOfIndividual import beam.sim.population.PopulationAdjustment._ import beam.utils.{FileUtils, OutputDataDescriptor} import com.typesafe.scalalogging.LazyLogging +import org.apache.commons.lang3.math.NumberUtils import org.matsim.api.core.v01.events.{Event, PersonArrivalEvent} import org.matsim.api.core.v01.population.{Activity, Leg, Person} import org.matsim.core.controler.OutputDirectoryHierarchy @@ -149,7 +150,42 @@ class BeamScoringFunctionFactory @Inject() ( leg.getAttributes.putAttribute("vehicles", trip.vehiclesInTrip.mkString(",")) } - val allDayScore = modeChoiceCalculator.computeAllDayUtility(trips, person, attributes) + // TODO: Factor in ivt multipliers from ASim to downweight extra time on transit: +// ivt_cost_multiplier: 0.6 +// ivt_lrt_multiplier: 0.9 +// ivt_ferry_multiplier: 0.8 +// ivt_exp_multiplier: 1 +// ivt_hvy_multiplier: 0.8 +// ivt_com_multiplier: 0.7 + + val tripsWithUpdatedAttributes = trips + .zip(personLegs) + .map { case (x, y) => + x -> Map("travelTimeRatio" -> (Option(y.getAttributes.getAttribute("trip_dur_min")) match { + case Some(expectedTravelTime) => + x.totalTravelTimeInSecs.toDouble / 60.0 / NumberUtils.toDouble(expectedTravelTime.toString) + case None => + logger.debug(s"Missing expected travel time ratio for leg $y") + 1.0 + })) + } + .toMap + val allDayExpectedScore = if (beamConfig.beam.replanning.subtractExpectedScores) { + modeChoiceCalculator.computeAllDayUtility( + tripsWithUpdatedAttributes, + person, + attributes, + overrideAttributes = true + ) + } else { 0.0 } + val allDayScore = + modeChoiceCalculator.computeAllDayUtility( + tripsWithUpdatedAttributes, + person, + attributes, + overrideAttributes = false + ) + val personActivities = person.getSelectedPlan.getPlanElements.asScala .collect { case activity: Activity => activity @@ -159,12 +195,21 @@ class BeamScoringFunctionFactory @Inject() ( personActivities.foldLeft(0.0)(_ + getActivityBenefit(_, attributes)) } else { 0.0 } val replanningScore = -replanningEventCount.toFloat * beamConfig.beam.replanning.replanningPenaltyInDollars + val utilsConversion = beamConfig.beam.agentsim.agents.modalBehaviors.multinomialLogit.units.toLowerCase match { + case "utils" => + beamConfig.beam.agentsim.agents.modalBehaviors.multinomialLogit.params.time / attributes.valueOfTime * 60.0 // Convert hours to minutes + case "dollars" => 1.0 + } - finalScore = allDayScore + leavingParkingEventScore + activityScore + replanningScore - finalScore = Math.max( - finalScore, - -100000 - ) // keep scores no further below -100k to keep MATSim happy (doesn't like -Infinity) but knowing + finalScore = + (allDayScore + leavingParkingEventScore + activityScore + replanningScore - allDayExpectedScore) * utilsConversion + finalScore = if (finalScore.isNaN) { -1000 } + else { + Math.max( + finalScore, + -100000 + ) + } // keep scores no further below -100k to keep MATSim happy (doesn't like -Infinity) but knowing // that if changes to utility function drive the true scores below -100k, this will need to be replaced with another big number. // Write the individual's trip scores to csv diff --git a/src/main/scala/beam/sim/BeamHelper.scala b/src/main/scala/beam/sim/BeamHelper.scala index d86507daafe..4177de6fd93 100755 --- a/src/main/scala/beam/sim/BeamHelper.scala +++ b/src/main/scala/beam/sim/BeamHelper.scala @@ -398,6 +398,31 @@ trait BeamHelper extends LazyLogging with BeamValidationHelper { } } + def vehicleEnergy(beamConfig: BeamConfig, vehicleTypes: Map[Id[BeamVehicleType], BeamVehicleType]): VehicleEnergy = { + var vehiclePaths = IndexedSeq( + Paths.get(beamConfig.beam.agentsim.agents.vehicles.vehicleTypesFilePath).getParent.toString + ) + beamConfig.beam.agentsim.agents.freight.vehicleTypesFilePath + .map(freightVehicleTypesFilePath => Paths.get(freightVehicleTypesFilePath).getParent.toString) + .foreach(freightVehiclePath => vehiclePaths = vehiclePaths :+ freightVehiclePath) + + val vehicleCsvReader = new VehicleCsvReader(beamConfig) + val consumptionRateFilterStore = + new ConsumptionRateFilterStoreImpl( + vehicleCsvReader.getVehicleEnergyRecordsUsing, + vehiclePaths, + primaryConsumptionRateFilePathsByVehicleType = + vehicleTypes.values.map(x => (x, x.primaryVehicleEnergyFile)).toIndexedSeq, + secondaryConsumptionRateFilePathsByVehicleType = + vehicleTypes.values.map(x => (x, x.secondaryVehicleEnergyFile)).toIndexedSeq + ) + // TODO Fix me once `TrieMap` is removed + new VehicleEnergy( + consumptionRateFilterStore, + vehicleCsvReader.getLinkToGradeRecordsUsing + ) + } + private def readPrivateVehicles( beamConfig: BeamConfig, vehicleTypes: Map[Id[BeamVehicleType], BeamVehicleType] diff --git a/src/main/scala/beam/sim/BeamMobsim.scala b/src/main/scala/beam/sim/BeamMobsim.scala index 2fbf93e6383..e807a2fe6ff 100755 --- a/src/main/scala/beam/sim/BeamMobsim.scala +++ b/src/main/scala/beam/sim/BeamMobsim.scala @@ -455,7 +455,8 @@ class BeamMobsimIteration( if (beamServices.beamConfig.beam.agentsim.agents.rideHail.managers.size == 1) { val managerConfig = beamConfig.beam.agentsim.agents.rideHail.managers.head val rhmName = managerConfig.name - val rideHailManagerId = VehicleManager.createOrGetReservedFor(rhmName, VehicleManager.TypeEnum.RideHail).managerId + val rideHailManagerId = + VehicleManager.createOrGetReservedFor(rhmName, Some(VehicleManager.TypeEnum.RideHail)).managerId val rideHailFleetInitializer = rideHailFleetInitializerProvider.get(rhmName) Props( new RideHailManager( diff --git a/src/main/scala/beam/sim/BeamSim.scala b/src/main/scala/beam/sim/BeamSim.scala index cdf1549b7aa..02b16af6994 100755 --- a/src/main/scala/beam/sim/BeamSim.scala +++ b/src/main/scala/beam/sim/BeamSim.scala @@ -35,6 +35,7 @@ import com.conveyal.r5.transit.TransportNetwork import com.google.inject.Inject import com.typesafe.config.Config import com.typesafe.scalalogging.LazyLogging +import kamon.Kamon import org.apache.commons.lang3.StringUtils import org.jfree.data.category.DefaultCategoryDataset import org.matsim.api.core.v01.Scenario @@ -592,17 +593,31 @@ class BeamSim @Inject() ( "dumpMatsimStuffAtTheBeginningOfSimulation in the beginning of simulation", x => logger.info(x) ) { - // `DumpDataAtEnd` during `notifyShutdown` dumps network, plans, person attributes and other things. - // Reusing it to get `outputPersonAttributes.xml.gz` which is needed for warmstart - val dumper = beamServices.injector.getInstance(classOf[DumpDataAtEnd]) - dumper match { - case listener: ShutdownListener => - val event = new ShutdownEvent(beamServices.matsimServices, false) - // Create files - listener.notifyShutdown(event) - dumpHouseholdAttributes - - case _ => logger.warn(s"dumper is not `ShutdownListener` - $dumper") + // Get the specific logger and save its original level + val dumpLogger = org.apache.log4j.Logger.getLogger("org.matsim.core.controler.corelisteners.DumpDataAtEndImpl") + val originalLevel = dumpLogger.getLevel + + // Temporarily set log level to WARN to suppress ERROR messages + dumpLogger.setLevel(org.apache.log4j.Level.WARN) + + try { + val dumper = beamServices.injector.getInstance(classOf[DumpDataAtEnd]) + dumper match { + case listener: ShutdownListener => + val event = new ShutdownEvent(beamServices.matsimServices, false) + try { + // Create files + listener.notifyShutdown(event) + dumpHouseholdAttributes() + } catch { + case ex: Throwable => + logger.error(s"Exception during initial data dump: ${ex.getMessage}") + } + case _ => logger.warn(s"dumper is not `ShutdownListener` - $dumper") + } + } finally { + // Restore original logging configuration + dumpLogger.setLevel(originalLevel) } } } @@ -659,6 +674,7 @@ class BeamSim @Inject() ( logger.info("Actor system shut down") deleteMATSimOutputFiles(event.getServices.getIterationNumber) + Kamon.stopModules() // simulation python scripts for { diff --git a/src/main/scala/beam/sim/RideHailFleetInitializer.scala b/src/main/scala/beam/sim/RideHailFleetInitializer.scala index d081d27f51b..cf980452854 100644 --- a/src/main/scala/beam/sim/RideHailFleetInitializer.scala +++ b/src/main/scala/beam/sim/RideHailFleetInitializer.scala @@ -47,7 +47,7 @@ object RideHailFleetInitializer extends OutputDataDescriptor with LazyLogging { val id = GenericCsvReader.getIfNotNull(rec, "id") val rideHailManagerIdStr = GenericCsvReader.getIfNotNull(rec, "rideHailManagerId") val rideHailManagerId = - VehicleManager.createOrGetReservedFor(rideHailManagerIdStr, VehicleManager.TypeEnum.RideHail).managerId + VehicleManager.createOrGetReservedFor(rideHailManagerIdStr, Some(VehicleManager.TypeEnum.RideHail)).managerId val vehicleType = GenericCsvReader.getIfNotNull(rec, "vehicleType") val initialLocationX = GenericCsvReader.getIfNotNull(rec, "initialLocationX").toDouble val initialLocationY = GenericCsvReader.getIfNotNull(rec, "initialLocationY").toDouble @@ -629,15 +629,15 @@ class ProceduralRideHailFleetInitializer( val realDistribution: UniformRealDistributionEnhanced = new UniformRealDistributionEnhanced() realDistribution.reseedRandomGenerator(beamServices.beamConfig.matsim.modules.global.randomSeed) - val passengerPopulation: Iterable[Person] = scenario.getPopulation.getPersons + private val passengerPopulation: Iterable[Person] = scenario.getPopulation.getPersons .values() .asScala - .filterNot(_.getId.toString.startsWith(FreightReader.FREIGHT_ID_PREFIX)) + .filterNot(_.getId.toString.startsWith(FreightReader.CARRIER_ID_PREFIX)) - val passengerHousehold: Iterable[Household] = scenario.getHouseholds.getHouseholds + private val passengerHousehold: Iterable[Household] = scenario.getHouseholds.getHouseholds .values() .asScala - .filterNot(_.getId.toString.startsWith(FreightReader.FREIGHT_ID_PREFIX)) + .filterNot(_.getId.toString.startsWith(FreightReader.CARRIER_ID_PREFIX)) private def computeNumRideHailAgents: Long = { val fleet: Double = beamServices.beamConfig.beam.agentsim.agents.vehicles.fractionOfInitialVehicleFleet @@ -652,6 +652,12 @@ class ProceduralRideHailFleetInitializer( } .count(beamVehicleType => beamVehicleType.vehicleCategory == VehicleCategory.Car) / fleet + logger.info( + s"Manager: ${managerConfig.name}: Number of household vehicles: $initialNumHouseholdVehicles, " + + s"fraction of initial vehicle fleet: ${managerConfig.initialization.procedural.fractionOfInitialVehicleFleet}, " + + s"ride hail agents to be generated: ${math.round(initialNumHouseholdVehicles * managerConfig.initialization.procedural.fractionOfInitialVehicleFleet)}" + ) + math.round( initialNumHouseholdVehicles * managerConfig.initialization.procedural.fractionOfInitialVehicleFleet @@ -665,7 +671,14 @@ class ProceduralRideHailFleetInitializer( val averageOnDutyHoursPerDay = managerConfig.initialization.procedural.averageOnDutyHoursPerDay val meanLogShiftDurationHours = managerConfig.initialization.procedural.meanLogShiftDurationHours val stdLogShiftDurationHours = managerConfig.initialization.procedural.stdLogShiftDurationHours - var equivalentNumberOfDrivers = managerConfig.initialization.procedural.equivalentNumberOfDrivers + var equivalentNumberOfDrivers = if (managerConfig.initialization.procedural.equivalentNumberOfDrivers >= 0) { + managerConfig.initialization.procedural.equivalentNumberOfDrivers + } else { + logger.warn( + s"Equivalent number of drivers is set to ${managerConfig.initialization.procedural.equivalentNumberOfDrivers}, setting it to 0 instead" + ) + 0 + } val personsWithMoreThanOneActivity = passengerPopulation.filter(_.getSelectedPlan.getPlanElements.size > 1) val persons: Array[Person] = rand.shuffle(personsWithMoreThanOneActivity).toArray @@ -687,60 +700,80 @@ class ProceduralRideHailFleetInitializer( val rideHailAgentInitializers: ArrayBuffer[RideHailFleetInitializer.RideHailAgentInitializer] = new ArrayBuffer() var idx = 0 val numRideHailAgents = computeNumRideHailAgents + var warned = false while (equivalentNumberOfDrivers < numRideHailAgents.toDouble) { - if (idx >= persons.length) { - throw new IllegalStateException("Can't have more ridehail drivers than total population") - } else { - try { - val person = persons(idx) - val vehicleType = vehiclesAdjustment - .sampleVehicleTypes( - numVehicles = 1, - vehicleCategory = VehicleCategory.Car, - realDistribution + if ((idx >= persons.length) && !warned) { + logger.warn( + s"We need ${numRideHailAgents.toDouble} ridehail agents, which is more than total population of ${persons.length}" + ) + logger.info(s"Current ratio of drivers to agents is $idx agents, $equivalentNumberOfDrivers drivers") + warned = true + } + try { + val person = persons(idx % persons.length) + val vehicleType = vehiclesAdjustment + .sampleVehicleTypes( + numVehicles = 1, + vehicleCategory = VehicleCategory.Car, + realDistribution + ) + .head + val rideInitialLocation: Location = getRideInitLocation(person, activityQuadTreeBounds) + + val meanSoc = beamServices.beamConfig.beam.agentsim.agents.vehicles.meanRidehailVehicleStartingSOC + val initialStateOfCharge = + beam.utils.BeamVehicleUtils.randomSocFromUniformDistribution(rand, vehicleType, meanSoc) + + val (shiftsOpt, shiftEquivalentNumberOfDrivers) = if (vehicleType.isConnectedAutomatedVehicle) { + (None, 1.0) + } else { + val shiftDuration = + math.round(math.exp(rand.nextGaussian() * stdLogShiftDurationHours + meanLogShiftDurationHours) * 3600) + val shiftMidPointTime = activityEndTimes(rand.nextInt(activityEndTimes.length)) + val shiftStartTime = max(shiftMidPointTime - (shiftDuration / 2).toInt, 10) + val shiftEndTime = min(shiftMidPointTime + (shiftDuration / 2).toInt, 30 * 3600) + + val shiftEquivalentNumberOfDrivers_ = (shiftEndTime - shiftStartTime) / (averageOnDutyHoursPerDay * 3600) + if (shiftEquivalentNumberOfDrivers_ < 0.0) { + logger.warn( + s"How did we end up with a negative equivalent number of drivers? " + + s"shiftStartTime: $shiftStartTime, shiftEndTime: $shiftEndTime, shiftDuration: $shiftDuration" ) - .head - val rideInitialLocation: Location = getRideInitLocation(person, activityQuadTreeBounds) - - val meanSoc = beamServices.beamConfig.beam.agentsim.agents.vehicles.meanRidehailVehicleStartingSOC - val initialStateOfCharge = - beam.utils.BeamVehicleUtils.randomSocFromUniformDistribution(rand, vehicleType, meanSoc) - - val (shiftsOpt, shiftEquivalentNumberOfDrivers) = if (vehicleType.isConnectedAutomatedVehicle) { - (None, 1.0) + (Some(List(Shift(Range(shiftStartTime, shiftEndTime), None))), 1.0) } else { - val shiftDuration = - math.round(math.exp(rand.nextGaussian() * stdLogShiftDurationHours + meanLogShiftDurationHours) * 3600) - val shiftMidPointTime = activityEndTimes(rand.nextInt(activityEndTimes.length)) - val shiftStartTime = max(shiftMidPointTime - (shiftDuration / 2).toInt, 10) - val shiftEndTime = min(shiftMidPointTime + (shiftDuration / 2).toInt, 30 * 3600) - - val shiftEquivalentNumberOfDrivers_ = (shiftEndTime - shiftStartTime) / (averageOnDutyHoursPerDay * 3600) - (Some(List(Shift(Range(shiftStartTime, shiftEndTime), None))), shiftEquivalentNumberOfDrivers_) } - val rideHailAgentInitializer = RideHailAgentInitializer( - person.getId.toString, - vehicleType, - rideHailManagerId, - shiftsOpt, - initialStateOfCharge, - rideInitialLocation, - geofence = None, - fleetId = managerConfig.name - ) + } - rideHailAgentInitializers += rideHailAgentInitializer + val rideHailAgentInitializer = RideHailAgentInitializer( + person.getId.toString, + vehicleType, + rideHailManagerId, + shiftsOpt, + initialStateOfCharge, + rideInitialLocation, + geofence = None, + fleetId = managerConfig.name + ) - equivalentNumberOfDrivers += shiftEquivalentNumberOfDrivers - } catch { - case ex: Throwable => - logger.error(s"Could not generate RideHailAgentInitializer: ${ex.getMessage}") - throw ex - } - idx += 1 + rideHailAgentInitializers += rideHailAgentInitializer + + equivalentNumberOfDrivers += shiftEquivalentNumberOfDrivers + } catch { + case ex: Throwable => + logger.error(s"Could not generate RideHailAgentInitializer: ${ex.getMessage}") + throw ex } + idx += 1 + } + + if (warned) { + logger.warn( + s"Generated $equivalentNumberOfDrivers ride hail agents for $idx shifts " + + s"for $rideHailManagerId, which is more than the total " + + s"population of ${persons.length}." + ) } rideHailAgentInitializers.toIndexedSeq @@ -924,7 +957,7 @@ case class ShpGeofence( geometries.exists(_.contains(point)) } - override def toString() = { + override def toString(): String = { s"ShpGeofence(${geometries.size} features from file: $geofenceShpFile)" } diff --git a/src/main/scala/beam/sim/common/GeoUtils.scala b/src/main/scala/beam/sim/common/GeoUtils.scala index cd037f307c2..98383815410 100755 --- a/src/main/scala/beam/sim/common/GeoUtils.scala +++ b/src/main/scala/beam/sim/common/GeoUtils.scala @@ -29,6 +29,7 @@ trait GeoUtils extends ExponentialLazyLogging { def localCRS: String val defaultMaxRadiusForMapSearch = 20000 private lazy val notExponentialLogger = Logger(LoggerFactory.getLogger(getClass.getName)) + private var cachedEdges: Option[Array[(EdgeWithCoord, GpxPoint)]] = None lazy val utm2Wgs: GeotoolsTransformation = new GeotoolsTransformation(localCRS, "EPSG:4326") @@ -95,7 +96,9 @@ trait GeoUtils extends ExponentialLazyLogging { distUTMInMeters(matsimUtmCoord, wgs2Utm(coordWGS)) } val distUTM = distUTMInMeters(wgs2Utm(coordWGS), wgs2Utm(new v01.Coord(closest.wgsCoord.x, closest.wgsCoord.y))) - notExponentialLogger.warn(s"""Will return closest to the corner: $closest which is $distUTM meters far away""") + notExponentialLogger.warn( + s"""Will return closest to the corner: $closest which is $distUTM meters far away from request at $coordWGS""" + ) closest.edgeIndex } else { theSplit.edge @@ -141,7 +144,7 @@ trait GeoUtils extends ExponentialLazyLogging { theSplit = streetLayer.findSplit(coord.getY, coord.getX, maxRadius, streetMode) } if (theSplit == null) { - notExponentialLogger.warn( + notExponentialLogger.debug( s"The split is `null` for StreetLayer.BoundingBox: ${streetLayer.getEnvelope}, coord: $coord, maxRadius: $maxRadius, street mode $streetMode" ) } @@ -149,25 +152,27 @@ trait GeoUtils extends ExponentialLazyLogging { } def getEdgesCloseToBoundingBox(streetLayer: StreetLayer): Array[(EdgeWithCoord, GpxPoint)] = { - val cursor = streetLayer.edgeStore.getCursor() - val iter = new Iterator[EdgeStore#Edge] { - override def hasNext: Boolean = cursor.advance() + cachedEdges.getOrElse { - override def next(): EdgeStore#Edge = cursor - } + val cursor = streetLayer.edgeStore.getCursor() + val iter = new Iterator[EdgeStore#Edge] { + override def hasNext: Boolean = cursor.advance() + + override def next(): EdgeStore#Edge = cursor + } - val boundingBox = streetLayer.envelope + val boundingBox = streetLayer.envelope - val insideBoundingBox = iter - .flatMap { edge => - Option(edge.getGeometry.getBoundary.getCoordinate).map { coord => - EdgeWithCoord(edge.getEdgeIndex, coord) + val insideBoundingBox = iter + .flatMap { edge => + Option(edge.getGeometry.getBoundary.getCoordinate).map { coord => + EdgeWithCoord(edge.getEdgeIndex, coord) + } } - } - .withFilter(x => boundingBox.contains(x.wgsCoord)) - .toArray + .withFilter(x => boundingBox.contains(x.wgsCoord)) + .toArray - /* + /* min => x0,y0 max => x1,y1 x0,y1 (TOP LEFT) ._____._____. x1,y1 (TOP RIGHT) @@ -177,37 +182,39 @@ x0,y1 (TOP LEFT) ._____._____. x1,y1 (TOP RIGHT) | | | | x0,y0 (BOTTOM LEFT) ._____._____. x1, y0 (BOTTOM RIGHT) - */ - - val bottomLeft = new Coord(boundingBox.getMinX, boundingBox.getMinY) - val topLeft = new Coord(boundingBox.getMinX, boundingBox.getMaxY) - val topRight = new Coord(boundingBox.getMaxX, boundingBox.getMaxY) - val bottomRight = new Coord(boundingBox.getMaxX, boundingBox.getMinY) - val midLeft = new Coord((bottomLeft.getX + topLeft.getX) / 2, (bottomLeft.getY + topLeft.getY) / 2) - val midTop = new Coord((topLeft.getX + topRight.getX) / 2, (topLeft.getY + topRight.getY) / 2) - val midRight = new Coord((topRight.getX + bottomRight.getX) / 2, (topRight.getY + bottomRight.getY) / 2) - val midBottom = new Coord((bottomLeft.getX + bottomRight.getX) / 2, (bottomLeft.getY + bottomRight.getY) / 2) - - val corners = Array( - GpxPoint("BottomLeft", bottomLeft), - GpxPoint("TopLeft", topLeft), - GpxPoint("TopRight", topRight), - GpxPoint("BottomRight", bottomRight), - GpxPoint("MidLeft", midLeft), - GpxPoint("MidTop", midTop), - GpxPoint("MidRight", midRight), - GpxPoint("MidBottom", midBottom) - ) + */ + + val bottomLeft = new Coord(boundingBox.getMinX, boundingBox.getMinY) + val topLeft = new Coord(boundingBox.getMinX, boundingBox.getMaxY) + val topRight = new Coord(boundingBox.getMaxX, boundingBox.getMaxY) + val bottomRight = new Coord(boundingBox.getMaxX, boundingBox.getMinY) + val midLeft = new Coord((bottomLeft.getX + topLeft.getX) / 2, (bottomLeft.getY + topLeft.getY) / 2) + val midTop = new Coord((topLeft.getX + topRight.getX) / 2, (topLeft.getY + topRight.getY) / 2) + val midRight = new Coord((topRight.getX + bottomRight.getX) / 2, (topRight.getY + bottomRight.getY) / 2) + val midBottom = new Coord((bottomLeft.getX + bottomRight.getX) / 2, (bottomLeft.getY + bottomRight.getY) / 2) + + val corners = Array( + GpxPoint("BottomLeft", bottomLeft), + GpxPoint("TopLeft", topLeft), + GpxPoint("TopRight", topRight), + GpxPoint("BottomRight", bottomRight), + GpxPoint("MidLeft", midLeft), + GpxPoint("MidTop", midTop), + GpxPoint("MidRight", midRight), + GpxPoint("MidBottom", midBottom) + ) - val closestEdges = corners.map { gpxPoint => - val utmCornerCoord = wgs2Utm(gpxPoint.wgsCoord) - val closestEdge: EdgeWithCoord = insideBoundingBox.minBy { x => - val utmCoord = wgs2Utm(new Coord(x.wgsCoord.x, x.wgsCoord.y)) - distUTMInMeters(utmCornerCoord, utmCoord) + val closestEdges = corners.map { gpxPoint => + val utmCornerCoord = wgs2Utm(gpxPoint.wgsCoord) + val closestEdge: EdgeWithCoord = insideBoundingBox.minBy { x => + val utmCoord = wgs2Utm(new Coord(x.wgsCoord.x, x.wgsCoord.y)) + distUTMInMeters(utmCornerCoord, utmCoord) + } + (closestEdge, gpxPoint) } - (closestEdge, gpxPoint) + cachedEdges = Some(closestEdges) + closestEdges } - closestEdges } } diff --git a/src/main/scala/beam/sim/config/BeamConfig.scala b/src/main/scala/beam/sim/config/BeamConfig.scala index a1402848c27..34836b9ea18 100644 --- a/src/main/scala/beam/sim/config/BeamConfig.scala +++ b/src/main/scala/beam/sim/config/BeamConfig.scala @@ -45,6 +45,7 @@ object BeamConfig { fractionOfPlansWithSingleActivity: scala.Double, h3taz: BeamConfig.Beam.Agentsim.H3taz, lastIteration: scala.Int, + lastTransitTrip: java.lang.String, populationAdjustment: java.lang.String, randomSeedForPopulationSampling: scala.Option[scala.Int], scenarios: BeamConfig.Beam.Agentsim.Scenarios, @@ -618,6 +619,7 @@ object BeamConfig { case class MultinomialLogit( params: BeamConfig.Beam.Agentsim.Agents.ModalBehaviors.MultinomialLogit.Params, + units: java.lang.String, utility_scale_factor: scala.Double ) @@ -633,6 +635,7 @@ object BeamConfig { ride_hail_pooled_intercept: scala.Double, ride_hail_subscription: scala.Double, ride_hail_transit_intercept: scala.Double, + time: scala.Double, transfer: scala.Double, transit_crowding: scala.Double, transit_crowding_VOT_multiplier: scala.Double, @@ -665,6 +668,7 @@ object BeamConfig { ride_hail_transit_intercept = if (c.hasPathOrNull("ride_hail_transit_intercept")) c.getDouble("ride_hail_transit_intercept") else 0.0, + time = if (c.hasPathOrNull("time")) c.getDouble("time") else 0.022, transfer = if (c.hasPathOrNull("transfer")) c.getDouble("transfer") else -1.4, transit_crowding = if (c.hasPathOrNull("transit_crowding")) c.getDouble("transit_crowding") else 0.0, transit_crowding_VOT_multiplier = @@ -692,6 +696,7 @@ object BeamConfig { if (c.hasPathOrNull("params")) c.getConfig("params") else com.typesafe.config.ConfigFactory.parseString("params{}") ), + units = if (c.hasPathOrNull("units")) c.getString("units") else "dollars", utility_scale_factor = if (c.hasPathOrNull("utility_scale_factor")) c.getDouble("utility_scale_factor") else 1.0 ) @@ -2439,6 +2444,7 @@ object BeamConfig { else com.typesafe.config.ConfigFactory.parseString("h3taz{}") ), lastIteration = if (c.hasPathOrNull("lastIteration")) c.getInt("lastIteration") else 0, + lastTransitTrip = if (c.hasPathOrNull("lastTransitTrip")) c.getString("lastTransitTrip") else "28:00:00", populationAdjustment = if (c.hasPathOrNull("populationAdjustment")) c.getString("populationAdjustment") else "DEFAULT_ADJUSTMENT", randomSeedForPopulationSampling = @@ -2881,7 +2887,11 @@ object BeamConfig { case class Output( activity_sim_skimmer: scala.Option[BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer], - emissions: BeamConfig.Beam.Exchange.Output.Emissions + activitySimSkimsEnabled: scala.Boolean, + emissions: BeamConfig.Beam.Exchange.Output.Emissions, + generateSkimsForAllModes: scala.Boolean, + generateSkimsForRideHailTransit: scala.Boolean, + sendNonChosenTripsToSkimmer: scala.Boolean ) object Output { @@ -2907,7 +2917,7 @@ object BeamConfig { } case class Secondary( - beamModeFilter: scala.List[java.lang.String], + beamModeFilter: scala.Option[scala.List[java.lang.String]], enabled: scala.Boolean, taz: BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer.Secondary.Taz ) @@ -2945,8 +2955,8 @@ object BeamConfig { c: com.typesafe.config.Config ): BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer.Secondary.Taz = { BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer.Secondary.Taz( - filePath = c.getString("filePath"), - tazIdFieldName = c.getString("tazIdFieldName"), + filePath = if (c.hasPathOrNull("filePath")) c.getString("filePath") else "''", + tazIdFieldName = if (c.hasPathOrNull("tazIdFieldName")) c.getString("tazIdFieldName") else "''", tazMapping = if (c.hasPathOrNull("tazMapping")) scala.Some( @@ -2960,7 +2970,8 @@ object BeamConfig { def apply(c: com.typesafe.config.Config): BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer.Secondary = { BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer.Secondary( - beamModeFilter = $_L$_str(c.getList("beamModeFilter")), + beamModeFilter = + if (c.hasPathOrNull("beamModeFilter")) scala.Some($_L$_str(c.getList("beamModeFilter"))) else None, enabled = c.hasPathOrNull("enabled") && c.getBoolean("enabled"), taz = BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer.Secondary.Taz( if (c.hasPathOrNull("taz")) c.getConfig("taz") @@ -3009,10 +3020,18 @@ object BeamConfig { if (c.hasPathOrNull("activity-sim-skimmer")) scala.Some(BeamConfig.Beam.Exchange.Output.ActivitySimSkimmer(c.getConfig("activity-sim-skimmer"))) else None, + activitySimSkimsEnabled = + c.hasPathOrNull("activitySimSkimsEnabled") && c.getBoolean("activitySimSkimsEnabled"), emissions = BeamConfig.Beam.Exchange.Output.Emissions( if (c.hasPathOrNull("emissions")) c.getConfig("emissions") else com.typesafe.config.ConfigFactory.parseString("emissions{}") - ) + ), + generateSkimsForAllModes = + c.hasPathOrNull("generateSkimsForAllModes") && c.getBoolean("generateSkimsForAllModes"), + generateSkimsForRideHailTransit = + c.hasPathOrNull("generateSkimsForRideHailTransit") && c.getBoolean("generateSkimsForRideHailTransit"), + sendNonChosenTripsToSkimmer = + !c.hasPathOrNull("sendNonChosenTripsToSkimmer") || c.getBoolean("sendNonChosenTripsToSkimmer") ) } } @@ -4243,7 +4262,8 @@ object BeamConfig { fractionOfIterationsToDisableInnovation: scala.Double, maxAgentPlanMemorySize: scala.Int, planSelectionBeta: scala.Double, - replanningPenaltyInDollars: scala.Double + replanningPenaltyInDollars: scala.Double, + subtractExpectedScores: scala.Boolean ) object Replanning { @@ -4287,7 +4307,8 @@ object BeamConfig { if (c.hasPathOrNull("maxAgentPlanMemorySize")) c.getInt("maxAgentPlanMemorySize") else 5, planSelectionBeta = if (c.hasPathOrNull("planSelectionBeta")) c.getDouble("planSelectionBeta") else 1.0, replanningPenaltyInDollars = - if (c.hasPathOrNull("replanningPenaltyInDollars")) c.getDouble("replanningPenaltyInDollars") else 100.0 + if (c.hasPathOrNull("replanningPenaltyInDollars")) c.getDouble("replanningPenaltyInDollars") else 100.0, + subtractExpectedScores = !c.hasPathOrNull("subtractExpectedScores") || c.getBoolean("subtractExpectedScores") ) } } @@ -4532,6 +4553,7 @@ object BeamConfig { numberOfSamples: scala.Int, osmMapdbFile: java.lang.String, suboptimalMinutes: scala.Int, + suboptimalMinutesForDriveAccess: scala.Int, transitAlternativeList: java.lang.String, travelTimeNoiseFraction: scala.Double ) @@ -4617,6 +4639,9 @@ object BeamConfig { if (c.hasPathOrNull("osmMapdbFile")) c.getString("osmMapdbFile") else "/test/input/beamville/r5/osm.mapdb", suboptimalMinutes = if (c.hasPathOrNull("suboptimalMinutes")) c.getInt("suboptimalMinutes") else 10, + suboptimalMinutesForDriveAccess = + if (c.hasPathOrNull("suboptimalMinutesForDriveAccess")) c.getInt("suboptimalMinutesForDriveAccess") + else 2, transitAlternativeList = if (c.hasPathOrNull("transitAlternativeList")) c.getString("transitAlternativeList") else "SUBOPTIMAL", travelTimeNoiseFraction = diff --git a/src/main/scala/beam/sim/population/PopulationAttributes.scala b/src/main/scala/beam/sim/population/PopulationAttributes.scala index 2858b36fbda..1fdc6448986 100644 --- a/src/main/scala/beam/sim/population/PopulationAttributes.scala +++ b/src/main/scala/beam/sim/population/PopulationAttributes.scala @@ -31,6 +31,9 @@ case class AttributesOfIndividual( wheelchairUser: Boolean = false ) extends PopulationAttributes { lazy val hasModalityStyle: Boolean = modalityStyle.nonEmpty + private val hourConversion = 1.0 / 3600 + private val modeMultiplierCache = collection.concurrent.TrieMap[BeamMode, Double]() + private val poolingMultiplierCache = collection.concurrent.TrieMap[AutomationLevel, Double]() val busTransit: Set[BeamMode] = Set(BeamMode.BUS, BeamMode.WALK) val subwayTransit: Set[BeamMode] = Set(BeamMode.SUBWAY, BeamMode.WALK) @@ -48,38 +51,41 @@ case class AttributesOfIndividual( isRideHail: Boolean = false, isPooledTrip: Boolean = false ): Double = { - // NOTE: This is in hours - val isWorkTrip = destinationActivity match { - case None => - false - case Some(activity) => - activity.getType().equalsIgnoreCase("work") - } + val (linkId, travelTime) = IdAndTT + val isWorkTrip = destinationActivity.exists(_.getType.equalsIgnoreCase("work")) - val multiplier = beamMode match { - case CAR => - val vehicleAutomationLevel = getAutomationLevel(beamVehicleTypeId, beamServices) - if (isRideHail) { - if (isPooledTrip) { - getModeVotMultiplier(Option(RIDE_HAIL_POOLED), modeChoiceModel) * - getPooledFactor(vehicleAutomationLevel, modeChoiceModel.poolingMultipliers) - } else { - getModeVotMultiplier(Option(RIDE_HAIL), modeChoiceModel) - } - } else { - getSituationMultiplier( - IdAndTT._1, - IdAndTT._2, - isWorkTrip, - modeChoiceModel.situationMultipliers(beamMode), + val multiplier = if (beamMode == CAR) { + val vehicleAutomationLevel = getAutomationLevel(beamVehicleTypeId, beamServices) + if (isRideHail) { + if (isPooledTrip) { + modeMultiplierCache.getOrElseUpdate( + RIDE_HAIL_POOLED, + modeChoiceModel.modeMultipliers.getOrElse(Some(RIDE_HAIL_POOLED), 1.0) + ) * poolingMultiplierCache.getOrElseUpdate( vehicleAutomationLevel, - beamServices - ) * getModeVotMultiplier(Option(CAR), modeChoiceModel) + modeChoiceModel.poolingMultipliers.getOrElse(vehicleAutomationLevel, 1.0) + ) + } else { + modeMultiplierCache.getOrElseUpdate( + RIDE_HAIL, + modeChoiceModel.modeMultipliers.getOrElse(Some(RIDE_HAIL), 1.0) + ) } - case _ => - getModeVotMultiplier(Option(beamMode), modeChoiceModel) + } else { + getSituationMultiplier( + linkId, + travelTime, + isWorkTrip, + modeChoiceModel.situationMultipliers(beamMode), + vehicleAutomationLevel, + beamServices + ) * modeMultiplierCache.getOrElseUpdate(CAR, modeChoiceModel.modeMultipliers.getOrElse(Some(CAR), 1.0)) + } + } else { + modeMultiplierCache.getOrElseUpdate(beamMode, modeChoiceModel.modeMultipliers.getOrElse(Some(beamMode), 1.0)) } - multiplier * IdAndTT._2 / 3600 + + multiplier * travelTime * hourConversion } def getGeneralizedTimeOfLegForMNL( @@ -173,23 +179,29 @@ case class AttributesOfIndividual( homeToWork || workToHome } + private val automationLevelCache = collection.concurrent.TrieMap[Id[BeamVehicleType], AutomationLevel]() + private def getAutomationLevel( beamVehicleTypeId: Id[BeamVehicleType], beamServices: BeamServices ): AutomationLevel = { - val automationInt = if (beamServices.beamConfig.beam.agentsim.agents.modalBehaviors.overrideAutomationForVOTT) { - beamServices.beamConfig.beam.agentsim.agents.modalBehaviors.overrideAutomationLevel - } else { - beamServices.beamScenario.vehicleTypes(beamVehicleTypeId).automationLevel - } - automationInt match { - case 1 => levelLE2 - case 2 => levelLE2 - case 3 => level3 - case 4 => level4 - case 5 => level5 - case _ => levelLE2 - } + automationLevelCache.getOrElseUpdate( + beamVehicleTypeId, { + val automationInt = if (beamServices.beamConfig.beam.agentsim.agents.modalBehaviors.overrideAutomationForVOTT) { + beamServices.beamConfig.beam.agentsim.agents.modalBehaviors.overrideAutomationLevel + } else { + beamServices.beamScenario.vehicleTypes(beamVehicleTypeId).automationLevel + } + automationInt match { + case 1 => levelLE2 + case 2 => levelLE2 + case 3 => level3 + case 4 => level4 + case 5 => level5 + case _ => levelLE2 + } + } + ) } // Convert from seconds to hours and bring in person's base VOT diff --git a/src/main/scala/beam/sim/vehiclesharing/Fleets.scala b/src/main/scala/beam/sim/vehiclesharing/Fleets.scala index 84b06b711eb..377a2ceb66e 100644 --- a/src/main/scala/beam/sim/vehiclesharing/Fleets.scala +++ b/src/main/scala/beam/sim/vehiclesharing/Fleets.scala @@ -7,7 +7,7 @@ import beam.sim.config.BeamConfig.Beam.Agentsim.Agents.Vehicles.SharedFleets$Elm object Fleets { def lookup(config: BeamConfig.Beam.Agentsim.Agents.Vehicles.SharedFleets$Elm): FleetType = { - val vehicleManager = VehicleManager.createOrGetReservedFor(config.name, VehicleManager.TypeEnum.Shared) + val vehicleManager = VehicleManager.createOrGetReservedFor(config.name, Some(VehicleManager.TypeEnum.Shared)) val parkingFilePath = config.parkingFilePath config.managerType match { case "fixed-non-reserving-fleet-by-taz" => diff --git a/src/main/scala/beam/utils/BeamVehicleUtils.scala b/src/main/scala/beam/utils/BeamVehicleUtils.scala index 9f7a3477a17..74c9e61df60 100755 --- a/src/main/scala/beam/utils/BeamVehicleUtils.scala +++ b/src/main/scala/beam/utils/BeamVehicleUtils.scala @@ -81,6 +81,7 @@ object BeamVehicleUtils extends LazyLogging { 9000 // Class 4-6 (GVWR 14001-26000 lbs. => 6000-15000, and average of 8000-9000 lbs curb weight) case VehicleCategory.Class78Vocational => 13000 // CLass 7&8 (GVWR 26001 to >33,001 lbs.) case VehicleCategory.Class78Tractor => 20000 // CLass 7&8 (GVWR 26001 to >33,001 lbs.) +// case VehicleCategory.AnyCategory => 0 } def readBeamVehicleTypeFile(filePath: String): Map[Id[BeamVehicleType], BeamVehicleType] = { diff --git a/src/main/scala/beam/utils/DateUtils.scala b/src/main/scala/beam/utils/DateUtils.scala index dae0bda30f5..e4a17faa4d9 100755 --- a/src/main/scala/beam/utils/DateUtils.scala +++ b/src/main/scala/beam/utils/DateUtils.scala @@ -27,6 +27,11 @@ object DateUtils { timeAr(0).toInt * 3600 + timeAr(1).toInt * 60 + timeAr(2).toInt } + def getLastTransitTripTime(beamConfig: beam.sim.config.BeamConfig): Int = { + val timeAr = beamConfig.beam.agentsim.lastTransitTrip.split(":") + timeAr(0).toInt * 3600 + timeAr(1).toInt * 60 + timeAr(2).toInt + } + def getMaxHour(beamConfig: beam.sim.config.BeamConfig): Int = Math .ceil( diff --git a/src/main/scala/beam/utils/EventReader.scala b/src/main/scala/beam/utils/EventReader.scala index d826442b3b2..24aa828a2cf 100644 --- a/src/main/scala/beam/utils/EventReader.scala +++ b/src/main/scala/beam/utils/EventReader.scala @@ -1,23 +1,19 @@ package beam.utils -import java.io._ -import java.net.URL -import java.nio.charset.StandardCharsets -import java.util -import java.util.zip.GZIPInputStream - import beam.agentsim.events._ import org.matsim.api.core.v01.events.{Event, GenericEvent} import org.matsim.core.api.experimental.events.EventsManager import org.matsim.core.config.Config import org.matsim.core.events.handler.BasicEventHandler import org.matsim.core.events.{EventsUtils, MatsimEventsReader} -import org.matsim.core.utils.io.UnicodeInputStream import org.supercsv.io.CsvMapReader import org.supercsv.prefs.CsvPreference +import java.io._ +import java.net.URL +import java.util +import java.util.zip.GZIPInputStream import scala.collection.mutable.ArrayBuffer -import scala.reflect.ClassTag class DummyEvent(attribs: java.util.Map[String, String]) extends Event(attribs.get("time").toDouble) { override def getEventType: String = attribs.get("type") diff --git a/src/main/scala/beam/utils/csv/readers/BeamCsvScenarioReader.scala b/src/main/scala/beam/utils/csv/readers/BeamCsvScenarioReader.scala index cdd002e78ee..9214816e805 100644 --- a/src/main/scala/beam/utils/csv/readers/BeamCsvScenarioReader.scala +++ b/src/main/scala/beam/utils/csv/readers/BeamCsvScenarioReader.scala @@ -101,6 +101,8 @@ object BeamCsvScenarioReader extends BeamScenarioReader with ExponentialLazyLogg legMode = Option(rec.get("legMode")), legDepartureTime = Option(rec.get("legDepartureTime")), legTravelTime = Option(rec.get("legTravelTime")), + legExpectedTravelTime = Option(rec.get("trip_dur_min")).map(_.toDouble), + legExpectedCost = Option(rec.get("trip_cost_dollars")).map(_.toDouble), legRouteType = Option(rec.get("legRouteType")), legRouteStartLink = Option(rec.get("legRouteStartLink")), legRouteEndLink = Option(rec.get("legRouteEndLink")), diff --git a/src/main/scala/beam/utils/csv/writers/PlansCsvWriter.scala b/src/main/scala/beam/utils/csv/writers/PlansCsvWriter.scala index d864a3af320..66522cb3c33 100755 --- a/src/main/scala/beam/utils/csv/writers/PlansCsvWriter.scala +++ b/src/main/scala/beam/utils/csv/writers/PlansCsvWriter.scala @@ -25,6 +25,8 @@ object PlansCsvWriter extends ScenarioCsvWriter { "activityEndTime", "legMode", "legDepartureTime", + "trip_dur_min", + "trip_cost_dollars", "legTravelTime", "legRouteType", "legRouteStartLink", @@ -96,6 +98,12 @@ object PlansCsvWriter extends ScenarioCsvWriter { legMode = mode, legDepartureTime = leg.getDepartureTime.toOption.map(_.toString), legTravelTime = leg.getTravelTime.toOption.map(_.toString), + legExpectedTravelTime = + Option(leg.getAttributes.getAttribute("trip_dur_min")).map(_.toString).filterNot(_.isEmpty).map(_.toDouble), + legExpectedCost = Option(leg.getAttributes.getAttribute("trip_cost_dollars")) + .map(_.toString) + .filterNot(_.isEmpty) + .map(_.toDouble), legRouteType = route.map(_.getRouteType), legRouteStartLink = route.map(_.getStartLinkId.toString), legRouteEndLink = route.map(_.getEndLinkId.toString), @@ -121,6 +129,8 @@ object PlansCsvWriter extends ScenarioCsvWriter { legMode = None, legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = None, + legExpectedCost = None, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, @@ -158,6 +168,8 @@ object PlansCsvWriter extends ScenarioCsvWriter { planInfo.activityEndTime.map(_.toString).getOrElse(""), planInfo.legMode.getOrElse(""), planInfo.legDepartureTime.getOrElse(""), + planInfo.legExpectedTravelTime.getOrElse(""), + planInfo.legExpectedCost.getOrElse(""), planInfo.legTravelTime.getOrElse(""), planInfo.legRouteType.getOrElse(""), planInfo.legRouteStartLink.getOrElse(""), diff --git a/src/main/scala/beam/utils/scenario/BeamScenarioLoader.scala b/src/main/scala/beam/utils/scenario/BeamScenarioLoader.scala index 0b88db20014..5de041b77f2 100644 --- a/src/main/scala/beam/utils/scenario/BeamScenarioLoader.scala +++ b/src/main/scala/beam/utils/scenario/BeamScenarioLoader.scala @@ -379,8 +379,7 @@ object BeamScenarioLoader extends ExponentialLazyLogging { val beamVehicleType = map(beamVehicleTypeId) - val vehicleManagerId = - VehicleManager.createOrGetReservedFor(info.householdId, VehicleManager.TypeEnum.Household).managerId + val vehicleManagerId = VehicleManager.createOrGetReservedFor(info.householdId).managerId val powerTrain = new Powertrain(beamVehicleType.primaryFuelConsumptionInJoulePerMeter) new BeamVehicle( beamVehicleId, diff --git a/src/main/scala/beam/utils/scenario/Models.scala b/src/main/scala/beam/utils/scenario/Models.scala index c90a4197a54..d93e9f57334 100644 --- a/src/main/scala/beam/utils/scenario/Models.scala +++ b/src/main/scala/beam/utils/scenario/Models.scala @@ -56,6 +56,8 @@ case class PlanElement( legMode: Option[String], legDepartureTime: Option[String], legTravelTime: Option[String], + legExpectedTravelTime: Option[Double], + legExpectedCost: Option[Double], legRouteType: Option[String], legRouteStartLink: Option[String], legRouteEndLink: Option[String], diff --git a/src/main/scala/beam/utils/scenario/UrbanSimScenarioLoader.scala b/src/main/scala/beam/utils/scenario/UrbanSimScenarioLoader.scala index 3c0f970302b..e26f431d3b4 100644 --- a/src/main/scala/beam/utils/scenario/UrbanSimScenarioLoader.scala +++ b/src/main/scala/beam/utils/scenario/UrbanSimScenarioLoader.scala @@ -19,6 +19,7 @@ import org.matsim.core.population.routes.{NetworkRoute, RouteUtils} import org.matsim.core.scenario.MutableScenario import org.matsim.households._ import org.matsim.vehicles.{Vehicle, VehicleType, VehicleUtils} +import beam.utils.OptionalUtils.OptionalTimeExtension import scala.collection.JavaConverters._ import scala.collection.mutable.ArrayBuffer @@ -54,10 +55,16 @@ class UrbanSimScenarioLoader( private def buildAndAddLegToPlan(currentPlan: Plan, planElement: PlanElement): Leg = { val leg = PopulationUtils.createAndAddLeg(currentPlan, planElement.legMode.getOrElse("")) planElement.legDepartureTime.foreach(v => leg.setDepartureTime(v.toDouble)) - planElement.legTravelTime.foreach(v => leg.setTravelTime(v.toDouble)) + planElement.legTravelTime.foreach(travelTimeStr => { + val travelTime = travelTimeStr.toDouble + if (travelTime == beam.UNDEFINED_TIME) leg.setTravelTimeUndefined() + else leg.setTravelTime(travelTime) + }) planElement.legMode.foreach(v => leg.setMode(v)) leg.getAttributes.putAttribute("trip_id", planElement.tripId) leg.getAttributes.putAttribute("tour_id", planElement.tourId) + leg.getAttributes.putAttribute("trip_dur_min", planElement.legExpectedTravelTime.getOrElse("")) + leg.getAttributes.putAttribute("trip_cost_dollars", planElement.legExpectedCost.getOrElse("")) val legRoute: NetworkRoute = { val links = planElement.legRouteLinks.map(v => Id.create(v, classOf[Link])).asJava diff --git a/src/main/scala/beam/utils/scenario/generic/readers/PlanElementReader.scala b/src/main/scala/beam/utils/scenario/generic/readers/PlanElementReader.scala index 9560885dc46..e51063d066c 100644 --- a/src/main/scala/beam/utils/scenario/generic/readers/PlanElementReader.scala +++ b/src/main/scala/beam/utils/scenario/generic/readers/PlanElementReader.scala @@ -70,6 +70,8 @@ object CsvPlanElementReader extends PlanElementReader { legMode = Option(rec.get("legMode")), legDepartureTime = Option(rec.get("legDepartureTime")), legTravelTime = Option(rec.get("legTravelTime")), + legExpectedTravelTime = Option(rec.get("trip_dur_min")).map(_.toDouble), + legExpectedCost = Option(rec.get("trip_cost_dollars")).map(_.toDouble), legRouteType = Option(rec.get("legRouteType")), legRouteStartLink = Option(rec.get("legRouteStartLink")), legRouteEndLink = Option(rec.get("legRouteEndLink")), @@ -96,8 +98,10 @@ object XmlPlanElementReader extends PlanElementReader { } } .collect { - case (person, plan, planIdx, act: Activity, planElIdx) => toPlanElement(act, plan, planIdx, person, planElIdx) - case (person, plan, planIdx, leg: Leg, planElIdx) => toPlanElement(leg, plan, planIdx, person, planElIdx) + case (person, plan, planIdx, act: Activity, planElIdx) if act != null => + toPlanElement(act, plan, planIdx, person, planElIdx) + case (person, plan, planIdx, leg: Leg, planElIdx) if leg != null => + toPlanElement(leg, plan, planIdx, person, planElIdx) } .toArray } @@ -162,6 +166,8 @@ object XmlPlanElementReader extends PlanElementReader { legMode = None, legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = None, + legExpectedCost = None, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, @@ -190,9 +196,17 @@ object XmlPlanElementReader extends PlanElementReader { activityLocationX = None, activityLocationY = None, activityEndTime = None, - legMode = Option(leg.getMode), + legMode = Option(leg).map(_.getMode), legDepartureTime = leg.getDepartureTime.toOption.map(_.toString), legTravelTime = leg.getTravelTime.toOption.map(_.toString), + legExpectedTravelTime = Option(leg.getAttributes.getAttribute("trip_dur_min")) + .filter(_.toString.nonEmpty) + .map(_.toString) + .map(_.toDouble), + legExpectedCost = Option(leg.getAttributes.getAttribute("trip_cost_dollars")) + .filter(_.toString.nonEmpty) + .map(_.toString) + .map(_.toDouble), legRouteType = Option(leg.getRoute).map(_.getRouteType), legRouteStartLink = Option(leg.getRoute).map(_.getStartLinkId.toString), legRouteEndLink = Option(leg.getRoute).map(_.getEndLinkId.toString), diff --git a/src/main/scala/beam/utils/scenario/urbansim/HOVModeTransformer.scala b/src/main/scala/beam/utils/scenario/urbansim/HOVModeTransformer.scala index af690c36fd4..0d83ddd9beb 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/HOVModeTransformer.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/HOVModeTransformer.scala @@ -37,6 +37,15 @@ import scala.util.Random */ object HOVModeTransformer extends ExponentialLazyLogging { + private val summaryStats = mutable.Map[String, Int]( + "forcedHOV2Teleports" -> 0, + "forcedHOV3Teleports" -> 0, + "forcedCarHOV2Count" -> 0, + "forcedCarHOV3Count" -> 0, + "randomHOV2Choices" -> 0, + "randomHOV3Choices" -> 0 + ) + def reseedRandomGenerator(randomSeed: Int): Unit = rand.setSeed(randomSeed) private implicit val rand: Random = new Random(42) @@ -65,13 +74,12 @@ object HOVModeTransformer extends ExponentialLazyLogging { def transformHOVtoHOVCARorHOVTeleportation( plansProbablyWithHOV: Iterable[PlanElement] ): Iterable[PlanElement] = { - val allHOVUsers: Set[PersonId] = plansProbablyWithHOV - .filter(planElement => { - val legMode = planElement.legMode.map(_.toLowerCase) - legMode.contains(hov2) || legMode.contains(hov3) - }) - .map(_.personId) - .toSet + + val allHOVUsers: Set[PersonId] = + plansProbablyWithHOV + .filter(x => x.legMode.exists(m => m.contains(hov2) || m.contains(hov3))) + .map(_.personId) + .toSet var forcedHOV2Teleports = 0 var forcedHOV3Teleports = 0 @@ -91,10 +99,12 @@ object HOVModeTransformer extends ExponentialLazyLogging { trip.map { case hov2Leg if itIsAnHOV2Leg(hov2Leg) => forcedHOV2Teleports -= 1 + summaryStats("forcedCarHOV2Count") += 1 hov2Leg.copy(legMode = Some(CAR_HOV2.value)) case hov3Leg if itIsAnHOV3Leg(hov3Leg) => // as car_hov3 contains two passengers, reduce by 2 forcedHOV3Teleports -= 2 + summaryStats("forcedCarHOV3Count") += 1 hov3Leg.copy(legMode = Some(CAR_HOV3.value)) case other => other } @@ -104,9 +114,11 @@ object HOVModeTransformer extends ExponentialLazyLogging { trip.map { case hov2Leg if itIsAnHOV2Leg(hov2Leg) => forcedCarHOV2Count -= 1 + summaryStats("forcedHOV2Teleports") += 1 hov2Leg.copy(legMode = Some(HOV2_TELEPORTATION.value)) case hov3Leg if itIsAnHOV3Leg(hov3Leg) => forcedCarHOV3Count -= 1 + summaryStats("forcedHOV3Teleports") += 1 hov3Leg.copy(legMode = Some(HOV3_TELEPORTATION.value)) case other => other } @@ -119,23 +131,39 @@ object HOVModeTransformer extends ExponentialLazyLogging { val (mappedTrip, forcedHOV2, forcedHOV3) = mapToForcedHOVTeleportation(trip) forcedHOV2Teleports += forcedHOV2 forcedHOV3Teleports += forcedHOV3 + summaryStats("forcedHOV2Teleports") += forcedHOV2 + summaryStats("forcedHOV3Teleports") += forcedHOV3 mappedTrip } else if (isForcedCarHOVTrip(trip)) { val (mappedTrip, forcedHOV2, forcedHOV3) = mapToForcedCarHOVTrip(trip) forcedCarHOV2Count += forcedHOV2 forcedCarHOV3Count += forcedHOV3 + summaryStats("forcedCarHOV2Count") += forcedHOV2 + summaryStats("forcedCarHOV3Count") += forcedHOV3 mappedTrip } else if (thereAreMoreHOVTeleportations) { replaceHOVwithCar(trip) } else if (thereAreMoreHOVCars) { replaceHOVwithTeleportation(trip) } else { - mapRandomHOVTeleportationOrCar(trip) + val transformedTrip = mapRandomHOVTeleportationOrCar(trip) + transformedTrip.foreach { + case leg if itIsAnHOV2Leg(leg) => summaryStats("randomHOV2Choices") += 1 + case leg if itIsAnHOV3Leg(leg) => summaryStats("randomHOV3Choices") += 1 + case _ => + } + transformedTrip } } else { trip } } + + // Log summary at the end + logger.info( + s"Summary of HOV transformation: ${summaryStats.map { case (k, v) => s"$k: $v" }.mkString(", ")}" + ) + // we need to merge plans without creating duplicates of home activity for persons with more than one trip val plans = joinTripsIntoPlans(tripsTransformed) plans @@ -252,12 +280,12 @@ object HOVModeTransformer extends ExponentialLazyLogging { def itIsAnHOV2Leg(planElement: PlanElement): Boolean = { planElement.planElementType == PlanElement.Leg && - planElement.legMode.exists(legMode => legMode.toLowerCase == hov2) + planElement.legMode.exists(legMode => legMode.contains(hov2)) } def itIsAnHOV3Leg(planElement: PlanElement): Boolean = { planElement.planElementType == PlanElement.Leg && - planElement.legMode.exists(legMode => legMode.toLowerCase == hov3) + planElement.legMode.exists(legMode => legMode.contains(hov3)) } def itIsASOVLeg(planElement: PlanElement): Boolean = { diff --git a/src/main/scala/beam/utils/scenario/urbansim/UrbanSimScenarioSource.scala b/src/main/scala/beam/utils/scenario/urbansim/UrbanSimScenarioSource.scala index f09eb951225..57d70efa3e7 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/UrbanSimScenarioSource.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/UrbanSimScenarioSource.scala @@ -75,6 +75,8 @@ class UrbanSimScenarioSource( // TODO: DataExchange.PlanElement does not have the following leg information legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = None, + legExpectedCost = None, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, diff --git a/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/InputPlanElement.scala b/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/InputPlanElement.scala index eeff65464ba..fdad8d6b379 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/InputPlanElement.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/InputPlanElement.scala @@ -14,7 +14,9 @@ case class InputPlanElement( ActivityType: Option[String], x: Option[Double], y: Option[Double], - departureTime: Option[Double] + departureTime: Option[Double], + expectedDurationMinutes: Option[Double] = None, + expectedCostDollars: Option[Double] = None ) object InputPlanElement extends EntityTransformer[InputPlanElement] { @@ -30,6 +32,8 @@ object InputPlanElement extends EntityTransformer[InputPlanElement] { val xWgs = getOptional(m, "x").map(_.toDouble) val yWgs = getOptional(m, "y").map(_.toDouble) val departureTime = getOptional(m, "departure_time").map(_.toDouble) + val expectedDurationMinutes = getOptional(m, "trip_dur_min").map(_.toDouble) + val expectedCostDollars = getOptional(m, "trip_cost_dollars").map(_.toDouble) InputPlanElement( tripId, @@ -41,7 +45,9 @@ object InputPlanElement extends EntityTransformer[InputPlanElement] { activityType, xWgs, yWgs, - departureTime + departureTime, + expectedDurationMinutes, + expectedCostDollars ) } } diff --git a/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/PersonInfo.scala b/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/PersonInfo.scala index 3f91f9eca98..9b1269cefe6 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/PersonInfo.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/censusblock/entities/PersonInfo.scala @@ -1,8 +1,8 @@ package beam.utils.scenario.urbansim.censusblock.entities import java.util - import beam.utils.scenario.urbansim.censusblock.EntityTransformer +import org.apache.commons.lang3.math.NumberUtils import scala.annotation.switch @@ -31,7 +31,8 @@ case class InputPersonInfo( householdId: String, age: Int, sex: Sex, - industry: Option[String] + industry: Option[String], + valueOfTime: Option[Double] ) object InputPersonInfo extends EntityTransformer[InputPersonInfo] { @@ -42,7 +43,8 @@ object InputPersonInfo extends EntityTransformer[InputPersonInfo] { val age = getIfNotNull(rec, "age").toInt val sex = Sex.determineSex(getIfNotNull(rec, "sex").toInt) val industry = Option(rec.get("industry")) + val valueOfTime = Option(NumberUtils.toDouble(rec.get("value_of_time"))) - InputPersonInfo(personId, householdId, age, sex, industry) + InputPersonInfo(personId, householdId, age, sex, industry, valueOfTime) } } diff --git a/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PersonMerger.scala b/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PersonMerger.scala index d0cee5b0497..b80bed9c1de 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PersonMerger.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PersonMerger.scala @@ -8,8 +8,9 @@ class PersonMerger(inputHousehold: Map[String, InputHousehold]) extends Merger[I override def merge(iter: Iterator[InputPersonInfo]): Iterator[PersonInfo] = iter.map(inputToOutput) private def inputToOutput(inputPersonInfo: InputPersonInfo): PersonInfo = { - val inputIncome = inputHousehold(inputPersonInfo.householdId).income - val income = PopulationAdjustment.incomeToValueOfTime(inputIncome).getOrElse(0d) + val valueOfTime = inputPersonInfo.valueOfTime.getOrElse( + PopulationAdjustment.incomeToValueOfTime(inputHousehold(inputPersonInfo.householdId).income).getOrElse(0d) + ) PersonInfo( personId = PersonId(inputPersonInfo.personId), @@ -19,7 +20,7 @@ class PersonMerger(inputHousehold: Map[String, InputHousehold]) extends Merger[I excludedModes = Seq.empty, rideHailServiceSubscription = Seq.empty, isFemale = inputPersonInfo.sex.isFemale, - valueOfTime = income, + valueOfTime = valueOfTime, industry = inputPersonInfo.industry ) } diff --git a/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PlanMerger.scala b/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PlanMerger.scala index a7b10ac2ef5..851df0bb685 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PlanMerger.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/censusblock/merger/PlanMerger.scala @@ -24,6 +24,8 @@ class PlanMerger(modeMap: Map[String, String]) extends Merger[InputPlanElement, inputPlanElement.tripMode.map(convertMode), legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = inputPlanElement.expectedDurationMinutes, + legExpectedCost = inputPlanElement.expectedCostDollars, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, diff --git a/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/CsvReaders.scala b/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/CsvReaders.scala index 77c5dacccf5..a1a44760f4c 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/CsvReaders.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/CsvReaders.scala @@ -18,7 +18,8 @@ class CsvPersonReader(path: String) extends BaseCsvReader[InputPersonInfo](path) householdId = record.get("household_id"), age = record.get("age").toInt, sex = Sex.determineSex(record.get("sex").toInt), - industry = Option(record.get("industry")) + industry = Option(record.get("industry")), + valueOfTime = Option(record.get("value_of_time")).map(_.toDouble) ) } } @@ -40,7 +41,9 @@ class CsvPlanReader(path: String) extends BaseCsvReader[InputPlanElement](path) ActivityType = Option(record.get("ActivityType")), x = Option(record.get("x")).map(_.toDouble), y = Option(record.get("y")).map(_.toDouble), - departureTime = Option(record.get("departure_time")).map(_.toDouble) + departureTime = Option(record.get("departure_time")).map(_.toDouble), + expectedDurationMinutes = Option(record.get("trip_dur_min")).map(_.toString.toDouble), + expectedCostDollars = Option(record.get("trip_cost_dollars")).map(_.toString.toDouble) ) } } @@ -54,7 +57,7 @@ class CsvHouseholdReader(path: String) extends BaseCsvReader[InputHousehold](pat InputHousehold( householdId = record.get("household_id"), cars = Try(record.get("cars").toInt).getOrElse(record.get("auto_ownership").toInt), - income = record.get("income").toInt, + income = Math.round(record.get("income").toFloat), blockId = record.get("block_id").toLong ) } diff --git a/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/ParquetReaders.scala b/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/ParquetReaders.scala index abdcba51da8..e440dbfcb49 100644 --- a/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/ParquetReaders.scala +++ b/src/main/scala/beam/utils/scenario/urbansim/censusblock/reader/ParquetReaders.scala @@ -21,7 +21,8 @@ class ParquetPersonReader(path: String) extends BaseParquetReader[InputPersonInf householdId = record.get("household_id").toString.split("\\.")(0), age = record.get("age").toString.toDouble.toInt, sex = Sex.determineSex(record.get("sex").toString.toDouble.toInt), - industry = industryField + industry = industryField, + valueOfTime = Try(record.get("value_of_time")).map(_.toString.toDouble).toOption // TODO: probably a better way ) } } @@ -36,11 +37,13 @@ class ParquetPlanReader(path: String) extends BaseParquetReader[InputPlanElement personId = personId, planElementIndex = record.get("PlanElementIndex").toString.toInt, activityElement = ActivityType.determineActivity(record.get("ActivityElement").toString), - tripMode = Option(record.get("trip_mode")).map(_.toString), - ActivityType = Option(record.get("ActivityType")).map(_.toString), + tripMode = Option(record.get("trip_mode")).map(_.toString).filterNot(_ == "nan"), + ActivityType = Option(record.get("ActivityType")).map(_.toString).filterNot(_ == "nan"), x = Option(record.get("x")).map(_.toString.toDouble), y = Option(record.get("y")).map(_.toString.toDouble), - departureTime = Option(record.get("departure_time")).map(_.toString.toDouble) + departureTime = Option(record.get("departure_time")).map(_.toString.toDouble), + expectedDurationMinutes = Option(record.get("trip_dur_min")).map(_.toString.toDouble), + expectedCostDollars = Option(record.get("trip_cost_dollars")).map(_.toString.toDouble) ) } } diff --git a/src/main/scala/scripts/NetworkRelaxationScenarioGenerator.scala b/src/main/scala/scripts/NetworkRelaxationScenarioGenerator.scala index 9758814c821..37f544dd1bf 100644 --- a/src/main/scala/scripts/NetworkRelaxationScenarioGenerator.scala +++ b/src/main/scala/scripts/NetworkRelaxationScenarioGenerator.scala @@ -42,11 +42,15 @@ class NetworkRelaxationScenarioGenerator { householdId = i.toString, age = 20 + Random.nextInt(50), sex = if (Random.nextBoolean()) Male else Female, + None, None ) } val csvWriter = - new CsvWriter(scenarioDir.getPath + "/persons.csv.gz", Seq("person_id", "household_id", "age", "sex")) + new CsvWriter( + scenarioDir.getPath + "/persons.csv.gz", + Seq("person_id", "household_id", "age", "sex", "value_of_time") + ) try { persons.foreach { person => csvWriter.write( @@ -56,7 +60,8 @@ class NetworkRelaxationScenarioGenerator { person.sex match { case Male => 1 case Female => 2 - } + }, + person.valueOfTime.getOrElse("") ) } } finally { diff --git a/src/main/scala/scripts/R5Requester.scala b/src/main/scala/scripts/R5Requester.scala index 5ace76c5f69..bbd0405373f 100644 --- a/src/main/scala/scripts/R5Requester.scala +++ b/src/main/scala/scripts/R5Requester.scala @@ -7,6 +7,7 @@ import beam.router.BeamRouter.{Location, RoutingRequest} import beam.router.Modes.BeamMode import beam.router.r5.{R5Parameters, R5Wrapper} import beam.router.{BeamRouter, FreeFlowTravelTime} +import beam.router.BeamTravelTime import beam.sim.BeamHelper import beam.sim.common.GeoUtils import beam.sim.population.{AttributesOfIndividual, HouseholdAttributes} @@ -368,6 +369,8 @@ object R5Requester extends BeamHelper { None, None, None, + None, + None, Seq.empty, None ) diff --git a/src/main/scala/scripts/calibration/ExperimentRunner.scala b/src/main/scala/scripts/calibration/ExperimentRunner.scala index 463535efc34..9279edb0b17 100755 --- a/src/main/scala/scripts/calibration/ExperimentRunner.scala +++ b/src/main/scala/scripts/calibration/ExperimentRunner.scala @@ -85,7 +85,7 @@ case class ExperimentRunner()(implicit experimentData: SigoptExperimentData) ext } if (objectiveFunctionClassName.equals("CountsObjectiveFunction")) { val outpath = Paths.get( - ioController.getIterationFilename(runConfig.controler().getLastIteration, "countscompare.txt") + ioController.getIterationFilename(runConfig.controler().getLastIteration, "countsCompare.txt") ) CountsObjectiveFunction.evaluateFromRun(outpath.toAbsolutePath.toString) } else if (objectiveFunctionClassName.equals("ModeChoiceObjectiveFunction_RMSPE") && benchmarkFileExists) { @@ -120,7 +120,7 @@ case class ExperimentRunner()(implicit experimentData: SigoptExperimentData) ext ) } else if (objectiveFunctionClassName.equals("ModeChoiceAndCountsObjectiveFunction") && benchmarkFileExists) { var outpath = Paths.get( - ioController.getIterationFilename(runConfig.controler().getLastIteration, "countscompare.txt") + ioController.getIterationFilename(runConfig.controler().getLastIteration, "countsCompare.txt") ) val countsObjVal = CountsObjectiveFunction.evaluateFromRun(outpath.toAbsolutePath.toString) diff --git a/src/main/scala/scripts/shape/FilterPointsInShapeFile.scala b/src/main/scala/scripts/shape/FilterPointsInShapeFile.scala index 8a59ed052ff..611c34bf6b0 100644 --- a/src/main/scala/scripts/shape/FilterPointsInShapeFile.scala +++ b/src/main/scala/scripts/shape/FilterPointsInShapeFile.scala @@ -34,8 +34,8 @@ object FilterPointsInShapeFile { val points = planReader .iterator() .flatMap { - case InputPlanElement(_, _, personId, _, _, _, _, Some(x), Some(y), _) => Some(personId, x, y) - case _ => None + case InputPlanElement(_, _, personId, _, _, _, _, Some(x), Some(y), _, _, _) => Some(personId, x, y) + case _ => None } .map { case (personId, x, y) => (personId, gf.createPoint(new Coordinate(x, y))) } diff --git a/src/main/scala/scripts/synthpop/PumaLevelScenarioGenerator.scala b/src/main/scala/scripts/synthpop/PumaLevelScenarioGenerator.scala index 67c83abb0c7..4922ac069e7 100644 --- a/src/main/scala/scripts/synthpop/PumaLevelScenarioGenerator.scala +++ b/src/main/scala/scripts/synthpop/PumaLevelScenarioGenerator.scala @@ -73,6 +73,8 @@ class PumaLevelScenarioGenerator( legMode = None, legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = None, + legExpectedCost = None, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, diff --git a/src/main/scala/scripts/synthpop/ScenarioGenerator.scala b/src/main/scala/scripts/synthpop/ScenarioGenerator.scala index 069cb2b4506..49fa0bc7733 100644 --- a/src/main/scala/scripts/synthpop/ScenarioGenerator.scala +++ b/src/main/scala/scripts/synthpop/ScenarioGenerator.scala @@ -98,6 +98,8 @@ class SimpleScenarioGenerator( legMode = None, legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = None, + legExpectedCost = None, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, diff --git a/src/test/java/beam/analysis/plots/FuelUsageGraphTest.java b/src/test/java/beam/analysis/plots/FuelUsageGraphTest.java index 0e4b534df49..29686853ee3 100755 --- a/src/test/java/beam/analysis/plots/FuelUsageGraphTest.java +++ b/src/test/java/beam/analysis/plots/FuelUsageGraphTest.java @@ -25,7 +25,7 @@ private static class FuelUsageHandler implements BasicEventHandler { @Override public void handleEvent(Event event) { - if (event instanceof PathTraversalEvent ) { + if (event instanceof PathTraversalEvent) { fuelUsageStats.processStats(event); } } @@ -49,7 +49,7 @@ public void setUpClass() { @Test public void testShouldPassShouldReturnPathTraversalEventCarFuel() { - long expectedResult = 675705873L; + long expectedResult = 675705883L; int maxHour = getMaxHour(stats.keySet()); long actualResult = getFuelageHoursDataCountOccurrenceAgainstMode(CAR, maxHour, stats); assertEquals(expectedResult, actualResult); @@ -57,7 +57,7 @@ public void testShouldPassShouldReturnPathTraversalEventCarFuel() { @Test public void testShouldPassShouldReturnPathTraversalBusFuel() { - long expectedResult = 135249995867L; + long expectedResult = 135249993216L; int maxHour = getMaxHour(stats.keySet()); long actualResult = getFuelageHoursDataCountOccurrenceAgainstMode(BUS, maxHour, stats); assertEquals(expectedResult, actualResult); diff --git a/src/test/scala/beam/agentsim/agents/PersonAgentSpec.scala b/src/test/scala/beam/agentsim/agents/PersonAgentSpec.scala index b466ead3190..f4325f928dd 100644 --- a/src/test/scala/beam/agentsim/agents/PersonAgentSpec.scala +++ b/src/test/scala/beam/agentsim/agents/PersonAgentSpec.scala @@ -405,7 +405,7 @@ class PersonAgentSpec population = population, household = household, vehicles = Map(), - fallbackHomeCoord = new Coord(0.0, 0.0), + fallbackInitialLocationCoord = new Coord(0.0, 0.0), Vector(), Set.empty, new RouteHistory(beamConfig), diff --git a/src/test/scala/beam/agentsim/agents/PersonAndTransitDriverSpec.scala b/src/test/scala/beam/agentsim/agents/PersonAndTransitDriverSpec.scala index aa3930bf762..d1d92590d5b 100644 --- a/src/test/scala/beam/agentsim/agents/PersonAndTransitDriverSpec.scala +++ b/src/test/scala/beam/agentsim/agents/PersonAndTransitDriverSpec.scala @@ -300,7 +300,7 @@ class PersonAndTransitDriverSpec population = population, household = household, vehicles = Map(), - fallbackHomeCoord = new Coord(0.0, 0.0), + fallbackInitialLocationCoord = new Coord(0.0, 0.0), Vector(), Set.empty, new RouteHistory(beamConfig), diff --git a/src/test/scala/beam/agentsim/agents/PersonWithVehicleSharingSpec.scala b/src/test/scala/beam/agentsim/agents/PersonWithVehicleSharingSpec.scala index 8082e1c18d1..e20bb2b34ee 100644 --- a/src/test/scala/beam/agentsim/agents/PersonWithVehicleSharingSpec.scala +++ b/src/test/scala/beam/agentsim/agents/PersonWithVehicleSharingSpec.scala @@ -154,7 +154,8 @@ class PersonWithVehicleSharingSpec mockSharedVehicleFleet.expectMsgType[MobilityStatusInquiry] val vehicleType = beamScenario.vehicleTypes(Id.create("sharedVehicle-sharedCar", classOf[BeamVehicleType])) - val managerId = VehicleManager.createOrGetReservedFor("shared-fleet-1", VehicleManager.TypeEnum.Shared).managerId + val managerId = + VehicleManager.createOrGetReservedFor("shared-fleet-1", Some(VehicleManager.TypeEnum.Shared)).managerId // I give it a car to use. val vehicle = new BeamVehicle( vehicleId, @@ -315,7 +316,8 @@ class PersonWithVehicleSharingSpec val vehicleType = beamScenario.vehicleTypes(Id.create("sharedVehicle-sharedCar", classOf[BeamVehicleType])) // I give it a car to use. - val managerId = VehicleManager.createOrGetReservedFor("shared-fleet-1", VehicleManager.TypeEnum.Shared).managerId + val managerId = + VehicleManager.createOrGetReservedFor("shared-fleet-1", Some(VehicleManager.TypeEnum.Shared)).managerId val vehicle = new BeamVehicle( vehicleId, new Powertrain(0.0), diff --git a/src/test/scala/beam/agentsim/agents/ridehail/MatchingAlgorithmsForRideHailSpec.scala b/src/test/scala/beam/agentsim/agents/ridehail/MatchingAlgorithmsForRideHailSpec.scala index f924fc24ab0..d89bdc62064 100644 --- a/src/test/scala/beam/agentsim/agents/ridehail/MatchingAlgorithmsForRideHailSpec.scala +++ b/src/test/scala/beam/agentsim/agents/ridehail/MatchingAlgorithmsForRideHailSpec.scala @@ -230,7 +230,7 @@ object MatchingAlgorithmsForRideHailSpec { VehicleManager .createOrGetReservedFor( services.beamConfig.beam.agentsim.agents.rideHail.managers.head.name, - VehicleManager.TypeEnum.RideHail + Some(VehicleManager.TypeEnum.RideHail) ) .managerId ) @@ -245,7 +245,7 @@ object MatchingAlgorithmsForRideHailSpec { VehicleManager .createOrGetReservedFor( services.beamConfig.beam.agentsim.agents.rideHail.managers.head.name, - VehicleManager.TypeEnum.RideHail + Some(VehicleManager.TypeEnum.RideHail) ) .managerId ) @@ -314,7 +314,7 @@ object MatchingAlgorithmsForRideHailSpec { VehicleManager .createOrGetReservedFor( services.beamConfig.beam.agentsim.agents.rideHail.managers.head.name, - VehicleManager.TypeEnum.RideHail + Some(VehicleManager.TypeEnum.RideHail) ) .managerId ) @@ -329,7 +329,7 @@ object MatchingAlgorithmsForRideHailSpec { VehicleManager .createOrGetReservedFor( services.beamConfig.beam.agentsim.agents.rideHail.managers.head.name, - VehicleManager.TypeEnum.RideHail + Some(VehicleManager.TypeEnum.RideHail) ) .managerId ) @@ -424,7 +424,7 @@ object MatchingAlgorithmsForRideHailSpec { VehicleManager .createOrGetReservedFor( services.beamConfig.beam.agentsim.agents.rideHail.managers.head.name, - VehicleManager.TypeEnum.RideHail + Some(VehicleManager.TypeEnum.RideHail) ) .managerId ) @@ -439,7 +439,7 @@ object MatchingAlgorithmsForRideHailSpec { VehicleManager .createOrGetReservedFor( services.beamConfig.beam.agentsim.agents.rideHail.managers.head.name, - VehicleManager.TypeEnum.RideHail + Some(VehicleManager.TypeEnum.RideHail) ) .managerId ) diff --git a/src/test/scala/beam/agentsim/agents/vehicles/LinkStateOfChargeSpec.scala b/src/test/scala/beam/agentsim/agents/vehicles/LinkStateOfChargeSpec.scala index 32c40835be1..0b24a8d28f1 100644 --- a/src/test/scala/beam/agentsim/agents/vehicles/LinkStateOfChargeSpec.scala +++ b/src/test/scala/beam/agentsim/agents/vehicles/LinkStateOfChargeSpec.scala @@ -90,7 +90,8 @@ class LinkStateOfChargeSpec extends AnyWordSpecLike with Matchers with BeamHelpe events .collectFirst { case pte: PathTraversalEvent if pte.vehicleId == vehicleId => - pte.endLegPrimaryFuelLevel + pte.primaryFuelConsumed + pte.endLegPrimaryFuelLevel.asInstanceOf[Double] + pte.primaryFuelConsumed.asInstanceOf[Double] + } .getOrElse(Double.NaN) } diff --git a/src/test/scala/beam/agentsim/infrastructure/HierarchicalParkingManagerSpec.scala b/src/test/scala/beam/agentsim/infrastructure/HierarchicalParkingManagerSpec.scala index 2dd4eb2da78..b011ac5cc7c 100644 --- a/src/test/scala/beam/agentsim/infrastructure/HierarchicalParkingManagerSpec.scala +++ b/src/test/scala/beam/agentsim/infrastructure/HierarchicalParkingManagerSpec.scala @@ -47,8 +47,8 @@ class HierarchicalParkingManagerSpec val randomSeed: Int = 0 // a coordinate in the center of the UTM coordinate system - val coordCenterOfUTM = new Coord(500000, 5000000) - val centerSpaceTime = SpaceTime(coordCenterOfUTM, 0) + val coordCenterOfUTM: Coord = new Coord(500000, 5000000) + val centerSpaceTime: SpaceTime = SpaceTime(coordCenterOfUTM, 0) val beamConfig: BeamConfig = BeamConfig(system.settings.config) val geo = new GeoUtilsImpl(beamConfig) @@ -81,12 +81,9 @@ class HierarchicalParkingManagerSpec } { val inquiry = ParkingInquiry.init(centerSpaceTime, "work", triggerId = 10) - val envelope = new Envelope( - inquiry.destinationUtm.loc.getX + 100, - inquiry.destinationUtm.loc.getX - 100, - inquiry.destinationUtm.loc.getY + 100, - inquiry.destinationUtm.loc.getY - 100 - ) + val (expectedStall: ParkingStall, _) = + ParkingStall.lastResortStall(inquiry.destinationUtm.loc, new Random(randomSeed)) + val response = parkingManager.processParkingInquiry(inquiry) assert(response.triggerId == 10) assert(response.stall.tazId.toString == "emergency") @@ -115,12 +112,8 @@ class HierarchicalParkingManagerSpec ) val inquiry = ParkingInquiry.init(centerSpaceTime, "work", triggerId = 34347) - val envelope = new Envelope( - inquiry.destinationUtm.loc.getX + 100, - inquiry.destinationUtm.loc.getX - 100, - inquiry.destinationUtm.loc.getY + 100, - inquiry.destinationUtm.loc.getY - 100 - ) + val (expectedStall: ParkingStall, _) = + ParkingStall.lastResortStall(inquiry.destinationUtm.loc, new Random(randomSeed)) val response = parkingManager.processParkingInquiry(inquiry) assert(response.triggerId == 34347) diff --git a/src/test/scala/beam/agentsim/infrastructure/ParallelParkingManagerSpec.scala b/src/test/scala/beam/agentsim/infrastructure/ParallelParkingManagerSpec.scala index 3ea908d3b71..b8db304be80 100644 --- a/src/test/scala/beam/agentsim/infrastructure/ParallelParkingManagerSpec.scala +++ b/src/test/scala/beam/agentsim/infrastructure/ParallelParkingManagerSpec.scala @@ -78,12 +78,9 @@ class ParallelParkingManagerSpec } { val inquiry = ParkingInquiry.init(centerSpaceTime, "work", triggerId = 11) - val envelope = new Envelope( - inquiry.destinationUtm.loc.getX + 100, - inquiry.destinationUtm.loc.getX - 100, - inquiry.destinationUtm.loc.getY + 100, - inquiry.destinationUtm.loc.getY - 100 - ) + val (expectedStall: ParkingStall, _) = + ParkingStall.lastResortStall(inquiry.destinationUtm.loc, new Random(randomSeed)) + val response = parkingManager.processParkingInquiry(inquiry) assert(response.triggerId == 11) assert(response.stall.tazId.toString == "emergency") @@ -108,12 +105,9 @@ class ParallelParkingManagerSpec ) val inquiry = ParkingInquiry.init(centerSpaceTime, "work", triggerId = 173) - val envelope = new Envelope( - inquiry.destinationUtm.loc.getX + 100, - inquiry.destinationUtm.loc.getX - 100, - inquiry.destinationUtm.loc.getY + 100, - inquiry.destinationUtm.loc.getY - 100 - ) + val (expectedStall: ParkingStall, _) = + ParkingStall.lastResortStall(inquiry.destinationUtm.loc, new Random(randomSeed)) + val response = parkingManager.processParkingInquiry(inquiry) assert(response.triggerId == 173) assert(response.stall.tazId.toString == "emergency") diff --git a/src/test/scala/beam/agentsim/infrastructure/ZonalParkingManagerSpec.scala b/src/test/scala/beam/agentsim/infrastructure/ZonalParkingManagerSpec.scala index 54749f3fba7..57e4f0b8079 100644 --- a/src/test/scala/beam/agentsim/infrastructure/ZonalParkingManagerSpec.scala +++ b/src/test/scala/beam/agentsim/infrastructure/ZonalParkingManagerSpec.scala @@ -73,37 +73,31 @@ class ZonalParkingManagerSpec val geo = new GeoUtilsImpl(beamConfig) describe("ZonalParkingManager with no parking") { - val tazTreeMap = ZonalParkingManagerSpec - .mockTazTreeMap( - coords = List((coordCenterOfUTM, 10000)), // one TAZ at agent coordinate - startAtId = 1, - xMin = 167000, - yMin = 0, - xMax = 833000, - yMax = 10000000 - ) - .get - val config = beamConfig - val emptyParkingDescription: Iterator[String] = Iterator.single(ParkingZoneFileUtils.ParkingFileHeader) - val zonalParkingManager = ZonalParkingManagerSpec.mockZonalParkingManager( - config, - tazTreeMap, - geo, - emptyParkingDescription, - boundingBox, - randomSeed - ) it("should return a response with an emergency stall") { - val inquiry = ParkingInquiry.init(centerSpaceTime, "work", triggerId = 77239) - val expectedStall: ParkingStall = ParkingStall.lastResortStall( - new Envelope( - inquiry.destinationUtm.loc.getX + 100, - inquiry.destinationUtm.loc.getX - 100, - inquiry.destinationUtm.loc.getY + 100, - inquiry.destinationUtm.loc.getY - 100 - ), - new Random(randomSeed) - ) + + for { + tazTreeMap <- ZonalParkingManagerSpec.mockTazTreeMap( + coords = List((coordCenterOfUTM, 10000)), + startAtId = 1, + xMin = 167000, + yMin = 0, + xMax = 833000, + yMax = 10000000 + ) // one TAZ at agent coordinate + config = beamConfig + emptyParkingDescription: Iterator[String] = Iterator.single(ParkingZoneFileUtils.ParkingFileHeader) + zonalParkingManager = ZonalParkingManagerSpec.mockZonalParkingManager( + config, + tazTreeMap, + geo, + emptyParkingDescription, + boundingBox, + randomSeed + ) + } { + val inquiry = ParkingInquiry.init(centerSpaceTime, "work", triggerId = 77239) + val (expectedStall: ParkingStall, _) = + ParkingStall.lastResortStall(inquiry.destinationUtm.loc, new Random(randomSeed)) val response = zonalParkingManager.processParkingInquiry(inquiry) @@ -478,8 +472,8 @@ class ZonalParkingManagerSpec describe("ZonalParkingManager with multiple parking files loaded") { it("should return the correct stall corresponding with the request (reservedFor, vehicleManagerId)") { - val sharedFleet1 = VehicleManager.createOrGetReservedFor("shared-fleet-1", VehicleManager.TypeEnum.Shared) - val sharedFleet2 = VehicleManager.createOrGetReservedFor("shared-fleet-2", VehicleManager.TypeEnum.Shared) + val sharedFleet1 = VehicleManager.createOrGetReservedFor("shared-fleet-1", Some(VehicleManager.TypeEnum.Shared)) + val sharedFleet2 = VehicleManager.createOrGetReservedFor("shared-fleet-2", Some(VehicleManager.TypeEnum.Shared)) val tazMap = taz.TAZTreeMap.fromCsv("test/input/beamville/taz-centers.csv") val stalls = InfrastructureUtils.loadStalls( "test/test-resources/beam/agentsim/infrastructure/taz-parking.csv", diff --git a/src/test/scala/beam/analysis/SimpleRideHailUtilizationTest.scala b/src/test/scala/beam/analysis/SimpleRideHailUtilizationTest.scala index cbfc1d155c0..ec31df3da47 100644 --- a/src/test/scala/beam/analysis/SimpleRideHailUtilizationTest.scala +++ b/src/test/scala/beam/analysis/SimpleRideHailUtilizationTest.scala @@ -22,8 +22,8 @@ class SimpleRideHailUtilizationTest extends AnyFunSuite with Matchers { arrivalTime = 1, mode = BeamMode.CAR, legLength = 1, - linkIds = IndexedSeq.empty, - linkTravelTime = IndexedSeq.empty, + linkIds = Array.empty, + linkTravelTime = Array.empty, startX = 0, startY = 0, endX = 1, @@ -36,10 +36,10 @@ class SimpleRideHailUtilizationTest extends AnyFunSuite with Matchers { None, None, None, - IndexedSeq.empty, - 0.0, + Array.empty, + 0.0f, None, - riders = Vector() + riders = Array.empty ) test("Should ignore non-ridehail vehicles") { diff --git a/src/test/scala/beam/analysis/cartraveltime/StudyAreaTripFilterTest.scala b/src/test/scala/beam/analysis/cartraveltime/StudyAreaTripFilterTest.scala index 700508f107a..499c5174c77 100644 --- a/src/test/scala/beam/analysis/cartraveltime/StudyAreaTripFilterTest.scala +++ b/src/test/scala/beam/analysis/cartraveltime/StudyAreaTripFilterTest.scala @@ -54,34 +54,34 @@ class StudyAreaTripFilterTest extends AnyFunSuite with Matchers { numPass = 1, beamLeg = beamLeg, currentTripMode = None, - primaryFuelConsumed = 1.0, - secondaryFuelConsumed = 0.0, - endLegPrimaryFuelLevel = 1.0, - endLegSecondaryFuelLevel = 0.0, + primaryFuelConsumed = 1.0f, + secondaryFuelConsumed = 0.0f, + endLegPrimaryFuelLevel = 1.0f, + endLegSecondaryFuelLevel = 0.0f, amountPaid = 0, - payloadIds = IndexedSeq.empty, - weight = 0.0, + payloadIds = Array.empty, + weight = 0.0f, emissionsProfile = None, - riders = Vector.empty + riders = Array.empty ) test("Should recognize that PTE is inside study area if both start and end are inside of study area") { val pteInsideStudyArea = - defaultPte.copy(startX = -97.763074, startY = 30.235920, endX = -97.687817, endY = 30.303643) + defaultPte.copy(startX = -97.763074f, startY = 30.235920f, endX = -97.687817f, endY = 30.303643f) studyAreaTripFilter.considerPathTraversal(pteInsideStudyArea) shouldBe true } test("Should recognize that PTE is outside of study area if only start is outside of study area") { - val pte = defaultPte.copy(startX = -97.792733, startY = 30.177015, endX = -97.687817, endY = 30.303643) + val pte = defaultPte.copy(startX = -97.792733f, startY = 30.177015f, endX = -97.687817f, endY = 30.303643f) studyAreaTripFilter.considerPathTraversal(pte) shouldBe false } test("Should recognize that PTE is outside of study area if only end is outside of study area") { - val pte = defaultPte.copy(startX = -97.763074, startY = 30.235920, endX = -97.661009, endY = 30.372633) + val pte = defaultPte.copy(startX = -97.763074f, startY = 30.235920f, endX = -97.661009f, endY = 30.372633f) studyAreaTripFilter.considerPathTraversal(pte) shouldBe false } test("Should recognize that PTE is outside of study area if both start and end are outside of study area") { - val pte = defaultPte.copy(startX = -97.792733, startY = 30.177015, endX = -97.661009, endY = 30.372633) + val pte = defaultPte.copy(startX = -97.792733f, startY = 30.177015f, endX = -97.661009f, endY = 30.372633f) studyAreaTripFilter.considerPathTraversal(pte) shouldBe false } } diff --git a/src/test/scala/beam/physsim/cchRoutingAssignment/RoutingFrameworkTravelTimeCalculatorSpec.scala b/src/test/scala/beam/physsim/cchRoutingAssignment/RoutingFrameworkTravelTimeCalculatorSpec.scala index 75178ebb4c3..b7f7accedfc 100644 --- a/src/test/scala/beam/physsim/cchRoutingAssignment/RoutingFrameworkTravelTimeCalculatorSpec.scala +++ b/src/test/scala/beam/physsim/cchRoutingAssignment/RoutingFrameworkTravelTimeCalculatorSpec.scala @@ -36,7 +36,7 @@ class RoutingFrameworkTravelTimeCalculatorSpec extends AnyFlatSpec with Matchers "RoutingFrameworkTravelTimeCalculator" must "create hour to travel infos map properly" in { val infos = calculator.generateHour2Events( - Lists.newArrayList(event(3500, IndexedSeq(1, 2, 3, 4, 5), IndexedSeq(30.0, 40.0, 40.0, 1300.0, 2500.0))) + Lists.newArrayList(event(3500, Array(1, 2, 3, 4, 5), Array(30.0f, 40.0f, 40.0f, 1300.0f, 2500.0f))) ) val expectedInfos = Map(1 -> Seq(TravelInfo(IndexedSeq(4, 5))), 0 -> Seq(TravelInfo(IndexedSeq(1, 2, 3)))) @@ -90,8 +90,8 @@ class RoutingFrameworkTravelTimeCalculatorSpec extends AnyFlatSpec with Matchers private def event( departureTime: Int, - linkIds: IndexedSeq[Int], - linkTravelTime: IndexedSeq[Double] + linkIds: Array[Int], + linkTravelTime: Array[Float] ): PathTraversalEvent = { val e = mock(classOf[PathTraversalEvent]) when(e.departureTime).thenReturn(departureTime) diff --git a/src/test/scala/beam/router/skim/urbansim/BackgroundSkimsCreatorTest.scala b/src/test/scala/beam/router/skim/urbansim/BackgroundSkimsCreatorTest.scala index d38e2799d16..06df51aea76 100644 --- a/src/test/scala/beam/router/skim/urbansim/BackgroundSkimsCreatorTest.scala +++ b/src/test/scala/beam/router/skim/urbansim/BackgroundSkimsCreatorTest.scala @@ -144,12 +144,12 @@ class BackgroundSkimsCreatorTest extends AnyFlatSpec with Matchers with BeamHelp pathTypeToSkimsCount(ActivitySimPathType.DRV_HVY_WLK) shouldBe 9 pathTypeToSkimsCount(ActivitySimPathType.WLK_LOC_WLK) shouldBe 86 - pathTypeToSkimsCount(ActivitySimPathType.DRV_LRF_WLK) shouldBe 19 + pathTypeToSkimsCount(ActivitySimPathType.DRV_LRF_WLK) shouldBe 22 pathTypeToSkimsCount(ActivitySimPathType.WLK_LRF_WLK) shouldBe 28 pathTypeToSkimsCount(ActivitySimPathType.WLK_HVY_WLK) shouldBe 24 - pathTypeToSkimsCount(ActivitySimPathType.DRV_LOC_WLK) shouldBe 34 + pathTypeToSkimsCount(ActivitySimPathType.DRV_LOC_WLK) shouldBe 31 - skims.keys.size shouldBe (9 + 86 + 19 + 28 + 24 + 34) + skims.keys.size shouldBe (9 + 86 + 22 + 28 + 24 + 31) } "skims creator" should "generate all types of skims" in { diff --git a/src/test/scala/beam/sim/output/IterationsPassengerPerTripTests.scala b/src/test/scala/beam/sim/output/IterationsPassengerPerTripTests.scala index 6b25d8a33e1..83cd0fcb1e1 100644 --- a/src/test/scala/beam/sim/output/IterationsPassengerPerTripTests.scala +++ b/src/test/scala/beam/sim/output/IterationsPassengerPerTripTests.scala @@ -260,20 +260,20 @@ class IterationsPassengerPerTripTests extends AnyWordSpecLike with Matchers with 0.0, null, null, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, + 0.0f, None, None, None, - IndexedSeq.empty, - 0.0, + Array.empty, + 0.0f, None, null ) diff --git a/src/test/scala/beam/utils/scenario/PreviousRunPlanMergerTest.scala b/src/test/scala/beam/utils/scenario/PreviousRunPlanMergerTest.scala index 8ff9534bea1..8e1f59caf4c 100644 --- a/src/test/scala/beam/utils/scenario/PreviousRunPlanMergerTest.scala +++ b/src/test/scala/beam/utils/scenario/PreviousRunPlanMergerTest.scala @@ -370,6 +370,8 @@ class PreviousRunPlanMergerTest extends AnyWordSpecLike with Matchers { None, None, None, + None, + None, Seq(), None ) @@ -404,6 +406,8 @@ class PreviousRunPlanMergerTest extends AnyWordSpecLike with Matchers { None, None, None, + None, + None, Seq.empty, None ) @@ -430,6 +434,8 @@ class PreviousRunPlanMergerTest extends AnyWordSpecLike with Matchers { None, None, None, + None, + None, Seq.empty, None ) diff --git a/src/test/scala/beam/utils/scenario/urbansim/HOVModeTransformerTest.scala b/src/test/scala/beam/utils/scenario/urbansim/HOVModeTransformerTest.scala index 86c0cda4554..7a8d691b28b 100644 --- a/src/test/scala/beam/utils/scenario/urbansim/HOVModeTransformerTest.scala +++ b/src/test/scala/beam/utils/scenario/urbansim/HOVModeTransformerTest.scala @@ -517,6 +517,8 @@ object HOVModeTransformerTest { legMode = Some(mode), legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = None, + legExpectedCost = None, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, @@ -542,6 +544,8 @@ object HOVModeTransformerTest { legMode = None, legDepartureTime = None, legTravelTime = None, + legExpectedTravelTime = None, + legExpectedCost = None, legRouteType = None, legRouteStartLink = None, legRouteEndLink = None, diff --git a/test/input/beamville/beam-freight.conf b/test/input/beamville/beam-freight.conf index 9e41c1c742c..472bf9a636a 100644 --- a/test/input/beamville/beam-freight.conf +++ b/test/input/beamville/beam-freight.conf @@ -10,8 +10,14 @@ beam.agentsim.agents.freight { plansFilePath = ${beam.inputDirectory}"/freight/payload-plans.csv" toursFilePath = ${beam.inputDirectory}"/freight/freight-tours.csv" carriersFilePath = ${beam.inputDirectory}"/freight/freight-carriers.csv" - carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-depots.csv" vehicleTypesFilePath = ${beam.inputDirectory}"/freight/freight-vehicleTypes.csv" + + carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-parking.csv" + #carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-parking-low.csv" + #carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-parking-medium.csv" + #carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-parking-high.csv" + #carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-parking-unlimited.csv" + reader = "Generic" replanning { disableAfterIteration = 1 diff --git a/test/input/beamville/beam.conf b/test/input/beamville/beam.conf index 6c5b6dc919c..6e7c8a2bf9c 100755 --- a/test/input/beamville/beam.conf +++ b/test/input/beamville/beam.conf @@ -206,7 +206,7 @@ beam.outputs.writeEventsInterval = ${beam.outputs.defaultWriteInterval} beam.physsim.writeEventsInterval = ${beam.outputs.defaultWriteInterval} beam.physsim.writePlansInterval = ${beam.outputs.defaultWriteInterval} beam.outputs.writeAnalysis = false -beam.physsim.linkStatsWriteInterval = 0 +beam.physsim.linkStatsWriteInterval = 1 # The remaining params customize how events are written to output files beam.outputs.events.fileOutputFormats = "csv,xml" # valid options: xml(.gz) , csv(.gz), none - DEFAULT: csv.gz diff --git a/test/input/beamville/freight/freight-depots.csv b/test/input/beamville/freight/freight-depots.csv index 96bf350a58d..113f26a5954 100644 --- a/test/input/beamville/freight/freight-depots.csv +++ b/test/input/beamville/freight/freight-depots.csv @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:53f306cb96c186094b9f931ff19749b19a3808c6ad7a0736328d7a6a74600f27 -size 8370 +oid sha256:2e0c5909616aecfcc5f28bb33e1ce0fe126fb63d4c04474dff4444a0e277c1c0 +size 8898 diff --git a/test/input/beamville/freight/freight-parking-high.csv b/test/input/beamville/freight/freight-parking-high.csv new file mode 100644 index 00000000000..7d90c6a81ea --- /dev/null +++ b/test/input/beamville/freight/freight-parking-high.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc4b3aea36d35d0d2f0f35761a119c09ab955236fbc916504fecdb57fe108812 +size 740 diff --git a/test/input/beamville/freight/freight-parking-low.csv b/test/input/beamville/freight/freight-parking-low.csv new file mode 100644 index 00000000000..36a537289a7 --- /dev/null +++ b/test/input/beamville/freight/freight-parking-low.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02bf0551ec5455d644ec9b49a7c5179e9f2bd3a6a1cd44b110a132de8a982f96 +size 724 diff --git a/test/input/beamville/freight/freight-parking-medium.csv b/test/input/beamville/freight/freight-parking-medium.csv new file mode 100644 index 00000000000..fd12471c47f --- /dev/null +++ b/test/input/beamville/freight/freight-parking-medium.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:574b951be7e049f0d3470f8d6451ff6aee8f1c0d1a06f13b185056250bced290 +size 732 diff --git a/test/input/beamville/freight/freight-parking-unlimited.csv b/test/input/beamville/freight/freight-parking-unlimited.csv new file mode 100644 index 00000000000..ea4727940de --- /dev/null +++ b/test/input/beamville/freight/freight-parking-unlimited.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:552215eaf2a568994273dd87676e37ea05066d276d9f671d3bd5135e0c4b1a26 +size 796 diff --git a/test/input/beamville/freight/freight-parking.csv b/test/input/beamville/freight/freight-parking.csv new file mode 100644 index 00000000000..113f26a5954 --- /dev/null +++ b/test/input/beamville/freight/freight-parking.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e0c5909616aecfcc5f28bb33e1ce0fe126fb63d4c04474dff4444a0e277c1c0 +size 8898 diff --git a/test/input/sf-light/freight/freight-depots.csv b/test/input/sf-light/freight/freight-depots.csv new file mode 100644 index 00000000000..5dca9ff93ba --- /dev/null +++ b/test/input/sf-light/freight/freight-depots.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:43852643264ef040e855d12101e533cf22b888593a0d2a28d1d26f17cd56b3e5 +size 504654 diff --git a/test/input/sf-light/freight/freight-depots.csv.gz b/test/input/sf-light/freight/freight-depots.csv.gz deleted file mode 100644 index 814699157f6..00000000000 --- a/test/input/sf-light/freight/freight-depots.csv.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:2fcd7271e8bae1d84c0c591ef9aa4dbba403284d47e0e11aa6eca910fd7fc980 -size 30826 diff --git a/test/input/sf-light/freight/freight-parking.csv b/test/input/sf-light/freight/freight-parking.csv new file mode 100644 index 00000000000..1b6ff243706 --- /dev/null +++ b/test/input/sf-light/freight/freight-parking.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0deb1ce701904119a2bd003d0f81ddc96c543c71dd01f68e032a72c078fe307 +size 539219 diff --git a/test/input/sf-light/freight/freight-vehicleTypes.csv b/test/input/sf-light/freight/freight-vehicleTypes.csv new file mode 100644 index 00000000000..14bed36f78e --- /dev/null +++ b/test/input/sf-light/freight/freight-vehicleTypes.csv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:911560012e3ac4c86804409980a37a63cf35e1fbb816cb55131eb8195ec9d906 +size 702 diff --git a/test/input/sf-light/sf-light-freight.conf b/test/input/sf-light/sf-light-freight.conf index b77c734a31c..1aedbc47417 100644 --- a/test/input/sf-light/sf-light-freight.conf +++ b/test/input/sf-light/sf-light-freight.conf @@ -3,14 +3,18 @@ include "sf-light.conf" beam.agentsim.simulationName = "freight" beam.agentsim.firstIteration = 0 -beam.agentsim.lastIteration = 1 +beam.agentsim.lastIteration = 0 beam.agentsim.agents.freight { enabled = true plansFilePath = ${beam.inputDirectory}"/freight/payload-plans.csv" toursFilePath = ${beam.inputDirectory}"/freight/freight-tours.csv" carriersFilePath = ${beam.inputDirectory}"/freight/freight-carriers.csv" - carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-depots.csv.gz" + vehicleTypesFilePath = ${beam.inputDirectory}"/freight/freight-vehicleTypes.csv" + + carrierParkingFilePath = ${beam.inputDirectory}"/freight/freight-parking.csv" + + reader = "Generic" replanning { disableAfterIteration = 1 departureTime = 28800