Scripting en Python

1. Introduction

Dans OghmaNano, les scripts Python fonctionnent en modifiant directement les fichiers de configuration de la simulation sur le disque, puis en lançant le moteur de simulation (oghma_core.exe) pour exécuter le modèle. Cette section décrit ce processus en détail.

2. Exécuter des fichiers de simulation avec Python.

Une simulation OghmaNano est entièrement définie par un seul fichier de configuration au format JSON, sim.json. Ce fichier contient l’état complet de la simulation, y compris la structure du dispositif, les paramètres des matériaux, les paramètres numériques et la configuration de la sortie. Dans de nombreux cas, sim.json existe déjà sous la forme d’un fichier normal dans le répertoire de la simulation.

Lorsque l’on utilise OghmaNano depuis Python, le script lit le fichier sim.json et le charge en mémoire à l’aide de la bibliothèque standard json de Python, modifie un ou plusieurs paramètres, puis enregistre le fichier JSON mis à jour sur le disque.

Il est essentiel que le script Python soit exécuté en définissant son répertoire de travail sur le répertoire de simulation, c’est-à-dire le répertoire contenant sim.json (et sim.oghma). C’est à partir de ce répertoire que oghma_core.exe est lancé.

Une fois que le fichier JSON a été mis à jour, le script lance oghma_core.exe à partir du même répertoire. Le moteur de simulation lit toujours ses fichiers d’entrée à partir du répertoire de travail actuel. Par conséquent, si le répertoire de travail est incorrect, la simulation échouera ou exécutera le mauvais modèle.

Cette répartition des responsabilités est intentionnelle et clairement définie : Python est chargé de déterminer les modifications à apporter à la simulation, tandis qu’OghmaNano est chargé d’exécuter les calculs physiques en utilisant les fichiers présents dans le répertoire courant.

L’exemple ci-dessous illustre ce processus en chargeant sim.json, en modifiant la mobilité des porteurs de la première couche du dispositif, en enregistrant la configuration mise à jour sur le disque, puis en exécutant la simulation à partir du répertoire de simulation.

       import json
       import os
       import sys

       f=open('sim.json')              #open the sim.json file
       lines=f.readlines()
       f.close()
       lines="".join(lines)    #convert the text to a python json object
     data = json.loads(lines)

     #Edit a value (use firefox as a json viewer
     # to help you figure out which value to edit)
     # this time we are editing the mobility of layer 1
     data['epitaxy']['segment1']['shape_dos']['mue_y']=1.0


     #convert the json object back to a string
     jstr = json.dumps(data, sort_keys=False, indent='\t')

     #write it back to disk
     f=open('sim.json',"w")
     f.write(jstr)
     f.close()

     #run the simulation using oghma_core
     os.system("oghma_core.exe")

Si la simulation dans sim.json est configurée pour générer une courbe J–V, OghmaNano créera des fichiers de sortie dans le répertoire de la simulation, qui contiendront des données telles que le rendement de conversion de puissance (PCE), le facteur de remplissage, \(J_{sc}\) et \(V_{oc}\).

L’exemple ci-dessous illustre la manière de lire un fichier de sortie au format JSON et d’ajouter la valeur de \(V_{oc}\) à un fichier texte distinct.

f=open('sim_info.dat')
lines=f.readlines()
f.close()
lines="".join(lines)
data = json.loads(lines)

f=open('out.dat',"a")
f.write(str(data["Voc"])+"\n");
f.close()

3. Simulations plus complexes.

Dans de nombreux processus d’exécution de scripts, vous voudrez exécuter la même simulation de base plusieurs fois, en utilisant différentes valeurs de paramètres, et conserver chaque exécution dans un répertoire distinct. C’est la méthode la plus simple pour obtenir des résultats clairs et éviter d’écraser accidentellement des données.

L’exemple ci-dessous crée un ensemble de répertoires correspondant à quatre types de mobilité (1e-5, 1e-6, 1e-7, 1e-8). Pour chaque répertoire, il effectue les opérations suivantes :

1. Crée le répertoire (s’il n’existe pas déjà).
2. Copie le fichier sim.json actuel dans ce répertoire.
3. Modifie la copie de sim.json pour définir la mobilité cible.
4. Modifie le répertoire de travail pour qu’il corresponde au répertoire spécifié.
5. Exécute le programme de résolution dans ce répertoire, ce qui génère des résultats spécifiques à cette exécution.

