networkDesign: replace SimulationAlgorithmDescriptor with UserDefinedConfigSchema

completes #1580

Remove the previous `SimulationAlgorithmDescriptor` interface, to be
replaced with the new `UserDefinedConfigSchema`.

Rename the classes' methods to match the new interface (`getOptions`
becomes `getFields`, `validateOptions` becomes `validateFields`).

Update a few translation strings to use the new `networkDesign:`
namespace instead of `simulation`.

Author: tahini

locales/en/transit.json

@@ -847,6 +847,62 @@
             "ErrorExportingGtfs": "An error occurred while generating the GTFS file."
         }
     },
+    "networkDesign": {
+        "evolutionaryAlgorithm": {
+            "LineAndNumberOfVehiclesGASimulation": "Genetic algorithm with lines and number of vehicles",
+            "PopulationSizeMin": "Minimum population size",
+            "PopulationSizeMax": "Maximum population size",
+            "NumberOfElites": "Number of elites per generation",
+            "NumberOfRandoms": "Number of random per generation",
+            "CrossoverNumberOfCuts": "Number of cuts in crossover",
+            "CrossoverProbability": "Probability of crossover",
+            "MutationProbability": "Probability of mutation",
+            "TournamentSize": "Tournament selection size",
+            "TournamentProbability": "Tournament probability",
+            "NumberOfGenerations": "Number of generations",
+            "ShuffleGenes": "Shuffle genes before reproduction",
+            "KeepGenerations": "Number of generations to keep",
+            "KeepCandidates": "Number of candidates to keep in generations",
+            "PopulationSizeMinInvalid": "Minimum population size must be greater than 0",
+            "PopulationSizeMaxInvalid": "Maximum population size must be greater than 0",
+            "NumberOfElitesInvalid": "Number of elites per generation must be greater than 0",
+            "NumberOfRandomsInvalid": "Number of random per generation must be greater or equal to 0",
+            "CrossoverNumberOfCutsInvalid": "Number of cuts in crossover must be greater than 0",
+            "CrossoverProbabilityInvalid": "Probability of crossover must be between 0 and 1",
+            "MutationProbabilityInvalid": "Probability of mutation must be between 0 and 1",
+            "TournamentSizeInvalid": "Tournament selection size must be greater than 0",
+            "TournamentProbabilityInvalid": "Tournament probability must be between 0 and 1",
+            "NumberOfGenerationsInvalid": "Number of generations must be greater than 0",
+            "KeepGenerationsInvalid": "Number of generations to keep must be greater than 0",
+            "KeepCandidatesInvalid": "Number of candidates to keep in generations must be greater than 0",
+            "help": {
+                "PopulationSizeMin": "Minimum number of candidates in each generation",
+                "PopulationSizeMax": "Maximum number of candidates in each generation",
+                "NumberOfElites": "Number of best candidates to copy directly to the next generation",
+                "NumberOfRandoms": "Number of entirely random new candidates to add in each generation",
+                "CrossoverNumberOfCuts": "Number of points where parent genes are cut to create offspring",
+                "CrossoverProbability": "Probability that a pair of parents undergoes crossover to create offspring",
+                "MutationProbability": "Probability that a gene undergoes mutation, i.e. is randomly modified. For this algorithm, a probability of 8% (0.08) is suggested.",
+                "TournamentSize": "Number of candidates among the best of the generation that will compete for reproduction after each generation.",
+                "TournamentProbability": "The initial probability that there will be a tournament for parent selection rather than selecting the best. This probability should not be too high, otherwise only the best will reproduce.",
+                "ShuffleGenes": "Shuffling genes avoids proximity effects in the chromosome, where 2 lines positioned side by side will always have the same values. This helps diversify the population.",
+                "KeepGenerations": "Number of last generations to keep for analysis after algorithm execution",
+                "KeepCandidates": "Number of best candidates to keep for each of the generations to keep"
+            },
+            "errors": {
+                "PopulationSizeMinGreaterThanMax": "Minimum population size is greater than maximum",
+                "CandidatesToKeepGreaterThanPopulation": "Number of candidates to keep is greater than population",
+                "GenerationsToKeepGreaterThanGenerations": "Number of generations to keep is greater than number of generations"
+            }
+        },
+        "simulationMethods": {
+            "accessibilityMap": {
+                "Title": "Using accessibility maps",
+                "AccessMapDataSources": "Data sources for places",
+                "AccessMapMaxSampleRatio": "Maximum sample ratio to test (between 0 and 1)"
+            }
+        }
+    },
     "simulation": {
         "Simulation": "Simulation",
         "Simulations": "Simulations",
@@ -859,25 +915,11 @@
         "NumberOfThreads": "Number of threads",
         "NumberOfLinesMin": "Minimum number of lines",
         "NumberOfLinesMax": "Maximum number of lines",
-        "PopulationSizeMin": "Minimum population size",
-        "PopulationSizeMax": "Maximum population size",
-        "VehiclesCount": "Number of vehicles (fleet size)",
         "MaxIntervalMinutes": "Maximum period (minutes)",
         "MaxIntervalMinutesHelp": "The maximum time between departures for a line. For optimal service, it is suggested to keep it lower than 15 minutes. But times up to 60 minutes are accepted.",
         "MinIntervalMinutes": "Minimum period (minutes)",
         "MinIntervalMinutesHelp": "The minimum time between departures for a line. The minimum value should be higher than 3, less than that will have no effect on the calculations.",
-        "NumberOfElites": "Number of elites per generation",
-        "NumberOfRandoms": "Number of random per generation",
-        "CrossoverNumberOfCuts": "Number of cuts in crossover",
-        "CrossoverProbability": "Probability of crossover",
-        "MutationProbability": "Probability of mutation",
-        "TournamentSize": "Tournament selection size",
-        "TournamentProbability": "Tournament probability",
-        "ShuffleGenes": "Shuffle genes before reproduction",
-        "KeepGenerations": "Number of generations to keep",
-        "KeepCandidates": "Number of candidates to keep in generations",
         "OdTripsSampleRatio": "Percentage of OD trips to include",
-        "NumberOfGenerations": "Number of generations",
         "Color": "Color",
         "Edit": "Simulation",
         "Delete": "Delete simulation",
@@ -905,9 +947,6 @@
         "Results": "Results",
         "Parameters": "Parameters",
         "RuntimeOptions": "Runtime Configuration",
-        "simulationClasses": {
-            "LineAndNumberOfVehiclesGASimulation": "Genetic algorithm with lines and number of vehicles"
-        },
         "simulationMethods": {
             "SelectSimulationFunctions": "Select functions to use for simulation",
             "OdTrips": "OD trips",
@@ -966,10 +1005,7 @@
             "MinTimeHigherThanMax": "The minimum time between passages is greater than maximum",
             "MinTimeBetweenPassagesTooHigh": "The minimum time between passages is too high",
             "UnknownAlgorithm": "The selected algorithm is unavailable",
-            "SimulatedAgenciesIsEmpty": "At least one agency to simulate must be selected",
-            "PopulationSizeMinGreaterThanMax": "Minimum population size is greater than maximum",
-            "CandidatesToKeepGreaterThanPopulation": "Number of candidates to keep is greater than population",
-            "GenerationsToKeepGreaterThanGenerations": "Number of generations to keep is greater than number of generations"
+            "SimulatedAgenciesIsEmpty": "At least one agency to simulate must be selected"
         }
     },
     "jobs": {

locales/fr/transit.json

@@ -847,6 +847,62 @@
             "ErrorExportingGtfs": "Une erreur s'est produite lors de la génération de l'archive GTFS."
         }
     },
