PowerShell-Skripting

1. Einleitung

In OghmaNano funktioniert die PowerShell-Skripterstellung, indem die Konfigurationsdateien der Simulation direkt auf der Festplatte bearbeitet und anschließend die Simulations-Engine (oghma_core.exe) aufgerufen wird, um das Modell auszuführen. In diesem Abschnitt wird dieser Arbeitsablauf detailliert beschrieben.

2. Ausführen von Simulationsdateien mit PowerShell

Eine OghmaNano-Simulation wird vollständig durch eine einzige JSON-Konfigurationsdatei sim.json definiert. Diese Datei enthält den vollständigen Zustand der Simulation, einschließlich der Gerätearchitektur, der Materialparameter, der numerischen Einstellungen und der Ausgabekonfiguration. In vielen Fällen sim.json existiert diese Datei bereits als normale Datei innerhalb des Simulationsverzeichnisses.

Wenn OghmaNano über PowerShell ausgeführt wird, liest das Skript sim.json in den Speicher, ändert einen oder mehrere Parameter und speichert die aktualisierte JSON-Datei wieder auf der Festplatte.

Entscheidend ist, dass PowerShell oghma_core.exe mit dem Simulationsverzeichnis als aktuellem Arbeitsverzeichnis ausgeführt werden muss – also dem Verzeichnis, das sim.json (und sim.oghma) enthält. Die Simulations-Engine liest ihre Eingabedateien immer aus dem aktuellen Arbeitsverzeichnis, sodass die Simulation fehlschlägt oder das falsche Modell ausführt, wenn das Arbeitsverzeichnis falsch ist.

Diese Aufteilung der Verantwortlichkeiten ist bewusst und explizit: PowerShell ist dafür zuständig, festzulegen, welche Änderungen in der Simulation vorgenommen werden, während OghmaNano die physikalische Simulation unter Verwendung der Dateien im aktuellen Verzeichnis ausführt.

Das folgende Beispiel veranschaulicht diesen Prozess, indem es sim.json lädt, die Trägermobilität der ersten Geräteschicht modifiziert, die aktualisierte Konfiguration auf der Festplatte speichert und anschließend die Simulation aus dem Simulationsverzeichnis ausführt.

# Set this to your simulation folder (must contain sim.json / sim.oghma)
$sim_dir = "C:\path\to\your\simulation"

# Read sim.json
$sim_path = Join-Path $sim_dir "sim.json"
$txt = Get-Content -Path $sim_path -Raw
$data = $txt | ConvertFrom-Json

# Edit a value: mobility of segment1 (same JSON path as the Python/MATLAB pages)
$data.epitaxy.segment1.shape_dos.mue_y = 1.0

# Write sim.json back to disk
$out = $data | ConvertTo-Json -Depth 200
Set-Content -Path $sim_path -Value $out -Encoding UTF8

# Run the simulation (working directory must be the simulation folder)
$orig_dir = Get-Location
Set-Location $sim_dir
& "oghma_core.exe"
Set-Location $orig_dir

Wenn die Simulation in sim.json so eingerichtet ist, dass eine J–V-Kurve berechnet wird, erstellt OghmaNano Ausgabedateien im Simulationsverzeichnis, die Größen wie den Wirkungsgrad, den Füllfaktor, \(J_{sc}\) und \(V_{oc}\) enthalten.

3. Ergebnisse extrahieren

Viele der von OghmaNano erstellten Ausgabedateien sind im JSON-Format gespeichert. Ein gängiges Verfahren besteht darin, sim_info.dat auszulesen, einen einzelnen, aussagekräftigen Wert zu extrahieren (zum Beispiel Voc) und diesen einer Textdatei hinzuzufügen, um ihn später zu analysieren.

Das folgende Beispiel liest sim_info.dat und fügt den Wert von \(V_{oc}\) einer separaten Textdatei hinzu.

# Must be run from (or pointed at) a completed simulation directory
$sim_dir = "C:\path\to\your\simulation"
$info_path = Join-Path $sim_dir "sim_info.dat"

$txt = Get-Content -Path $info_path -Raw
$info = $txt | ConvertFrom-Json
$voc = $info.Voc

# Append to a text file (one Voc per line)
$out_path = Join-Path $sim_dir "out.dat"
Add-Content -Path $out_path -Value ("{0}" -f $voc)

3. Komplexere Simulationen

In vielen Skript-basierten Arbeitsabläufen möchten Sie möglicherweise die gleiche Basissimulation mehrmals mit unterschiedlichen Parameterwerten ausführen und jede Ausführung in einem eigenen Verzeichnis isoliert speichern. Dies ist die einfachste Methode, um übersichtliche Ergebnisse zu erzielen und zu verhindern, dass Ergebnisse versehentlich überschrieben werden.

Das folgende Beispiel erstellt eine Reihe von Verzeichnissen, die den vier Mobilitätsarten (1e-5, 1e-6, 1e-7, 1e-8) entsprechen. Für jedes Verzeichnis werden folgende Schritte ausgeführt:

