WIP: Add RAVENS schema

src/PowerModelsDistribution.jl

@@ -71,6 +71,7 @@ module PowerModelsDistribution
     include("data_model/transformations/math2eng.jl")
     include("data_model/transformations/utils.jl")
     include("data_model/transformations/reduce.jl")
+    include("data_model/transformations/ravens2math.jl")
 
     include("core/data.jl")
     include("core/ref.jl")
@@ -113,6 +114,7 @@ module PowerModelsDistribution
     include("io/common.jl")
 
     include("data_model/utils.jl")
+    include("data_model/utils_ravens.jl")
     include("data_model/checks.jl")
     include("data_model/components.jl")
     include("data_model/multinetwork.jl")

src/data_model/utils_ravens.jl

@@ -0,0 +1,99 @@
+const _phasecode_map = Dict(
+            "PhaseCode.ABC" => [1, 2, 3],
+            "PhaseCode.AB" => [1, 2],
+            "PhaseCode.AC" => [1, 3],
+            "PhaseCode.BC" => [2, 3],
+            "PhaseCode.A" => [1],
+            "PhaseCode.B" => [2],
+            "PhaseCode.C" => [3]
+)
+
+
+"initializes the base math object of any type"
+function _init_math_obj_ravens(obj_type::String, eng_id::Any, eng_obj::Dict{String,<:Any}, index::Int; pass_props::Vector{String}=String[])::Dict{String,Any}
+    math_obj = Dict{String,Any}(
+        "name" => "$eng_id",
+        "source_id" => "$obj_type.$eng_id"
+    )
+
+    math_obj["index"] = index
+
+    return math_obj
+end
+
+
+"converts impendance in Ohm/m by multiplying by length"
+function _impedance_conversion_ravens(data_eng::Dict{String,Any}, eng_obj::Dict{String,Any}, key::String)
+
+    _conductor_count =  data_eng["PerLengthPhaseImpedance.conductorCount"]
+    _impedance_matrix = zeros(Float64, _conductor_count, _conductor_count)
+
+    for obj in data_eng["PerLengthPhaseImpedance.PhaseImpedanceData"]
+        row = obj["PhaseImpedanceData.row"]
+        col = obj["PhaseImpedanceData.column"]
+        value = get(obj, key, 0.0)
+        _impedance_matrix[row, col] = value
+        _impedance_matrix[col, row] = value
+    end
+
+    return _impedance_matrix .* get(eng_obj, "Conductor.length", 1.0)
+end
+
+
+"converts impendance in Ohm/m by multiplying by length"
+function _impedance_conversion_ravens_energy_source(data_eng::Dict{String,Any}, eng_obj::Dict{String,Any}, key1::String, key2::String)
+    # Default energy sources considered 3 phases
+    nphases = 3
+    _impedance_matrix = zeros(Float64, nphases, nphases)
+
+    z = get(eng_obj, key1, 0.0)
+    z0 = get(eng_obj, key2, 0.0)
+
+    for i in 1:nphases
+        for j in 1:i
+            if(i==j)
+                _impedance_matrix[i, j] =  z + ((z0 - z)/3)
+            else
+                _impedance_matrix[i, j] = (z0 - z)/3
+                _impedance_matrix[j, i] = (z0 - z)/3
+            end
+        end
+    end
+
+    return _impedance_matrix .* get(eng_obj, "Conductor.length", 1.0)
+end
+
+
+"converts admittance by multiplying by 2πωl"
+function _admittance_conversion_ravens(data_eng::Dict{String,<:Any}, eng_obj::Dict{String,<:Any}, key::String; freq::Float64=60.0)
+
+    _conductor_count =  data_eng["PerLengthPhaseImpedance.conductorCount"]
+    _admittance_matrix = zeros(Float64, _conductor_count, _conductor_count)
+
+    for obj in data_eng["PerLengthPhaseImpedance.PhaseImpedanceData"]
+        row = obj["PhaseImpedanceData.row"]
+        col = obj["PhaseImpedanceData.column"]
+        value = get(obj, key, 0.0)
+        _admittance_matrix[row, col] = value
+        _admittance_matrix[col, row] = value
+    end
+
+    return _admittance_matrix .* get(eng_obj, "Conductor.length", 1.0) .* freq ./ 1e2 # divide by 2 to get both sides _to and _fr
+end
+
+"extracts the name from a ravens reference string"
+function _extract_name(element)
+
+    name = replace(split(element, "::")[2], "'" => "")
+    return name
+end
+
+
+"calculates the shunt admittance matrix based on terminals and b or g"
+function _calc_shunt_admittance_matrix(terminals, b)
+
+    N = length(terminals)
+    _shunt_matrix = b* Matrix(LinearAlgebra.I, N, N)
+    return _shunt_matrix
+
+end

src/prob/common.jl

@@ -116,6 +116,9 @@ function instantiate_mc_model(
         )
     end
 
+    # @info "$(data["transformer"])"
+    # DEFINIDOEN_instantiate_mc_model
+
     return _IM.instantiate_model(
         data,
         model_type,
@@ -129,6 +132,46 @@ function instantiate_mc_model(
 end
 
 
+
+function instantiate_mc_model_ravens(
+    data::Dict{String,<:Any},
+    model_type::Type,
+    build_method::Function;
+    ref_extensions::Vector{<:Function}=Function[],
+    multinetwork::Bool=ismultinetwork(data),
+    global_keys::Set{String}=Set{String}(),
+    ravens2math_extensions::Vector{<:Function}=Function[],
+    ravens2math_passthrough::Dict{String,<:Vector{<:String}}=Dict{String,Vector{String}}(),
+    make_pu_extensions::Vector{<:Function}=Function[],
+    kwargs...
+    )
+
+    @info "Converting CIM-RAVENS data model to MATHEMATICAL first to build JuMP model"
+
+    data = transform_data_model_ravens(
+            data;
+            multinetwork=multinetwork,
+            global_keys=global_keys,
+            ravens2math_extensions=ravens2math_extensions,
+            ravens2math_passthrough=ravens2math_passthrough,
+            make_pu_extensions=make_pu_extensions,
+        )
+
+    # @info "$(data["transformer"])"
+    # DEFINIDOEN_instantiate_mc_model_ravens
+
+    return _IM.instantiate_model(
+        data,
+        model_type,
+        build_method,
+        ref_add_core!,
+        union(_pmd_math_global_keys, global_keys),
+        pmd_it_sym;
+        ref_extensions=ref_extensions,
+        kwargs...
+    )
+end
+
 """
     solve_mc_model(
         data::Dict{String,<:Any},