Fix some bugs, merge splitminor and splitgrid, use tooltip boundingbox for deleting markers, save markers data on a dictionary. Add Constant gain and constant noise circles. Add Stability regions.

Author: uvegege

Images/ConstantCircles.svg

@@ -124,6 +124,125 @@ Interactive data markers can be added to your Smith chart using the `datamarkers
 
 ![datamarkergif](Images/datamarkers.gif)
 
+
+## Stability, Gain and Noise Circles
+
+SmithChart.jl allows visualization of constant gain circles, constant noise circles, and stability regions, essential for amplifier design and stability analysis. These features can be useful for tasks such as designing low-noise amplifiers (LNAs), power amplifiers, and ensuring the stability of circuits over a range of frequencies and impedances.
+
+This example shows how to use the `NFCircle` and `CGCircle`. This functions returns an array of `Point2f` that can be used with Makie functions like `lines!` or `poly!`. 
+
+```julia
+using CairoMakie
+f = Figure(size = (1200, 660))
+sc = SmithAxis(f[1,1], cutgrid = true, title = "Constant NF Circles")
+
+NF_to_F(nf) = 10.0^(nf/10.0)
+Γopt = 0.5 * cis(130 * pi / 180)
+NFmin = 1.6 # dB
+Fmin = NF_to_F(NFmin)
+F2dB = NF_to_F(2.0)
+F2_5dB = NF_to_F(2.5)
+F3dB = NF_to_F(3.0)
+nf2 = NFCircle(F2dB, Fmin, Γopt, 20.0, 50.0, 361)
+nf2_5 = NFCircle(F2_5dB, Fmin, Γopt, 20.0, 50.0, 361)
+nf3 = NFCircle(F3dB, Fmin, Γopt, 20.0, 50.0, 361)
+
+smithscatter!(sc, [Γopt], reflection = true, color = :blue, linewidth = 1.9)
+text!(sc, "Γopt", position = Point2f(real(Γopt), imag(Γopt)),  offset  = (3, 3), color = :blue, font = :bold)
+text!(sc, "$NFmin dB", position = Point2f(real(Γopt), imag(Γopt)),  offset  = (0, -16), color = :blue, font = :bold)
+
+lines!(sc, nf2, color = :green, linewidth = 1.9)
+text!(sc, "2.0 dB", position = nf2[45],  offset  = (2, 0), color = :green, font = :bold)
+
+lines!(sc, nf2_5, color = :purple, linewidth = 1.9)
+text!(sc, "2.5 dB", position = nf2_5[120],  offset  = (-35, 2), color = :purple, font = :bold)
+
+lines!(sc, nf3, color = :orange, linewidth = 1.9)
+text!(sc, "3.0 dB", position = nf3[260],  offset  = (2, 2), color = :orange, font = :bold)
+
+# https://www.allaboutcircuits.com/technical-articles/designing-a-unilateral-rf-amplifier-for-a-specified-gain/
+sc = SmithAxis(f[1,2], cutgrid = true, title = "Constant Gs Circles")
+
+S11 = 0.533 * cis(176.6 / 180 * π)
+S22 = 0.604 * cis(-58.0 / 180 * π)
+Go = abs2(S11)
+Gs_max = 1 / (1 - abs2(S11))
+gain(dB) = 10.0^(dB/10.0)
+
+g1 = gain(0.0) / Gs_max
+g2 = gain(0.5) / Gs_max
+g3 = gain(1.0) / Gs_max
+g4 = gain(1.4) / Gs_max
+
+c1 = CGCircle(g1, S11, 361)
+c2 = CGCircle(g2, S11, 361)
+c3 = CGCircle(g3, S11, 361)
+c4 = CGCircle(g4, S11, 361)
+
+smithscatter!(sc, [conj(S11)], reflection = true, color = :blue, linewidth = 1.9)
+text!(sc, "S11*", position = Point2f(real(S11), -imag(S11)),  
+    offset  = (-5, 7), color = :blue, font = :bold, fontsize = 9)
+
+poly!(sc, c1, color = (:green, 0.1), strokecolor = :green, strokewidth = 1.9)
+text!(sc, "0.0 dB", position = c1[125],  offset  = (17, 0), color = :green, font = :bold)
+
+lines!(sc, c2, color = :red, linewidth = 1.9)
+text!(sc, "0.5 dB", position = c2[110],  offset  = (-27, 3), color = :red, font = :bold)
+
+lines!(sc, c3, color = :magenta, linewidth = 1.9)
+text!(sc, "1.0 dB", position = c3[260],  offset  = (2, 0), color = :magenta, font = :bold)
+
+lines!(sc, c4, color = :purple, linewidth = 1.9)
+text!(sc, "1.4 dB", position = c3[45],  offset  = (2, 2), color = :purple, font = :bold)
+```
+
+![Ccircles](Images/ConstantCircles.svg)
+
+When calculating the stability regions, you can select whether you want to display the stable or unstable region. To do this, modify the keyword `stable` in the `StabilityCircle` function.
+
+```julia
+using CairoMakie
+f = Figure(size = (800, 500))
+Label(f[0, 1:2] , "Stable Regions", fontsize = 24, font = :bold)
+S11, S12, S21, S22 =  [0.438868-0.778865im 1.4+0.2im; 0.1+0.43im  0.692125-0.361834im]
+A =  StabilityCircle(S11, S12, S21, S22, :source, 361; stable = false)
+B =  StabilityCircle(S11, S12, S21, S22, :source, 361; stable = true)
+
+ax = SmithAxis(f[1,1], subtitle = "StabilityCircle(... ; stable = false)")
+region = poly!(ax, A, strokecolor = :black, strokewidth = 1.2, color = Pattern('x', linecolor = :red, width = 1.3, background_color = (:red, 0.1)))
+translate!(region, (0, 0, -2)) 
+text!(ax, "Unstable Input Region", position = Point2f(-0.1, -0.5), font = :bold, color = :red, fontsize = 13)
+B =  StabilityCircle(S11, S12, S21, S22, :source, 361; stable = true);
+ax = SmithAxis(f[1,2], subtitle = "StabilityCircle(... ; stable = true)")
+region = poly!(ax, B, strokecolor = :black, strokewidth = 1.2, color = Pattern('\\', linecolor = :blue, width = 1.3, background_color = (:blue, 0.1)))
+translate!(region, (0, 0, -2)) 
+text!(ax, "Stable Input region", position = Point2f(-0.5, -0.5), font = :bold, color = :blue, fontsize = 13)
+```
+![stabilityregions1](Images/stableregions.svg)
+
+It is possible to obtain the input or output stability regions with `StabilityCircle(S11, S12, S21, S22, :source, npoints)` or `StabilityCircle(S11, S12, S21, S22, :load, npoints)`.
+
+```julia
+f = Figure()
+S11, S12, S21, S22 = [ 0.0967927-0.604297im  0.0255292+0.0394621im ; -8.4396+11.0786im    0.552226-0.425271im]
+A =  StabilityCircle(S11, S12, S21, S22, :source, 361; stable = true);
+B =  StabilityCircle(S11, S12, S21, S22, :load, 361; stable = true);
+ax = SmithAxis(f[1,1], title = "Input and Output stability regions")
+color1 = Pattern('/', linecolor = :blue, width = 1.3, background_color  = :transparent)
+color2 = Pattern('\\', linecolor = :green, width = 1.3, background_color  = :transparent)
+region = poly!(ax, A, strokecolor = :black, strokewidth = 1.2, color = color1)
+translate!(region, (0, 0, -2)) 
+region = poly!(ax, B, strokecolor = :black, strokewidth = 1.2, color = color2)
+translate!(region, (0, 0, -2)) 
+text!(ax, "Stable Input", position = Point2f(-0.85, 0.2), font = :bold, color = :blue, rotation = 25*pi/180, fontsize = 12)
+text!(ax, "Stable Output", position = Point2f(0.3, 0.5), font = :bold, color = :green, rotation = -18*pi/180, fontsize = 12)
+```
+
+![stabilityregions2](Images/StableRegionsLines.svg)
+
+
+![ZoomGif](Images/SmithChart_zoom.gif)
+
 ## Dynamic Annotation Update
 
 You can activate a experimental dynamic curve annotation with the keyword `textupdate = true`
@@ -133,8 +252,6 @@ fig = Figure(size = (800,600))
 ax = SmithAxis(fig[1, 1]; subgrid = true, cutgrid = true, zoomupdate = true, textupdate = true, threshold = (150, 150))
 ```
 
