Enhance get_equivalent_rating function for BranchesParalell and add tests

src/BranchesParallel.jl

@@ -4,10 +4,14 @@ mutable struct BranchesParallel{T <: PSY.ACTransmission} <: PSY.ACTransmission
 end
 
 function BranchesParallel(branches::Vector{T}) where {T <: PSY.ACTransmission}
+    isempty(branches) &&
+        throw(ArgumentError("BranchesParallel requires at least one branch."))
     BranchesParallel(branches, nothing)
 end
 # Constructor for the mixed types
 function BranchesParallel(branches::Vector{PSY.ACTransmission})
+    isempty(branches) &&
+        throw(ArgumentError("BranchesParallel requires at least one branch."))
     return BranchesParallel{PSY.ACTransmission}(branches, nothing)
 end
 
@@ -79,16 +83,117 @@ end
 """
     get_equivalent_rating(bp::BranchesParallel)
 
-Calculate the total rating for branches in parallel.
-For parallel circuits, the rating is the sum of individual ratings divided by the number of circuits.
-This provides a conservative estimate that accounts for potential overestimation of total capacity.
+Calculate the equivalent rating for a group of parallel branches using the default strategy:
+sum with admittance-weighted flow distribution.
+
+Equivalent to `get_equivalent_rating(bp, SumRating(), AdmittanceWeighted())`.
+
+See also: 
+[`get_equivalent_rating(::BranchesParallel, ::SumRating, ::AdmittanceWeighted)`](@ref),
+[`get_equivalent_rating(::BranchesParallel, ::AverageRating, ::AdmittanceWeighted)`](@ref),
+[`get_equivalent_rating(::BranchesParallel, ::SumRating, ::ArithmeticWeighting)`](@ref),
+[`get_equivalent_rating(::BranchesParallel, ::AverageRating, ::ArithmeticWeighting)`](@ref).
 """
 function get_equivalent_rating(bp::BranchesParallel)
-    # Sum of ratings divided by number of circuits
+    return get_equivalent_rating(bp, SumRating(), AdmittanceWeighted())
+end
+
+"""
+    get_equivalent_rating(bp::BranchesParallel, ::SumRating, ::AdmittanceWeighted)
+
+Calculate the equivalent rating using the sum with admittance-weighted flow distribution.
+
+Each branch carries a fraction of total flow proportional to its series susceptance
+``f_i = b_i / \\sum_k b_k``. The total capacity is limited by the first branch
+to reach its thermal limit:
+
+``S_{\\max} = \\min_i \\left( \\frac{S_{\\text{limit},i}}{f_i} \\right)``
+"""
+function get_equivalent_rating(
+    bp::BranchesParallel,
+    ::SumRating,
+    ::AdmittanceWeighted,
+)
+    multipliers = _admittance_multipliers(bp)
+    if any(iszero, values(multipliers)) || any(!isfinite, values(multipliers))
+        throw(
+            ArgumentError(
+                "Cannot compute admittance-weighted equivalent rating: total series susceptance across the parallel group must be finite and non-zero.",
+            ),
+        )
+    end
+    # Total interface capacity limited by the first branch to reach its thermal limit.
+    return minimum(
+        get_equivalent_rating(br) / multipliers[PSY.get_name(br)] for br in bp.branches
+    )
+end
+
+"""
+    get_equivalent_rating(bp::BranchesParallel, ::AverageRating, ::AdmittanceWeighted)
+
+Calculate the susceptance-weighted average of individual branch ratings.
+
+Each branch carries a fraction of total flow proportional to its series susceptance
+``f_i = b_i / \\sum_k b_k``. Returns ``\\sum_i f_i \\cdot S_{\\text{limit},i}``.
+"""
+function get_equivalent_rating(
+    bp::BranchesParallel,
+    ::AverageRating,
+    ::AdmittanceWeighted,
+)
+    multipliers = _admittance_multipliers(bp)
+    if any(!isfinite, values(multipliers))
+        throw(
+            ArgumentError(
+                "Cannot compute admittance-weighted equivalent rating: total series susceptance across the parallel group must be finite and non-zero.",
+            ),
+        )
+    end
+    # Susceptance-weighted average of individual ratings.
+    return sum(
+        multipliers[PSY.get_name(br)] * get_equivalent_rating(br) for br in bp.branches
+    )
+end
+
+"""
+    get_equivalent_rating(bp::BranchesParallel, ::SumRating, ::ArithmeticWeighting)
+
+Calculate the equivalent rating as the simple sum of individual branch ratings.
+
+All branches are treated as carrying equal fractions of total flow.
+"""
+function get_equivalent_rating(
+    bp::BranchesParallel,
+    ::SumRating,
+    ::ArithmeticWeighting,
+)
+    return sum(get_equivalent_rating(branch) for branch in bp.branches)
+end
+
+"""
+    get_equivalent_rating(bp::BranchesParallel, ::AverageRating, ::ArithmeticWeighting)
+
+Calculate the equivalent rating as the arithmetic mean of individual branch ratings.
+
+All branches are treated as carrying equal fractions of total flow.
+"""
+function get_equivalent_rating(
+    bp::BranchesParallel,
+    ::AverageRating,
+    ::ArithmeticWeighting,
+)
     return sum(get_equivalent_rating(branch) for branch in bp.branches) /
            length(bp.branches)
 end
 