+    "networkDesign": {
+        "evolutionaryAlgorithm": {
+            "LineAndNumberOfVehiclesGASimulation": "Algorithme génétique avec lignes et nombre de véhicules",
+            "PopulationSizeMin": "Taille minimale de la population",
+            "PopulationSizeMax": "Taille maximale de la population",
+            "NumberOfElites": "Nombre d'élites par génération",
+            "NumberOfRandoms": "Nombre d'aléatoires par génération",
+            "CrossoverNumberOfCuts": "Nombre de coupures d'entrecroisement",
+            "CrossoverProbability": "Probabilité d'entrecroisement",
+            "MutationProbability": "Probabilité de mutation",
+            "TournamentSize": "Taille du tournoi de sélection",
+            "TournamentProbability": "Probabilité du tournoi",
+            "NumberOfGenerations": "Nombre de générations",
+            "ShuffleGenes": "Mélanger les gènes avant la reproduction",
+            "KeepGenerations": "Nombre de générations à conserver",
+            "KeepCandidates": "Nombre de candidats à conserver",
+            "PopulationSizeMinInvalid": "La taille minimale de la population doit être supérieure à 0",
+            "PopulationSizeMaxInvalid": "La taille maximale de la population doit être supérieure à 0",
+            "NumberOfElitesInvalid": "Le nombre d'élites par génération doit être supérieur à 0",
+            "NumberOfRandomsInvalid": "Le nombre d'aléatoires par génération doit être supérieur ou égal à 0",
+            "CrossoverNumberOfCutsInvalid": "Le nombre de coupures d'entrecroisement doit être supérieur à 0",
+            "CrossoverProbabilityInvalid": "La probabilité d'entrecroisement doit être entre 0 et 1",
+            "MutationProbabilityInvalid": "La probabilité de mutation doit être entre 0 et 1",
+            "TournamentSizeInvalid": "La taille du tournoi de sélection doit être supérieure à 0",
+            "TournamentProbabilityInvalid": "La probabilité du tournoi doit être entre 0 et 1",
+            "NumberOfGenerationsInvalid": "Le nombre de générations doit être supérieur à 0",
+            "KeepGenerationsInvalid": "Le nombre de générations à conserver doit être supérieur à 0",
+            "KeepCandidatesInvalid": "Le nombre de candidats à conserver doit être supérieur à 0",
+            "help": {
+                "PopulationSizeMin": "Nombre minimal de candidats dans chaque génération",
+                "PopulationSizeMax": "Nombre maximal de candidats dans chaque génération",
+                "NumberOfElites": "Nombre de meilleurs candidats à copier directement dans la génération suivante",
+                "NumberOfRandoms": "Nombre de nouveaux candidats entièrement aléatoires à ajouter dans chaque génération",
+                "CrossoverNumberOfCuts": "Nombre de points où les gènes des parents sont coupés pour créer des enfants",
+                "CrossoverProbability": "Probabilité qu'un couple de parents subisse l'entrecroisement pour créer des enfants",
+                "MutationProbability": "Probabilité qu'un gène subisse une mutation, ie soit modifié aléatoirement. Pour cet algorithme, une probabilité de 8% (0.08) est suggérée.",
+                "TournamentSize": "Nombre de candidats parmi les meilleurs de la génération qui s'affronteront pour la reproduction après chaque génération.",
+                "TournamentProbability": "La probabilité initiale qu'il y ait un tournoi pour la sélection des parents plutôt que sélectionner le meilleur. Cette probabilité ne doit pas être trop élevée, sinon seuls les meilleurs se reproduiront.",
+                "ShuffleGenes": "Mélanger les gènes évite les effets de proximité dans le chromosome, où 2 lignes positionnées côte à côte auront toujours les mêmes valeurs. Cela aide à diversifier la population.",
+                "KeepGenerations": "Nombre de dernières générations à conserver pour analyse après l'exécution de l'algorithme",
+                "KeepCandidates": "Nombre des meilleurs candidats à conserver pour chacune des générations à conserver"
+            },
+            "errors": {
+                "PopulationSizeMinGreaterThanMax": "La taille de la population minimale est plus grande que la maximale",
+                "CandidatesToKeepGreaterThanPopulation": "Le nombre de candidats à conserver est supérieur à la population",
+                "GenerationsToKeepGreaterThanGenerations": "Le nombre générations à conserver est supérieur au nombre de génération"
+            }
+        },
+        "simulationMethods": {
+            "accessibilityMap": {
+                "Title": "Par carte d'accessibilité",
+                "AccessMapDataSources": "Sources de données pour les lieux",
+                "AccessMapMaxSampleRatio": "Ratio d'échantillonnage maximal à tester (entre 0 et 1)"
+            }
+        }
+    },
     "simulation": {
         "Simulation": "Simulation",
         "Simulations": "Simulations",
@@ -859,25 +915,12 @@
         "NumberOfThreads": "Nombre de processus parallèles",
         "NumberOfLinesMin": "Nombre minimal de lignes",
         "NumberOfLinesMax": "Nombre maximal de lignes",
-        "PopulationSizeMin": "Taille minimale de la population",
-        "PopulationSizeMax": "Taille maximale de la population",
         "VehiclesCount": "Nombre de véhicules (flotte)",
         "MaxIntervalMinutes": "Intervalle maximal (minutes)",
         "MaxIntervalMinutesHelp": "Le temps maximum entre les départs sur une ligne. Pour un service optimal, il est suggéré de le garder en-dessous de 15 minutes. Des temps jusqu'à 60 mintues sont acceptés.",
         "MinIntervalMinutes": "Intervalle minimal (minutes)",
         "MinIntervalMinutesHelp": "Le temps minimal entre les départs sur une ligne. La valeur ne devrait pas être supérieure à 3. Moins que ça n'aurait pas d'effet sur les calculs.",
-        "NumberOfElites": "Nombre d'élites par génération",
-        "NumberOfRandoms": "Nombre d'aléatoires par génération",
-        "CrossoverNumberOfCuts": "Nombre de coupures d'entrecroisement",
-        "CrossoverProbability": "Probabilité d'entrecroisement",
-        "MutationProbability": "Probabilité de mutation",
-        "TournamentSize": "Taille du tournoi de sélection",
-        "TournamentProbability": "Probabilité du tournoi",
-        "ShuffleGenes": "Mélanger les gènes avant la reproduction",
-        "KeepGenerations": "Nombre de générations à conserver",
-        "KeepCandidates": "Nombre de candidats à conserver",
         "OdTripsSampleRatio": "Pourcentage des déplacements OD à inclure",
-        "NumberOfGenerations": "Nombre de générations",
         "Color": "Color",
         "Edit": "Simulation",
         "Delete": "Supprimer la simulation",
@@ -905,9 +948,6 @@
         "Results": "Résultats",
         "Parameters": "Paramètres",
         "RuntimeOptions": "Configuration de l'exécution",
-        "simulationClasses": {
-            "LineAndNumberOfVehiclesGASimulation": "Algorithme génétique avec lignes et nombre de véhicules"
-        },
         "simulationMethods": {
             "SelectSimulationFunctions": "Sélectionner les fonctions à utiliser pour la simulation",
             "OdTrips": "Chargement OD",
@@ -966,10 +1006,7 @@
             "MinTimeHigherThanMax": "Le temps minimal entre les passages est plus élevé que le temps maximal",
             "MinTimeBetweenPassagesTooHigh": "Le temps minimal entre les passages est trop élevé",
             "UnknownAlgorithm": "L'algorithme sélectionné n'est pas disponible",
-            "SimulatedAgenciesIsEmpty": "Au moins une agence à simuler doit être sélectionnée",
-            "PopulationSizeMinGreaterThanMax": "La taille de la population minimale est plus grande que la maximale",
-            "CandidatesToKeepGreaterThanPopulation": "Le nombre de candidats à conserver est supérieur à la population",
-            "GenerationsToKeepGreaterThanGenerations": "Le nombre générations à conserver est supérieur au nombre de génération"
+            "SimulatedAgenciesIsEmpty": "Au moins une agence à simuler doit être sélectionnée"
         }
     },
     "jobs": {

packages/transition-backend/src/services/simulation/__tests__/TransitNetworkDesignAlgorithmDescriptorStub.ts

@@ -4,7 +4,8 @@
  * This file is licensed under the MIT License.
  * License text available at https://opensource.org/licenses/MIT
  */
-import { TransitNetworkDesignAlgorithm, SimulationAlgorithmDescriptor } from 'transition-common/lib/services/networkDesign/transit/TransitNetworkDesignAlgorithm';
+import { TransitNetworkDesignAlgorithm } from 'transition-common/lib/services/networkDesign/transit/TransitNetworkDesignAlgorithm';
+import { UserDefinedConfigSchema } from 'transition-common/lib/utils/userDefinedConfig';
 
 type AlgorithmStubOptions = {
     numericOption: number;
@@ -25,20 +26,20 @@ export class SimulationAlgorithmStub implements TransitNetworkDesignAlgorithm {
 
 }
 
-export class SimulationAlgorithmDescriptorStub implements SimulationAlgorithmDescriptor<AlgorithmStubOptions> {
+export class SimulationAlgorithmDescriptorStub implements UserDefinedConfigSchema<AlgorithmStubOptions> {
 
     getTranslatableName = () => "string"
 
-    getOptions = () => ({ 
+    getFields = () => ({ 
         numericOption: { i18nName: 'numOption', type: 'number' as const, validate: (value: number) => value > 0 }, 
         stringOption: { i18nName: 'stringOption', type: 'string' as const }, 
         booleanOption: { i18nName: 'boolOption', type: 'boolean' as const } 
     });
 
-    validateOptions = (options: Partial<AlgorithmStubOptions>) => {
+    validateFields = (fields: Partial<AlgorithmStubOptions>) => {
         let valid = true;
         let errors: string[] = [];
-        if (options.stringOption === undefined) {
+        if (fields.stringOption === undefined) {
             valid = false;
             errors.push('StringOptionMandatory');
         }

packages/transition-backend/src/services/simulation/methods/SimulationMethod.ts

@@ -4,9 +4,9 @@
  * This file is licensed under the MIT License.
  * License text available at https://opensource.org/licenses/MIT
  */
-import { SimulationAlgorithmDescriptor } from 'transition-common/lib/services/networkDesign/transit/TransitNetworkDesignAlgorithm';
 import { SimulationRunDataAttributes } from 'transition-common/lib/services/simulation/SimulationRun';
 import { TransitRoutingBaseAttributes } from 'chaire-lib-common/lib/services/routing/types';
+import { UserDefinedConfigSchema } from 'transition-common/lib/utils/userDefinedConfig';
 
 /**
  * Interface for simulation method implementations. A simulation method will be
@@ -36,5 +36,5 @@ export interface SimulationMethod {
 export interface SimulationMethodFactory<TOptionsType extends Record<string, unknown>> {
     create: (options: TOptionsType, simulationDataAttributes: SimulationRunDataAttributes) => SimulationMethod;
 
-    getDescriptor: () => SimulationAlgorithmDescriptor<TOptionsType>;
+    getDescriptor: () => UserDefinedConfigSchema<TOptionsType>;
 }