1. Erstellt das Verzeichnis (falls es noch nicht vorhanden ist).
2. Kopiert die aktuelle sim.json-Datei in dieses Verzeichnis.
3. Bearbeitet die kopierte sim.json-Datei, um die gewünschte Mobilität einzustellen.
4. Ändert das aktuelle Arbeitsverzeichnis in das angegebene Verzeichnis.
5. Führt den Solver in diesem Verzeichnis aus und erzeugt Ausgabedateien, die für diese Ausführung spezifisch sind.

Dieses Muster bildet die Grundlage für die Batch-Skripterstellung in OghmaNano: Für jeden Durchlauf wird ein eigenes Verzeichnis, eine eigene Konfigurationsdatei und ein eigener, leerer Ausgabeordner für jeden Parametersatz verwendet.

# The script should be started in the base simulation directory
# (i.e. the directory containing the reference sim.json).
$base_dir = (Get-Location).Path

$mobilities = @(1e-5, 1e-6, 1e-7, 1e-8)
$src_sim = Join-Path $base_dir "sim.json"

foreach ($mu in $mobilities) {
    $run_name = ("mu_{0:0e}" -f $mu)
    $run_dir  = Join-Path $base_dir $run_name

    if (-not (Test-Path -Path $run_dir -PathType Container)) {
        New-Item -ItemType Directory -Path $run_dir | Out-Null
    }

    # Copy the base sim.json into the run directory
    $dst_sim = Join-Path $run_dir "sim.json"
    Copy-Item -Path $src_sim -Destination $dst_sim -Force

    # Load the copied sim.json and edit the mobility in THAT copy
    $txt  = Get-Content -Path $dst_sim -Raw
    $data = $txt | ConvertFrom-Json
    $data.epitaxy.segment1.shape_dos.mue_y = [double]$mu

    $out = $data | ConvertTo-Json -Depth 200
    Set-Content -Path $dst_sim -Value $out -Encoding UTF8

    # Change into the run directory and execute the solver there
    Push-Location $run_dir
    & "oghma_core.exe"
    Pop-Location
}

4. Ergebnisse extrahieren

Nachdem eine Reihe von Simulationen in separaten Verzeichnissen durchgeführt wurden (z. B. mu_1e-05, mu_1e-06, ...), besteht der nächste Schritt darin, eine wichtige Kennzahl aus jeder Simulation zu extrahieren und den Trend grafisch darzustellen. Ein gängiges Beispiel ist das Auslesen der Leerlaufspannung \(V_{oc}\) aus sim_info.dat in jedem Verzeichnis und das anschließende Aufzeichnen dieser Werte in Abhängigkeit von der inversen Beweglichkeit \(1/\mu\).

Das folgende Skript durchsucht eine vordefinierte Menge von Verzeichnissen, die den Mobilitätswerten 1e-5, 1e-6, 1e-7, 1e-8 entsprechen, und führt für jedes Verzeichnis Folgendes aus:

1. Lädt sim_info.dat als JSON-Datei.
2. Auszüge Voc.
3. Berechnet \(1/\mu\) anhand der Mobilität, die dem jeweiligen Verzeichnis zugeordnet ist.
4. Erstellt eine kleine Zusammenfassungsdatei (voc_vs_inv_mobility.dat).
5. Diagramme \(V_{oc}\) im Vergleich zu \(1/\mu\).

# Run this from the BASE directory that contains the run folders
# (mu_1e-05, mu_1e-06, ...). If not, set base_dir explicitly.
$base_dir = (Get-Location).Path

$mobilities = @(1e-5, 1e-6, 1e-7, 1e-8)

$inv_mu = @()
$vocs   = @()

foreach ($mu in $mobilities) {
    $run_dir = Join-Path $base_dir ("mu_{0:0e}" -f $mu)
    $info_path = Join-Path $run_dir "sim_info.dat"

    if (-not (Test-Path -Path $info_path -PathType Leaf)) {
        throw ("Missing sim_info.dat in: {0}" -f $run_dir)
    }

    $txt  = Get-Content -Path $info_path -Raw
    $info = $txt | ConvertFrom-Json

    $vocs   += [double]$info.Voc
    $inv_mu += (1.0 / [double]$mu)
}

# Write a small summary table to disk
$out_path = Join-Path $base_dir "voc_vs_inv_mobility.dat"
"# inv_mobility(1/mu)    Voc(V)" | Set-Content -Path $out_path -Encoding UTF8
for ($i = 0; $i -lt $mobilities.Count; $i++) {
    ("{0:e6}    {1}" -f $inv_mu[$i], $vocs[$i]) | Add-Content -Path $out_path -Encoding UTF8
}

# Plot Voc vs inverse mobility
# PowerShell does not have a built-in plotting window. The simplest workflow is to
# load voc_vs_inv_mobility.dat into your plotting tool of choice (MATLAB, Python, Excel, etc.).