Тестирование устройств РЗ при насыщение измерительных ТТ

module ScenarioModule

export Scenario, Saturation_Characteristic, reset_faults!, set_fault_type!,
        set_controlled_phase!, set_delay!

mutable struct Saturation_Characteristic
    V_base
    I_base
    I1
    I2
    R2
    trz
    Ta  # будет задаваться при расчёте
end

function Saturation_Characteristic(V_base, I_base, I1, I2, R2, trz)
    return Saturation_Characteristic(V_base, I_base, I1, I2, R2, trz, nothing)
end

"""
    get_corrected_characteristic(satur::Saturation_Characteristic, Ikz, Ta, Rn, Kr, satur_phase)

Вычисляет скорректированные ВАХ (V, I) по фазам (A, B, C), с учётом насыщения.
`satur_phase` — символ 'A', 'B' или 'C', указывающий фазу насыщения.
Возвращает кортеж `(Vabc, Iabc)` — матрицы скорректированных напряжений и токов.
"""
function get_corrected_characteristic(satur::Saturation_Characteristic, Ikz, Ta, Rn, Kr, satur_phase)
    satur.Ta = Ta
    
    # Функция расчёта коэффициента насыщения и скорректированных V и I по фазе
    function calc_phase(Kr_phase)
        # Расчёт точки насыщения (VA correction)
        Kfact = Ikz / satur.I1
        U2sin = Kfact * satur.I2 * (satur.R2 + Rn)

        t = (1:round(Int, satur.trz * 1e6)) ./ 1e6
        Kpr = 2π * 50 * Ta * (1 .- exp.(-t ./ Ta)) .- sin.(2π * 50 .* t)
        Kpr = maximum(Kpr)

        Unas_r = U2sin * Kpr / (1 - Kr_phase)

        # Коэффициент масштабирования
        Knas = Unas_r / satur.V_base[10]

        # Возврат скорректированных характеристик
        V = satur.V_base .* Knas
        I = satur.I_base .* Knas
        return V, I
    end

    # Инициализация коэффициентов насыщения по фазам
    KrA = satur_phase == 'A' ? Kr : 0
    KrB = satur_phase == 'B' ? Kr : 0
    KrC = satur_phase == 'C' ? Kr : 0

    # Расчёт по каждой фазе
    Va, Ia = calc_phase(KrA)
    Vb, Ib = calc_phase(KrB)
    Vc, Ic = calc_phase(KrC)

    Vabc = [Va; Vb; Vc]
    Iabc = [Ia; Ib; Ic]

    return Vabc, Iabc
end

"""Словарь, переводящий короткий код типа КЗ (AB, AG, CAG) в строковое описание."""
const FAULT_MAP = Dict(
    "None" => "None",
    "AG"   => "Single-phase to ground (a-g)",
    "BG"   => "Single-phase to ground (b-g)",
    "CG"   => "Single-phase to ground (c-g)",
    "AB"   => "Two-phase (a-b)",
    "BC"   => "Two-phase (b-c)",
    "CA"   => "Two-phase (c-a)",
    "ABG"  => "Two-phase to ground (a-b-g)",
    "BCG"  => "Two-phase to ground (b-c-g)",
    "CAG"  => "Two-phase to ground (c-a-g)",
    "ABC"  => "Three-phase (a-b-c)",
    "ABCG" => "Three-phase to ground (a-b-c-g)"
)

"""
    mutable struct Scenario

Структура описывает сценарий моделирования короткого замыкания.

Хранит:
- параметры файла и имени проекта РИТМ  
- набор точек КЗ (`K1`, `K1_add`, `K2_4`, `K_delayed`)  
- параметры задержки и контролируемой фазы  
- характеристику насыщения  
- массивы Vabc, Iabc, V_strt  

Методы позволяют:
- сбрасывать точки КЗ  
- задавать тип КЗ  
- задавать параметры задержки  
- формировать данные для выгрузки  
"""
mutable struct Scenario
    path::String
    ritm_name::String

    # Точки КЗ с информацией вида — "Two-phase (a-b)"
    K1::String
    K1_add::String
    K2_4::String
    K_delayed::String

    delay::Real
    controlled_phase::Int8

    satur_characteristic
    Vabc::Matrix{Float64}
    Iabc::Matrix{Float64}
    V_strt::Vector{Float64}

    function Scenario(path::String,
                      ritm_name::String,
                      satur_characteristic)

        return new(
            path,
            ritm_name,

            "None",
            "None",
            "None",
            "None",

            0,
            Int8(1),

            satur_characteristic,
            zeros(3,10),
            zeros(3,10),
            Float64[]
        )
    end
end