+# Internal helper: compute per-branch admittance multipliers for a parallel group.
+function _admittance_multipliers(bp::BranchesParallel)
+    return Dict(
+        PSY.get_name(br) => compute_parallel_multiplier(bp, PSY.get_name(br))
+        for br in bp.branches
+    )
+end
+
 """
     get_equivalent_emergency_rating(bp::BranchesParallel)
 

src/PowerNetworkMatrices.jl

@@ -29,6 +29,14 @@ export DC_vPTDF_Matrix
 export DC_BA_Matrix
 export AC_Ybus_Matrix
 export YBUS_ELTYPE
+export BranchesParallel
+export RatingMethod
+export SumRating
+export AverageRating
+export RatingWeighting
+export AdmittanceWeighted
+export ArithmeticWeighting
+export get_equivalent_rating
 
 export apply_woodbury_correction
 export clear_all_caches!

src/definitions.jl

@@ -33,3 +33,49 @@ const SUPPORTED_LINEAR_SOLVERS = ("KLU", "MKLPardiso", "AppleAccelerate", "Dense
     s == "AppleAccelerate" && return AppleAccelerateSolver()
     error("Unsupported linear solver: $s. Supported: $SUPPORTED_LINEAR_SOLVERS")
 end
+
+"""
+Abstract supertype for rating aggregation strategies applied to groups of parallel branches.
+
+See also: [`SumRating`](@ref), [`AverageRating`](@ref).
+"""
+abstract type RatingMethod end
+
+"""
+    SumRating()
+
+Rating aggregation strategy for parallel branches: returns the sum 
+    of individual branch capacities.
+"""
+struct SumRating <: RatingMethod end
+
+"""
+    AverageRating()
+
+Rating aggregation strategy for parallel branches: returns the arithmetic mean 
+    of individual branch ratings.
+"""
+struct AverageRating <: RatingMethod end
+
+"""
+Abstract supertype for flow weighting schemes applied to groups of parallel branches.
+
+See also: [`AdmittanceWeighted`](@ref), [`ArithmeticWeighting`](@ref).
+"""
+abstract type RatingWeighting end
+
+"""
+    AdmittanceWeighted()
+
+Flow weighting scheme for parallel branches: each branch carries a fraction of total potential 
+    flow proportional to series susceptance, reflecting physical behaviour of parallel circuits.
+"""
+struct AdmittanceWeighted <: RatingWeighting end
+
+"""
+    ArithmeticWeighting()
+
+Flow weighting scheme for parallel branches: each branch is treated as carrying an equal
+    fraction of total potential flow (uniform weighting).
+"""
+struct ArithmeticWeighting <: RatingWeighting end

test/test_equivalent_getters.jl

@@ -36,9 +36,30 @@
     )
     # Create BranchesParallel
     bp = PNM.BranchesParallel([line1, line2])
-    # Test get_rating: Rating = (Rating1 + Rating2) / n = (100.0 + 150.0) / 2 = 125.0
-    rating_eq = PNM.get_equivalent_rating(bp)
-    @test rating_eq ≈ 125.0 atol = 1e-6
+
+    # Default (SumRating + AdmittanceWeighted)
+    # b1 = x1/(r1²+x1²) = 0.2/0.05 = 4.0,  b2 = 0.4/0.20 = 2.0,  b_total = 6.0
+    # f1 = 2/3,  f2 = 1/3
+    # min(100/(2/3), 150/(1/3)) = min(150, 450) = 150.0
+    @test PNM.get_equivalent_rating(
+        bp,
+    ) ≈ 150.0 atol = 1e-6
+
+    # AverageRating + AdmittanceWeighted
+    # (2/3)*100 + (1/3)*150 = 350/3 ≈ 116.667
+    @test PNM.get_equivalent_rating(
+        bp, PNM.AverageRating(), PNM.AdmittanceWeighted(),
+    ) ≈ 350.0 / 3.0 atol = 1e-6
+
+    # SumRating + ArithmeticWeighting
+    @test PNM.get_equivalent_rating(
+        bp, PNM.SumRating(), PNM.ArithmeticWeighting(),
+    ) ≈ 250.0 atol = 1e-6
+
+    # AverageRating + ArithmeticWeighting
+    @test PNM.get_equivalent_rating(
+        bp, PNM.AverageRating(), PNM.ArithmeticWeighting(),
+    ) ≈ 125.0 atol = 1e-6
 
     emergency_rating_eq = PNM.get_equivalent_emergency_rating(bp)
     @test emergency_rating_eq ≈ 250.0 atol = 1e-6
@@ -53,13 +74,12 @@
     emergency_rating_eq = PNM.get_equivalent_emergency_rating(bs)
     @test emergency_rating_eq ≈ 100.0 atol = 1e-6
 
-    #Add test parrallel circuit + line1
+    # Add test parallel circuit + line2
     bs = PNM.BranchesSeries()
     PNM.add_branch!(bs, bp, :FromTo)
     PNM.add_branch!(bs, line2, :FromTo)
-    # Test get_rating: Rating = minimum rating for series branches (weakest link)
     rating_eq = PNM.get_equivalent_rating(bs)
-    @test rating_eq ≈ 125.0 atol = 1e-6
+    @test rating_eq ≈ 150.0 atol = 1e-6
 
     emergency_rating_eq = PNM.get_equivalent_emergency_rating(bs)
     @test emergency_rating_eq ≈ 150.0 atol = 1e-6