Scripting em PowerShell

1. Introdução

No OghmaNano, o scripting em PowerShell funciona editando diretamente os arquivos de configuração da simulação em disco e então invocando o mecanismo de simulação (oghma_core.exe) para executar o modelo. Esta seção descreve esse fluxo de trabalho em detalhe.

2. Executando arquivos de simulação com PowerShell

Uma simulação do OghmaNano é definida inteiramente por um único arquivo de configuração JSON, sim.json. Esse arquivo contém o estado completo da simulação, incluindo a estrutura do dispositivo, os parâmetros de material, as configurações numéricas e a configuração de saída. Em muitos casos, sim.json já existe como um arquivo normal dentro do diretório da simulação.

Ao controlar o OghmaNano a partir de PowerShell, o script lê sim.json na memória, modifica um ou mais parâmetros e grava o JSON atualizado de volta em disco.

Crucialmente, o PowerShell deve executar oghma_core.exe com seu diretório de trabalho definido como o diretório da simulação — isto é, o diretório que contém sim.json (e sim.oghma). O mecanismo de simulação sempre lê seus arquivos de entrada a partir do diretório de trabalho atual, portanto, se o diretório de trabalho estiver incorreto, a simulação falhará ou executará o modelo errado.

Essa separação de responsabilidades é intencional e explícita: PowerShell é responsável por definir o que muda na simulação, enquanto o OghmaNano é responsável por executar a física usando os arquivos presentes no diretório atual.

O exemplo abaixo demonstra esse processo carregando sim.json, modificando a mobilidade de portadores da primeira camada do dispositivo, gravando a configuração atualizada de volta em disco e então executando a simulação a partir do diretório da simulação.

# Defina isto como sua pasta de simulação (deve conter sim.json / sim.oghma)
$sim_dir = "C:\path\to\your\simulation"

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

# Editar um valor: mobilidade de segment1 (mesmo caminho JSON das páginas de Python/MATLAB)
$data.epitaxy.segment1.shape_dos.mue_y = 1.0

# Gravar sim.json de volta em disco
$out = $data | ConvertTo-Json -Depth 200
Set-Content -Path $sim_path -Value $out -Encoding UTF8

# Executar a simulação (o diretório de trabalho deve ser a pasta da simulação)
$orig_dir = Get-Location
Set-Location $sim_dir
& "oghma_core.exe"
Set-Location $orig_dir

Se a simulação em sim.json estiver configurada para executar uma curva J–V, o OghmaNano gravará arquivos de saída no diretório da simulação contendo quantidades como PCE, fator de preenchimento, \(J_{sc}\) e \(V_{oc}\).

3. Extraindo resultados

Muitos arquivos de saída do OghmaNano são gravados em formato JSON. Um padrão comum é ler sim_info.dat, extrair uma figura de mérito escalar (por exemplo Voc) e anexá-la a um arquivo de texto para análise posterior.

O exemplo abaixo lê sim_info.dat e anexa o valor de \(V_{oc}\) a um arquivo de texto separado.

# Deve ser executado a partir de (ou apontado para) um diretório de simulação concluída
$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

# Anexar a um arquivo de texto (um Voc por linha)
$out_path = Join-Path $sim_dir "out.dat"
Add-Content -Path $out_path -Value ("{0}" -f $voc)

3. Simulações mais complexas

Em muitos fluxos de trabalho com scripting, você desejará executar a mesma simulação base várias vezes com diferentes valores de parâmetro e manter cada execução isolada em seu próprio diretório. Essa é a forma mais simples de manter as saídas organizadas e evitar sobrescrever acidentalmente os resultados.

O exemplo abaixo cria um conjunto de diretórios correspondentes a quatro mobilidades (1e-5, 1e-6, 1e-7, 1e-8). Para cada diretório ele:

1. Cria o diretório (se ele ainda não existir).
2. Copia o sim.json atual para esse diretório.
3. Edita o sim.json copiado para definir a mobilidade alvo.
4. Muda o diretório de trabalho para esse diretório.
5. Executa o solver nesse diretório, produzindo saídas locais para essa execução.

Esse padrão é a base do scripting em lote no OghmaNano: um diretório por execução, um arquivo de configuração por execução, e uma pasta de saída limpa para cada valor de parâmetro.

# O script deve ser iniciado no diretório base da simulação
# (ou seja, o diretório que contém o sim.json de referência).
$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 o sim.json base para o diretório da execução
    $dst_sim = Join-Path $run_dir "sim.json"
    Copy-Item -Path $src_sim -Destination $dst_sim -Force

    # Carregar o sim.json copiado e editar a mobilidade NESSA cópia
    $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

    # Mudar para o diretório da execução e executar o solver lá
    Push-Location $run_dir
    & "oghma_core.exe"
    Pop-Location
}

4. Extraindo resultados

Depois de executar um lote de simulações em diretórios de execução separados (por exemplo mu_1e-05, mu_1e-06, ...), o próximo passo é extrair uma figura de mérito chave de cada execução e visualizar a tendência. Um exemplo comum é ler a tensão de circuito aberto \(V_{oc}\) de sim_info.dat em cada diretório e plotá-la contra a mobilidade inversa \(1/\mu\).

O script abaixo varre um conjunto fixo de diretórios de execução correspondentes às mobilidades 1e-5, 1e-6, 1e-7, 1e-8 e, para cada diretório:

1. Carrega sim_info.dat como JSON.
2. Extrai Voc.
3. Calcula \(1/\mu\) usando a mobilidade associada àquele diretório.
4. Grava um pequeno arquivo de resumo (voc_vs_inv_mobility.dat).
5. Plota \(V_{oc}\) vs \(1/\mu\).

# Execute isto a partir do diretório BASE que contém as pastas de execução
# (mu_1e-05, mu_1e-06, ...). Se não, defina base_dir explicitamente.
$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 ("sim_info.dat ausente em: {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)
}

# Gravar uma pequena tabela de resumo em disco
$out_path = Join-Path $base_dir "voc_vs_inv_mobility.dat"
"# mobilidade_inversa(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
}

# Plotar Voc vs mobilidade inversa
# O PowerShell não possui uma janela de plotagem integrada. O fluxo de trabalho mais simples é
# carregar voc_vs_inv_mobility.dat em sua ferramenta de plotagem preferida (MATLAB, Python, Excel, etc.).