"Сбрасывает все точки КЗ в состояние 'None'."
function reset_faults!(s::Scenario)
    s.K1 = "None"
    s.K1_add = "None"
    s.K2_4 = "None"
    s.K_delayed = "None"
end


"""
    set_fault_type!(scenario, "K1", "AB"; reset_faults=true)

Устанавливает тип КЗ в выбранных точках.

Формат вызова:
```julia
set_fault_type!(sc, "K1", "ABC")
set_fault_type!(sc, "K1", "AC", "K2_4", "BG")
set_fault_type!(sc, "K1", "BCG"; reset_faults=false)
```

Аргументы:
- имя точки КЗ: `"K1"`, `K1_add`, `"K2_4"`, `"K_delayed"`
- короткий тип КЗ: `"AG"`, `"BC"`, `"CAG"`, `"ABC"` и т.д.

Если `reset_faults = true` (по умолчанию) — перед установкой
все точки КЗ сбрасываются в `"None"`.
"""
function set_fault_type!(s::Scenario, args...; reset_faults::Bool=true)
    if reset_faults
        reset_faults!(s)
    end

    @assert length(args) % 2 == 0 "Аргументы должны идти парами: точка, тип"

    for i in 1:2:length(args)
        fault_name = args[i]
        code       = uppercase(args[i+1])

        @assert haskey(FAULT_MAP, code) "Неизвестный тип КЗ: $code"

        # Проверяем, что Scenario имеет такое поле
        @assert hasproperty(s, Symbol(fault_name)) "Неверное имя точки КЗ: $fault_name"

        # Записываем строку-описание
        setfield!(s, Symbol(fault_name), FAULT_MAP[code])
    end
end

"""
    set_controlled_phase!(s::Scenario, Ikz, Ta; phase=1, Rn=5, Kr=0)

Задаёт контролируемую фазу и формирует характеристику насыщения трансформатора тока.

Параметр `phase` может быть:
- `1`, `2`, `3` — номера фаз A, B, C
- `'A'`, `'B'`, `'C'` — символьная форма

# Параметры
- `s` — сценарий с полем `satur_characteristic`.
- `Ikz` — ток КЗ.
- `Ta` — постоянная времени переходного процесса.
- `Rn` — сопротивление нагрузки (по умолчанию 5).
- `Kr` — коэффициент остаточной намагниченности (по умолчанию 0).

# Модифицирует
- `s.Vabc`, `s.Iabc` — фазные напряжения и токи.
- `s.controlled_phase` — номер активной фазы.
- `s.V_strt` — стартовые напряжения.

# Пример
```julia
set_controlled_phase!(s, 10000, 0.4; phase='B', Rn=5, Kr=0.86)
```
"""
function set_controlled_phase!(s::Scenario, Ikz, Ta; phase=1, Rn=5, Kr=0)
    # Преобразование символов в индексы
    phase_map = Dict('A' => 1, 'B' => 2, 'C' => 3)

    if phase isa Char
        satur_phase = get(phase_map, phase, 1)
    elseif phase in (1,2,3)
        satur_phase = phase
    else
        error("Некорректная фаза: phase должен быть 1, 2, 3 или 'A','B','C'")
    end

    # Получаем характеристики
    s.Vabc, s.Iabc = get_corrected_characteristic(
        s.satur_characteristic, Ikz, Ta, Rn, 0, satur_phase
    )

    s.controlled_phase = satur_phase

    # Выбираем стартовые напряжения
    V = s.Vabc[:,10]

    if Kr != 0
        if satur_phase == 1
            s.V_strt = [ Kr*V[1], -Kr*V[2], -Kr*V[3] ]
        elseif satur_phase == 2
            s.V_strt = [ -Kr*V[1], Kr*V[2], -Kr*V[3] ]
        else
            s.V_strt = [ Kr*V[1], Kr*V[2], -Kr*V[3] ]
        end
        return
    end

    # Если Kr == 0, то значения остаточной намагниченности - 0.86
    if satur_phase == 1
        s.V_strt = [0, -0.86*V[2], -0.86*V[3]]
    elseif satur_phase == 2
        s.V_strt = [0.86*V[1], -0.7*V[2], 0.86*V[3]]
    else
        s.V_strt = [-0.86*V[1], -0.86*V[2], 0.65*V[3]]
    end
end

"""
    set_delay!(s::Scenario, delay::Real)

Задаёт задержку короткого замыкания (КЗ) в миллисекундах.

Задержка может принимать любое вещественное значение.

# Пример

```julia
set_delay!(s, 37.5)
```
# Аргументы
s — объект структуры Scenario.
delay — величина задержки типа Real.
"""
function set_delay!(s::Scenario, delay::Real)
    s.delay = delay /1e3
end
end # module