Processus d’expérimentation

Créer un modèle

Les scripts de configuration d’EMOD contiennent cinq éléments principaux : 1. Importer des modules - Importer tous les modules et fonctions nécessaires à l’exécution du script suivant. 2. Configuration et durée de la simulation - Définir les paramètres config.json aux valeurs par défaut de l’équipe et mettre à jour les paramètres additionnels si nécessaire en utilisant un callback vers la configuration emod-api. Par exemple, on peut spécifier différents types de simulation tels que MALARIA_SIM ou VECTOR_SIM pour simuler uniquement le modèle de vecteur sans le modèle de paludisme à l’intérieur de l’hôte, ou d’autres types de simulation listés ici.

      ::: {.cell}
      ``` {.python .cell-code}
      def set_param_fn(config):
          import emodpy_malaria.malaria_config as conf
          config = conf.set_team_defaults(config, manifest)
          
          #Si souhaité, définir le type de simulation, par défaut MALARIA_SIM ci-dessous
          config.parameters.Simulation_Type = "MALARIA_SIM"
          return config
      ```
      :::
      
      
3. Configuration de la campagne
    - Créez un fichier de campagne en utilisant le schéma `emod-api`. C'est là que les interventions souhaitées doivent être ajoutées.


      ::: {.cell}
      ``` {.python .cell-code}
      def build_camp():
          camp.schema_path = manifest.schema_file
          return camp
      ```
      :::
      
      
4. Données démographiques
    - Construisez un fichier démographique en utilisant `emod-api`. Cela se fait typiquement via [`from_template_node`](https://github.com/numalariamodeling/emodpy-malaria/blob/main/emodpy_malaria/demographics/MalariaDemographics.py) pour les sims à un seul nœud, mais il y a d'autres méthodes disponibles si nécessaire ([*voir demographics how to*](https://numalariamodeling.github.io/FE-2023-site-web-francais/guides/demographics_guide.html)).


      ::: {.cell}
      ``` {.python .cell-code}
      def build_demog():
          demog = Demographics.from_template_node(lat=1, lon=2, pop=10, name="Example_Site")
          return demog
      ```
      :::
      
      
5. EMODTask et constructeur d'expériences
    - Définir la plateforme avec les détails de l'endroit où nous effectuerons les simulations et créer la `EMODTask` qui fait référence aux constructeurs ci-dessus, au schéma et à l'exécutable du modèle.
    - Des rapporteurs peuvent être ajoutés après la tâche pour surveiller les résultats de la simulation (*voir la section sur les rapporteurs ci-dessous*).
    - L'expérience peut être construite en utilisant `from_task` ou `from_builder` en fonction de la complexité de la simulation. Lorsque des changements, tels que des balayages, sont effectués en dehors du constructeur de campagne initial, alors `from_builder` est nécessaire (*voir la section constructeur de modèle ci-dessous*).


      ::: {.cell}
      ``` {.python .cell-code}
      def general_sim(selected_platform):
          # Définir la plate-forme et les valeurs associées, telles que le nombre maximum de tâches à exécuter en même temps et d'autres spécificités de la plate-forme.
          platform = Platform(<platform>, job_directory=manifest.job_directory,
                              partition=<SLURM partition>, time=<'HH:MM:SS'>,
                              account=<SLURM account>, modules=['singularity'],
                              max_running_jobs=10)
          # créer EMODTask en utilisant les constructeurs précédemment définis
          print("Creating EMODTask (from files)...")
          task = EMODTask.from_default2(
                    config_path="config.json",
                    eradication_path=manifest.eradication_path,
                    campaign_builder=build_camp,
                    schema_path=manifest.schema_file,
                    param_custom_cb=set_param_fn,
                    ep4_custom_cb=None,
                    demog_builder=build_demog,
                    plugin_report=None
                    )
          
          # définir l'image de singularité à utiliser lors de l'exécution de cette expérience
          task.set_sif(manifest.SIF_PATH, platform)
          
          # create experiment from builder
          user = os.getlogin()
          experiment = Experiment.from_task(task, name= 'experiment_name')
          # La dernière étape consiste à appeler run() sur le ExperimentManager pour exécuter les simulations.
          experiment.run(wait_until_done=True, platform=platform)
      ```
      :::