Tworzenie skryptów w języku PowerShell.

1. Wprowadzenie

W OghmaNano skrypty PowerShell działają poprzez bezpośrednią edycję plików konfiguracyjnych symulacji, zapisanych na dysku, a następnie uruchamiają silnik symulacyjny (oghma_core.exe), aby uruchomić model. W tej sekcji szczegółowo opisano ten proces.

2. Uruchamianie plików symulacyjnych za pomocą programu PowerShell.

Symulacja OghmaNano jest w pełni definiowana przez pojedynczy plik konfiguracyjny w formacie JSON, sim.json. Plik ten zawiera kompletny stan symulacji, w tym strukturę urządzenia, parametry materiałowe, ustawienia numeryczne i konfigurację wyjściową. W wielu przypadkach sim.json już istnieje jako zwykły plik w katalogu symulacji.

Uruchamiając OghmaNano za pomocą PowerShell, skrypt odczytuje dane z pliku sim.json i zapisuje je w pamięci, modyfikuje jeden lub więcej parametrów, a następnie zapisuje zaktualizowany plik JSON z powrotem na dysku.

Co najważniejsze, program PowerShell musi być uruchomiony oghma_core.exe z ustawionym katalogiem roboczym na katalog symulacji – czyli katalog, w którym znajdują się sim.json (i sim.oghma). Silnik symulacyjny zawsze odczytuje pliki wejściowe z aktualnego katalogu roboczego, więc jeśli katalog roboczy jest nieprawidłowy, symulacja zakończy się niepowodzeniem lub uruchomi nieprawidłowy model.

To rozdzielenie zadań jest celowe i wyraźnie określone: PowerShell odpowiada za definiowanie zmian wprowadzanych w symulacji, natomiast OghmaNano odpowiada za uruchamianie symulacji fizycznej z wykorzystaniem plików znajdujących się w bieżącym katalogu.

Poniższy przykład ilustruje ten proces poprzez załadowanie sim.json, zmodyfikowanie mobilności nośników w pierwszej warstwie urządzenia, zapisanie zaktualizowanej konfiguracji na dysku, a następnie uruchomienie symulacji z katalogu symulacji.

# 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

Jeśli w programie sim.json ustawiono symulację mającą na celu wygenerowanie krzywej J–V, OghmaNano zapisze pliki wynikowe w katalogu symulacji, zawierające takie parametry, jak PCE, współczynnik wypełnienia, \(J_{sc}\) i \(V_{oc}\).

3. Pobieranie wyników

Wiele plików wyjściowych programu OghmaNano zapisywanych jest w formacie JSON. Typowym rozwiązaniem jest odczytanie danych sim_info.dat, wyodrębnienie pojedynczej wartości określającej jakość (na przykład Voc) i dołączenie jej do pliku tekstowego w celu późniejszej analizy.

Poniższy przykład odczytuje wartość sim_info.dat i zapisuje wartość \(V_{oc}\) do oddzielnego pliku tekstowego.

# 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. Bardziej zaawansowane symulacje.

W wielu procesach tworzenia skryptów będziesz chciał uruchamiać tę samą podstawową symulację wielokrotnie, używając różnych wartości parametrów, i przechowywać wyniki każdego uruchomienia w oddzielnym folderze. Jest to najprostszy sposób na zachowanie porządku w wynikach i uniknięcie przypadkowego nadpisywania danych.

Poniższy przykład tworzy zestaw katalogów odpowiadających czterem różnym typom mobilności (1e-5, 1e-6, 1e-7, 1e-8). Dla każdego katalogu wykonuje następujące czynności:

1. Tworzy katalog (jeśli taki katalog jeszcze nie istnieje).
2. Kopiuje aktualną wersję sim.json do tego katalogu.
3. Modyfikuje skopiowany element sim.json, aby ustawić docelową wartość mobilności.
4. Zmienia bieżący katalog roboczy na wskazany katalog.
5. Uruchamia program rozwiązujący w danym katalogu, generując wyniki, które są zapisywane lokalnie w tym katalogu.

Ten schemat stanowi podstawę skryptów wsadowych w OghmaNano: dla każdego uruchomienia tworzony jest oddzielny katalog, oddzielny plik konfiguracyjny oraz czysty folder wyjściowy dla każdej wartości parametru.

# 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. Pobieranie wyników

Po przeprowadzeniu serii symulacji w oddzielnych katalogach (np. mu_1e-05, mu_1e-06, ...), kolejnym krokiem jest wyodrębnienie kluczowego wskaźnika z każdej symulacji i przedstawienie go w formie graficznej, aby zilustrować tendencję. Typowym przykładem jest odczytanie napięcia w obwodzie otwartym \(V_{oc}\) z pliku sim_info.dat w każdym katalogu i przedstawienie go na wykresie w zależności od odwrotności ruchliwości \(1/\mu\).

Poniższy skrypt przeszukuje zdefiniowany zestaw katalogów, odpowiadających wartościom mobilności 1e-5, 1e-6, 1e-7, 1e-8, a dla każdego katalogu wykonuje następujące czynności:

1. Wczytuje dane sim_info.dat w formacie JSON.
2. Fragmenty Voc.
3. Oblicza wartość \(1/\mu\) na podstawie mobilności powiązanej z danym katalogiem.
4. Tworzy mały plik podsumowujący (voc_vs_inv_mobility.dat).
5. Porównanie fabuł \(V_{oc}\) i \(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.).