Ce modèle constitue la base du script en mode batch dans OghmaNano : un répertoire par exécution, un fichier de configuration par exécution et un dossier de résultats propre pour chaque valeur de paramètre.

       import json
       import os
       import shutil

       # The script must be started in the base simulation directory
       # (i.e. the directory containing the reference sim.json).
       base_dir = os.getcwd()

       mobilities = [1e-5, 1e-6, 1e-7, 1e-8]

       for mu in mobilities:
           # Create a directory name that is easy to read and sorts nicely
           run_dir = os.path.join(base_dir, f"mu_{mu:.0e}")
           os.makedirs(run_dir, exist_ok=True)

           # Copy the base sim.json into the run directory
           src_sim = os.path.join(base_dir, "sim.json")
           dst_sim = os.path.join(run_dir, "sim.json")
           shutil.copyfile(src_sim, dst_sim)

           # Load the copied sim.json and edit the mobility in THAT copy
           f = open(dst_sim)
           lines = f.readlines()
           f.close()
           lines = "".join(lines)
           data = json.loads(lines)

           # Edit a value: set the mobility for the first device layer
           data['epitaxy']['segment1']['shape_dos']['mue_y'] = mu

           jstr = json.dumps(data, sort_keys=False, indent='\t')
           f = open(dst_sim, "w")
           f.write(jstr)
           f.close()

           # Change into the run directory and execute the solver there
           os.chdir(run_dir)

           # If your command is "augment.nano" instead, replace the string below.
           os.system("oghma_core.exe")

           # Return to the base directory for the next run
           os.chdir(base_dir)

Une fois l’exécution terminée, chaque répertoire contiendra les résultats correspondant à la valeur de mobilité utilisée. Dans la section suivante, nous allons modifier ce script afin de collecter les principaux résultats de chaque exécution et de les regrouper dans un seul fichier récapitulatif.

Représentation graphique de \(V_{oc}\) en fonction de l’inverse de la mobilité.

Une fois que vous avez exécuté une série de simulations dans des répertoires distincts, l’étape suivante consiste généralement à extraire une valeur clé de chaque simulation et à visualiser la tendance. Un exemple courant consiste à lire la tension en circuit ouvert \(V_{oc}\) à partir du fichier de sortie JSON (sim_info.dat) et à la représenter graphiquement en fonction de la mobilité inverse \(1/\mu\).

Le script ci-dessous analyse une série de répertoires (par exemple, mu_1e-05, mu_1e-06, ...) et, pour chaque répertoire :

1. Charge les données sim_info.dat au format JSON.
2. Extrait(s) Voc.
3. Calcule \(1/\mu\) en utilisant la mobilité associée à ce répertoire.
4. Crée un petit fichier récapitulatif (voc_vs_inv_mobility.dat).
5. Comparaison des graphiques \(V_{oc}\) et \(1/\mu\).

       import json
       import os

       # Optional: plotting (requires matplotlib)
       import matplotlib.pyplot as plt

       base_dir = os.getcwd()

       # Mobilities must match the run directories you generated earlier
       mobilities = [1e-5, 1e-6, 1e-7, 1e-8]

       inv_mu = []
       vocs = []

       for mu in mobilities:
           run_dir = os.path.join(base_dir, f"mu_{mu:.0e}")
           info_path = os.path.join(run_dir, "sim_info.dat")

           # Read the JSON output file and extract Voc
           f = open(info_path)
           lines = f.readlines()
           f.close()
           lines = "".join(lines)
           data = json.loads(lines)

           voc = data["Voc"]

           inv_mu.append(1.0 / mu)
           vocs.append(voc)

       # Write a small summary table to disk
       out = open("voc_vs_inv_mobility.dat", "w")
       out.write("# inv_mobility(1/mu)    Voc(V)\n")
       for x, y in zip(inv_mu, vocs):
           out.write(f"{x:.6e}    {y}\n")
       out.close()

       # Plot Voc against inverse mobility
       plt.plot(inv_mu, vocs, "o-")
       plt.xlabel("Inverse mobility (1/μ)")
       plt.ylabel("Open-circuit voltage Voc (V)")
       plt.title("Voc vs inverse mobility")
       plt.grid(True)
       plt.tight_layout()
       plt.show()

▶ Vidéo associée

La vidéo ci-dessous montre comment utiliser OghmaNano grâce à des scripts Python.

Remarque : l’API et l’interface de script interne présentées dans la vidéo ne sont plus utilisées et ne sont plus fournies, car leur maintenance s’est avérée difficile. Le processus actuel et recommandé consiste à utiliser un script Python externe pour modifier directement les fichiers de simulation JSON, puis à exécuter oghma_core.exe. Cette approche est plus simple, plus fiable et plus facile à maintenir. Vous pouvez toujours trouver la vidéo utile pour comprendre le processus général et les cas d’utilisation typiques, mais pour connaître la méthode la plus récente, veuillez suivre les étapes décrites ci-dessus.