Scripting en PowerShell

1. Introducción

En OghmaNano, el scripting en PowerShell funciona editando directamente los archivos de configuración de simulación en disco y luego invocando el motor de simulación (oghma_core.exe) para ejecutar el modelo. Esta sección describe este flujo de trabajo en detalle.

2. Ejecutar archivos de simulación con PowerShell

Una simulación de OghmaNano está definida completamente por un único archivo de configuración JSON, sim.json. Este archivo contiene el estado completo de la simulación, incluyendo la estructura del dispositivo, los parámetros del material, los ajustes numéricos y la configuración de salida. En muchos casos, sim.json ya existe como un archivo normal dentro del directorio de simulación.

Al controlar OghmaNano desde PowerShell, el script lee sim.json en memoria, modifica uno o más parámetros y escribe el JSON actualizado de nuevo en disco.

Es crucial que PowerShell ejecute oghma_core.exe con su directorio de trabajo configurado en el directorio de simulación — es decir, el directorio que contiene sim.json (y sim.oghma). El motor de simulación siempre lee sus archivos de entrada desde el directorio de trabajo actual, por lo que si el directorio de trabajo es incorrecto, la simulación fallará o ejecutará el modelo equivocado.

Esta separación de responsabilidades es intencional y explícita: PowerShell es responsable de definir qué cambia en la simulación, mientras que OghmaNano es responsable de ejecutar la física usando los archivos presentes en el directorio actual.

El ejemplo siguiente demuestra este proceso cargando sim.json, modificando la movilidad de portadores de la primera capa del dispositivo, escribiendo la configuración actualizada de nuevo en disco y luego ejecutando la simulación desde el directorio de simulación.

# Configure esto a su carpeta de simulación (debe contener sim.json / sim.oghma)
$sim_dir = "C:\path\to\your\simulation"

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

# Editar un valor: movilidad de segment1 (misma ruta JSON que en las páginas de Python/MATLAB)
$data.epitaxy.segment1.shape_dos.mue_y = 1.0

# Escribir sim.json de nuevo en disco
$out = $data | ConvertTo-Json -Depth 200
Set-Content -Path $sim_path -Value $out -Encoding UTF8

# Ejecutar la simulación (el directorio de trabajo debe ser la carpeta de simulación)
$orig_dir = Get-Location
Set-Location $sim_dir
& "oghma_core.exe"
Set-Location $orig_dir

Si la simulación en sim.json está configurada para ejecutar una curva J–V, OghmaNano escribirá archivos de salida en el directorio de simulación que contienen magnitudes tales como PCE, factor de llenado, \(J_{sc}\) y \(V_{oc}\).

3. Extracción de resultados

Muchos archivos de salida de OghmaNano se escriben en formato JSON. Un patrón común consiste en leer sim_info.dat, extraer una figura de mérito escalar (por ejemplo Voc), y añadirla a un archivo de texto para un análisis posterior.

El ejemplo siguiente lee sim_info.dat y añade el valor de \(V_{oc}\) a un archivo de texto separado.

# Debe ejecutarse desde (o apuntar a) un directorio de simulación completado
$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

# Añadir a un archivo de texto (un Voc por línea)
$out_path = Join-Path $sim_dir "out.dat"
Add-Content -Path $out_path -Value ("{0}" -f $voc)

3. Simulaciones más complejas

En muchos flujos de trabajo de scripting querrá ejecutar la misma simulación base varias veces con distintos valores de parámetro y mantener cada ejecución aislada en su propio directorio. Esta es la forma más sencilla de mantener limpias las salidas y evitar sobrescribir accidentalmente resultados.

El ejemplo siguiente crea un conjunto de directorios correspondientes a cuatro movilidades (1e-5, 1e-6, 1e-7, 1e-8). Para cada directorio:

1. Crea el directorio (si no existe ya).
2. Copia el sim.json actual en ese directorio.
3. Edita el sim.json copiado para establecer la movilidad objetivo.
4. Cambia el directorio de trabajo a ese directorio.
5. Ejecuta el solucionador en ese directorio, produciendo salidas locales a esa ejecución.

Este patrón es la base del scripting por lotes en OghmaNano: un directorio por ejecución, un archivo de configuración por ejecución, y una carpeta de salida limpia para cada valor de parámetro.

# El script debe iniciarse en el directorio base de simulación
# (es decir, el directorio que contiene el sim.json de referencia).
$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
    }

    # Copiar el sim.json base al directorio de ejecución
    $dst_sim = Join-Path $run_dir "sim.json"
    Copy-Item -Path $src_sim -Destination $dst_sim -Force

    # Cargar el sim.json copiado y editar la movilidad en ESA copia
    $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

    # Cambiar al directorio de ejecución y ejecutar allí el solucionador
    Push-Location $run_dir
    & "oghma_core.exe"
    Pop-Location
}

4. Extracción de resultados

Después de ejecutar un lote de simulaciones en directorios de ejecución separados (por ejemplo mu_1e-05, mu_1e-06, ...), el siguiente paso es extraer una figura de mérito clave de cada ejecución y visualizar la tendencia. Un ejemplo común es leer el voltaje de circuito abierto \(V_{oc}\) desde sim_info.dat en cada directorio y representarlo frente a la movilidad inversa \(1/\mu\).

El script siguiente recorre un conjunto fijo de directorios de ejecución correspondientes a movilidades 1e-5, 1e-6, 1e-7, 1e-8 y para cada directorio:

1. Carga sim_info.dat como JSON.
2. Extrae Voc.
3. Calcula \(1/\mu\) usando la movilidad asociada a ese directorio.
4. Escribe un pequeño archivo resumen (voc_vs_inv_mobility.dat).
5. Representa \(V_{oc}\) frente a \(1/\mu\).

# Ejecute esto desde el directorio BASE que contiene las carpetas de ejecución
# (mu_1e-05, mu_1e-06, ...). Si no, configure base_dir explícitamente.
$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 ("Falta sim_info.dat en: {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)
}

# Escribir una pequeña tabla resumen en disco
$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
}

# Representar Voc frente a la movilidad inversa
# PowerShell no tiene una ventana de representación integrada. El flujo de trabajo más sencillo es
# cargar voc_vs_inv_mobility.dat en la herramienta de representación de su elección (MATLAB, Python, Excel, etc.).