-![ZoomGif](Images/SmithChart_zoom.gif)
-
 ## Other Keywords
 
 How some keywords modify visual aspects of the Smith Chart.
@@ -159,6 +276,6 @@ There are multiple keywords to modify the position of the ticks. Some of them ar
 
 ### Subgrid split
 
-The `splitminor` keyword controls the number of cuts of a space between ticks when there is no zoom. See also `splitgrid` to control the number of cuts while zooming.
+The `splitgrid` keyword controls the number of cuts for each zoomlevel. The value should be a 
 
 ![keywordexample](Images/splitminor.png)

Images/NFCircles.png

@@ -170,3 +170,119 @@ function rectangular_shape(s = 1e5)
 end
 
 
+
+"""
+    NFCircle(F, Fmin, Γopt, Rn, Zo)
+
+Computes the points of the constant Noise Figure Circle.
+
+- F: noise factor
+- Fmin: minimum noise factor
+- Γopt: optimimum source reflection coefficient related to Zopt or Yopt.
+- Rn: noise resistance parameter
+- Zo: Reference Impedance
+- Np: Number of points
+"""
+function NFCircle(F, Fmin, Γopt, Rn, Zo, Np)
+    N = (F - Fmin)/(4*Rn/Zo) * abs2(1 + Γopt)
+    center = Γopt / (N + 1)
+    rad = sqrt(N*(N+1-abs2(Γopt)))/(N+1)
+    x, y = real(center), imag(center)
+    return [Point2f(rad * cos(th) + x, rad * sin(th) + y) for th in range(-π, π, Np)]
+end
+
+"""
+    CGCircle(gi, Sii)
+
+Computes the points of the Constant Gain Circle.
+
+- gi: It's gsource or gload and it's value is G / Gmax
+- Sii: Reflection S parameter. S11 for Gs and S22 for Gl. 
+- Np: Number of points
+
+"""
+function CGCircle(gi, Sii, Np)
+    center = (gi * conj(Sii)) / (1 - abs2(Sii)*(1 - gi))
+    rad = (sqrt(1-gi) * (1 - abs2(Sii))) / (1 - abs2(Sii)*(1 - gi))
+    x, y = real(center), imag(center)
+    return [Point2f(rad * cos(th) + x, rad * sin(th) + y) for th in range(-π, π, Np)]
+end
+
+# Stability Circunferences
+
+"""
+    StabilityCircle(S11, S12, S21, S22, inout::Symbol, Np; stable = false)
+
+Computes the region of stability (or unstability) and returns a Makie.Polygon.
+
+- Sii: S-parameter
+- inout: a symbol selecting source or load regions. Valid values are :load or :source.
+- Np: Number of points.
+- stable: Selects if the region corresponds to the stable (true) or unstable (false) region.
+"""
+function StabilityCircle(S11, S12, S21, S22, inout::Symbol, Np; stable = false)
+    if inout == :load
+        S11, S22 = S22, S11
+    end
+    Δ =  S11 * S22 - S12 * S21
+    center = conj(S22 - Δ*conj(S11)) / (abs2(S22) - abs2(Δ))
+    rad = abs(S12 * S21) / (abs2(S22) - abs2(Δ))
+    x, y = real(center), imag(center)
+    points = [Point2f(rad * cos(th) + x, rad * sin(th) + y) for th in range(-π, π, Np)]
+    circshape = circular_shape(Np)
+    # Check if:
+    if sqrt(sum(abs2, center)) + rad <= 1  # Stability Circle INSIDE Smith Chart
+        if abs(S11) < 1
+            outpolygon = stable == true ? Makie.Polygon(circshape, [points]) : Makie.Polygon(points)
+        else
+            outpolygon = stable == true ?  Makie.Polygon(points) : Makie.Polygon(circshape, [points])
+        end
+    elseif sqrt(sum(abs2, center)) + 1 <= rad # Smith Chart INSIDE Stability Circle (Unconditionally Stable)
+        outpolygon = stable == true ? Makie.Polygon(circshape) : Makie.Polygon([Point2f(NaN) for _ in 1:3])
+    elseif sqrt(sum(abs2, center)) - rad > 1  # Stability Circle OUTSIDE Smith Chart (Unconditionally Stable)
+        outpolygon = stable == true ? Makie.Polygon(circshape) : Makie.Polygon([Point2f(NaN) for _ in 1:3])
+    else
+        Cr = real(center)
+        Ci = imag(center)
+        #Γi = (k - (Cr * Γr)) / Ci
+        #Γr^2 + (Γi)^2 = 1
+        #Γr^2 + ((k - (Cr * Γr))/Ci)^2 = 1
+        #Ci^2*Γr^2   + k^2 + Cr^2*Γr^2 - 2*k*Cr*Γr - Ci^2 = 0
+        #Ci^2 * Γr^2 + Cr*Γr^2 - 2*k*Cr*Γr - (Ci^2 + k^2) = 0
+        #(Ci^2 + Cr^2) * Γr^2    - 2*k*Cr*Γr  + (-Ci^2 + k^2) = 0
+        k = (Cr^2 + Ci^2 - rad^2 + 1)/2
+        a = (Ci^2 + Cr^2)
+        b = -(2*k*Cr)
+        c = (-Ci^2 + k^2)
+        v = sqrt(b^2-4*a*c)
+        Γr = [(-b + v)/(2*a), (-b - v)/(2*a)]
+        Γi = @. (k - (Cr * Γr)) / Ci
+        P = Point2f.(Γr, Γi)
+        v = map(x -> x - Point2f(Cr, Ci), P)
+        angles_stability = map(x->atan(x[2], x[1]), v)
+        angles_smith = map(x->atan(x[2], x[1]), P)
+        # Case 1: |S11| < 1
+        ids = sortperm(angles_smith)
+        sort!(angles_smith)
+        angles_stability = angles_stability[reverse(ids)]
+        # Case 2: |S11| > 1
+        if ((abs(S11) > 1) & (stable == false)) | ((abs(S11) < 1) & (stable == true))
+            reverse!(angles_smith)
+            reverse!(angles_stability)
+            angles_smith[end] += 2*pi
+        end
+        stability_points = [Point2f(rad * cos(th) + x, rad * sin(th) + y) 
+            for th in range(angles_stability[1], angles_stability[2], Np)]
+        smith_points = [Point2f(cos(th), sin(th)) 
+            for th in range(angles_smith[1], angles_smith[2], Np)]
+        
+        outpolygon = Makie.Polygon(vcat(smith_points, stability_points))
+    end
+
+    return outpolygon
+end
+
+
+
+# Forbidden regions
+