Edit3: ISS Medzinárodná vesmírna stanica, máme tu vysokoenergetické častice, zapnite Hrubošov rotačný štít proti výboju zo slnka: spomalíme ich na štítoch...

https://hrubos.tech/blogy/content/images/20260823121824-ISS_vysoko_energeticke_Stity.png

Edit2: Cestou z kostola ma napadlo, žé ako by mal vyzerať náš hromozvod? Čo, ak teda má rotovať, aby krivil polia za vetra na streche? Pomohla mi ho stvárniť ako tak AI ideogram, popri tejto simulácií z GPT: https://hrubos.tech/simulacie/hromozvod_navrh_11c.mp4

Ak sa pýtate, prečo sú na špirále dielektrické kondenzátorové jednotky, tak tieto tvoria obyčajný kondenzátor zo vzduchu, lebo vzduch je izolant, čiže dielektrikum ako v kondenzátore ^^^

Historici našli takýto disk https://hrubos.tech/blogy/content/images/20260823091253-Snímka obrazovky 2026-08-22 o 20.28.16.png Dodnes nevedia, načo bol?

Napadlo ma, že to bol energetický štít, pohliadnite ako krútil pole nepriateľa. Predstavte si, že ste boli nabitý statickou "zlou" energiou. Stačilo vytiahnuť tento štít a stalo sa?

Toto:

https://hrubos.tech/simulacie/3anteny.mov

https://hrubos.tech/simulacie/3antenyb.mp4

Simulácia energetického štítu poľa mojich príkazov je:

# ============================================================
# ZEM 11
# ANTENNAS11_CAPACITOR.JL
#
# 3 KOHERENTNÉ ANTÉNY — 120°
# ROTUJÚCI TANIER
#
# 3D KOHEERENTNÉ VLNY A INTERFERENCIA
# HORIZONTÁLNE E POLE
# VERTIKÁLNE E POLE
#
# HORNÁ DOSKA KONDENZÁTORA
# PULZUJÚCI ZAKRIVENÝ VÝBOJ ZHORA NADOL
#
# BOČNÝ POHĽAD S MIERNYM NADHĽADOM
# 4K / RETINA / MP4
# ============================================================


# ============================================================
# 0. BALÍKY
# ============================================================

using Pkg

Pkg.add("GLMakie")
Pkg.add("FFMPEG")
Pkg.add("StaticArrays")

using GLMakie
using LinearAlgebra
using StaticArrays
using Printf


# ============================================================
# 1. FYZIKA
# ============================================================

const C0 = 299_792_458.0

const FREQ = 2.4e9

const OMEGA = 2π * FREQ

const LAMBDA = C0 / FREQ

const K = 2π / LAMBDA


# ============================================================
# 2. ANTÉNNY SYSTÉM
# ============================================================

const N_ANTENNAS = 3

const ANGLE_STEP = 2π / 3

const PLATE_RADIUS = 0.35

const ANTENNA_RADIUS = 0.23

const ANTENNA_HEIGHT = 0.18

const ANTENNA_BASE_Z = 0.08


# ============================================================
# 3. SIMULAČNÝ PRIESTOR
# ============================================================

const FIELD_RADIUS = 2.35

const FIELD_Z_MIN = -0.30

const FIELD_Z_MAX = 2.90

const GRID_X = 56

const GRID_Y = 56

const GRID_Z = 34


# ============================================================
# 4. ANIMÁCIA
# ============================================================

const FRAMES = 360

const FPS = 30

const ROTATIONS = 1.0


# ============================================================
# 5. FÁZOVÝ POSUN
#
# 0 = všetky tri antény sú koherentné.
# ============================================================

const PHASE_STEP = 0.0


# ============================================================
# 6. KONDENZÁTOR A VÝBOJ
# ============================================================

const CAPACITOR_Z = 2.45

const CAPACITOR_RADIUS = 0.72

const CAPACITOR_THICKNESS = 0.08

const DISCHARGE_TARGET_Z = ANTENNA_BASE_Z + 0.04

const DISCHARGE_LINES = 42

const DISCHARGE_SEGMENTS = 46

const PARTICLES_PER_LINE = 2

const DISCHARGE_CYCLES = 3.0

const PARTICLE_SPEED = 1.35

const DISCHARGE_BEND = 0.58


# ============================================================
# 7. ANTÉNNA POLOHA
# ============================================================

function antenna_position(index, rotation)

    angle =
        rotation +
        (index - 1) * ANGLE_STEP

    return SVector(
        ANTENNA_RADIUS * cos(angle),
        ANTENNA_RADIUS * sin(angle),
        ANTENNA_BASE_Z
    )
end


# ============================================================
# 8. SMER ANTÉNY
#
# Antény smerujú radiálne von.
# ============================================================

function antenna_direction(index, rotation)

    angle =
        rotation +
        (index - 1) * ANGLE_STEP

    return normalize(
        SVector(
            cos(angle),
            sin(angle),
            0.0
        )
    )
end


# ============================================================
# 9. HORIZONTÁLNA POLARIZÁCIA
#
# Tangenciálny vektor kolmý na radiálny smer.
# ============================================================

function horizontal_polarization(direction)

    return normalize(
        SVector(
            -direction[2],
            direction[1],
            0.0
        )
    )
end


# ============================================================
# 10. JEDNODUCHÝ SMEROVÝ DIAGRAM ANTÉNY
# ============================================================

function antenna_pattern(direction, observation)

    cθ =
        clamp(
            dot(direction, observation),
            -1.0,
            1.0
        )

    if cθ <= 0.0
        return 0.02
    end

    return 0.08 + 0.92 * cθ^5
end


# ============================================================
# 11. KOMPLEXNÉ E POLE
# ============================================================

function electric_field(point, rotation)

    E =
        SVector(
            0.0 + 0im,
            0.0 + 0im,
            0.0 + 0im
        )

    for antenna in 1:N_ANTENNAS

        source =
            antenna_position(
                antenna,
                rotation
            )

        direction =
            antenna_direction(
                antenna,
                rotation
            )

        rvec =
            point -
            source

        r =
            norm(rvec)

        if r < 0.03
            continue
        end

        observation =
            rvec / r

        pattern =
            antenna_pattern(
                direction,
                observation
            )

        # Fyzikálnejší pokles amplitúdy E-poľa.
        amplitude =
            pattern /
            max(r, 0.03)

        source_phase =
            (antenna - 1) *
            PHASE_STEP

        propagation_phase =
            -K * r

        total_phase =
            propagation_phase +
            source_phase

        wave =
            amplitude *
            exp(im * total_phase)

        horizontal =
            horizontal_polarization(
                direction
            )

        vertical =
            SVector(
                0.0,
                0.0,
                0.55
            )

        polarization =
            horizontal +
            vertical

        E +=
            wave *
            polarization
    end

    return E
end


# ============================================================
# 12. INTENZITY ZLOŽIEK
# ============================================================

function horizontal_intensity(E)

    return abs2(E[1]) +
           abs2(E[2])
end


function vertical_intensity(E)

    return abs2(E[3])
end


# ============================================================
# 13. VÝPOČET 3D POĽA
# ============================================================

function calculate_field(rotation)

    X = Float32[]
    Y = Float32[]
    Z = Float32[]

    total = Float32[]
    horizontal = Float32[]
    vertical = Float32[]

    for iz in 1:GRID_Z

        z =
            FIELD_Z_MIN +
            (FIELD_Z_MAX - FIELD_Z_MIN) *
            (iz - 1) /
            (GRID_Z - 1)

        for iy in 1:GRID_Y

            y =
                -FIELD_RADIUS +
                2 * FIELD_RADIUS *
                (iy - 1) /
                (GRID_Y - 1)

            for ix in 1:GRID_X

                x =
                    -FIELD_RADIUS +
                    2 * FIELD_RADIUS *
                    (ix - 1) /
                    (GRID_X - 1)

                rxy =
                    sqrt(
                        x^2 +
                        y^2
                    )

                if rxy > FIELD_RADIUS
                    continue
                end

                point =
                    SVector(
                        x,
                        y,
                        z
                    )

                E =
                    electric_field(
                        point,
                        rotation
                    )

                I =
                    real(
                        sum(
                            abs2.(E)
                        )
                    )

                IH =
                    horizontal_intensity(E)

                IV =
                    vertical_intensity(E)

                push!(X, Float32(x))
                push!(Y, Float32(y))
                push!(Z, Float32(z))

                push!(total, Float32(I))
                push!(horizontal, Float32(IH))
                push!(vertical, Float32(IV))
            end
        end
    end

    return (
        X,
        Y,
        Z,
        total,
        horizontal,
        vertical
    )
end


# ============================================================
# 14. FIGURE
# ============================================================

fig =
    Figure(
        size = (
            800,
            600
        ),
        backgroundcolor = :black
    )


# ============================================================
# 15. 3D OS
# ============================================================

ax =
    Axis3(
        fig[1, 1],
        aspect = :data,
        perspectiveness = 0.72,
        backgroundcolor = :black
    )

hidedecorations!(ax)

hidespines!(ax)

limits!(
    ax,
    -2.05,
    2.05,
    -2.05,
    2.05,
    -0.20,
    2.70
)


# ============================================================
# 16. SPODNÝ ROTUJÚCI TANIER
# ============================================================

θ =
    range(
        0,
        2π,
        length = 300
    )

lines!(
    ax,
    PLATE_RADIUS .* cos.(θ),
    PLATE_RADIUS .* sin.(θ),
    fill(ANTENNA_BASE_Z, length(θ)),
    color = :white,
    linewidth = 10
)

for radius in (
    0.08,
    0.16,
    0.24,
    0.32
)

    lines!(
        ax,
        radius .* cos.(θ),
        radius .* sin.(θ),
        fill(ANTENNA_BASE_Z, length(θ)),
        color = (:white, 0.18),
        linewidth = 2
    )
end


# ============================================================
# 17. HORNÁ DOSKA KONDENZÁTORA
# ============================================================

θ_cap =
    range(
        0,
        2π,
        length = 240
    )

lines!(
    ax,
    CAPACITOR_RADIUS .* cos.(θ_cap),
    CAPACITOR_RADIUS .* sin.(θ_cap),
    fill(CAPACITOR_Z, length(θ_cap)),
    color = :deepskyblue,
    linewidth = 14
)

for radius in (
    0.18,
    0.36,
    0.54,
    0.72
)

    lines!(
        ax,
        radius .* cos.(θ_cap),
        radius .* sin.(θ_cap),
        fill(CAPACITOR_Z, length(θ_cap)),
        color = (:cyan, 0.30),
        linewidth = 3
    )
end

for angle in range(0, 2π, length = 13)[1:end-1]

    x =
        CAPACITOR_RADIUS *
        cos(angle)

    y =
        CAPACITOR_RADIUS *
        sin(angle)

    lines!(
        ax,
        Point3f[
            Point3f(
                x,
                y,
                CAPACITOR_Z - CAPACITOR_THICKNESS
            ),
            Point3f(
                x,
                y,
                CAPACITOR_Z + CAPACITOR_THICKNESS
            )
        ],
        color = (:deepskyblue, 0.65),
        linewidth = 3
    )
end


# ============================================================
# 18. CENTRÁLNA OS
# ============================================================

lines!(
    ax,
    Point3f[
        Point3f(0, 0, FIELD_Z_MIN),
        Point3f(0, 0, CAPACITOR_Z)
    ],
    color = (:yellow, 0.75),
    linewidth = 10
)


# ============================================================
# 19. SMEROVÁ ZNAČKA ROTÁCIE
# ============================================================

rotation_marker =
    Observable(
        Point3f[
            Point3f(0, 0, ANTENNA_BASE_Z),
            Point3f(0.16, 0, ANTENNA_BASE_Z)
        ]
    )

lines!(
    ax,
    rotation_marker,
    color = :orange,
    linewidth = 15
)


# ============================================================
# 20. ANTÉNY
# ============================================================

antenna_lines =
    Observable[]

antenna_tips =
    Observable[]

for i in 1:N_ANTENNAS

    line_obs =
        Observable(
            Point3f[
                Point3f(0, 0, 0),
                Point3f(0, 0, 0)
            ]
        )

    push!(
        antenna_lines,
        line_obs
    )

    lines!(
        ax,
        line_obs,
        color = :orange,
        linewidth = 18
    )

    tip_obs =
        Observable(
            Point3f[
                Point3f(0, 0, 0)
            ]
        )

    push!(
        antenna_tips,
        tip_obs
    )

    scatter!(
        ax,
        tip_obs,
        color = :white,
        markersize = 35
    )
end


# ============================================================
# 21. 3D INTERFERENČNÉ POLE
# ============================================================

field_points =
    Observable(
        Point3f[]
    )

field_values =
    Observable(
        Float32[]
    )

scatter!(
    ax,
    field_points,
    color = field_values,
    colormap = :turbo,
    colorrange = (0, 1),
    markersize = 8,
    transparency = true
)


# ============================================================
# 22. HORIZONTÁLNE VEKTORY E-POĽA
# ============================================================

H_start =
    Observable(
        Point3f[]
    )

H_direction =
    Observable(
        Vec3f[]
    )

arrows3d!(
    ax,
    H_start,
    H_direction,
    color = :cyan,

)


# ============================================================
# 23. VERTIKÁLNE VEKTORY E-POĽA
# ============================================================

V_start =
    Observable(
        Point3f[]
    )

V_direction =
    Observable(
        Vec3f[]
    )

arrows3d!(
    ax,
    V_start,
    V_direction,
    color = :yellow,

)


# ============================================================
# 24. ZAKRIVENÉ KANÁLY VÝBOJA KONDENZÁTORA
# ============================================================

discharge_lines =
    Observable(
        Point3f[]
    )

discharge_colors =
    Observable(
        Float32[]
    )

lines!(
    ax,
    discharge_lines,
    color = discharge_colors,
    colormap = :blues,
    colorrange = (0, 1),
    linewidth = 5,
    transparency = true
)

discharge_particles =
    Observable(
        Point3f[]
    )

scatter!(
    ax,
    discharge_particles,
    color = :white,
    markersize = 16,
    transparency = true
)


# ============================================================
# 25. TEXT
# ============================================================

title_obs =
    Observable(
        "ZEM 11 — ROTUJÚCI KONDENZÁTOR A 3 KOHEERENTNÉ VLNY"
    )

info_obs =
    Observable(
        "CYAN: HORIZONTÁLNE E POLE   •   ŽLTÉ: VERTIKÁLNE E POLE   •   MODRÉ: VÝBOJ KONDENZÁTORA"
    )

phase_obs =
    Observable(
        "ROTÁCIA TANIERA = 0.00°"
    )

Label(
    fig[0, 1],
    title_obs,
    fontsize = 46,
    color = :white
)

Label(
    fig[2, 1],
    info_obs,
    fontsize = 24,
    color = :cyan
)

Label(
    fig[3, 1],
    phase_obs,
    fontsize = 24,
    color = :yellow
)


# ============================================================
# 26. UPDATE ANTÉN
# ============================================================

function update_antennas!(rotation)

    for i in 1:N_ANTENNAS

        p =
            antenna_position(
                i,
                rotation
            )

        top =
            p +
            SVector(
                0.0,
                0.0,
                ANTENNA_HEIGHT
            )

        antenna_lines[i][] =
            Point3f[
                Point3f(p),
                Point3f(top)
            ]

        antenna_tips[i][] =
            Point3f[
                Point3f(top)
            ]
    end

    rotation_marker[] =
        Point3f[
            Point3f(
                0,
                0,
                ANTENNA_BASE_Z
            ),
            Point3f(
                0.16 * cos(rotation),
                0.16 * sin(rotation),
                ANTENNA_BASE_Z
            )
        ]
end


# ============================================================
# 27. UPDATE 3D E-POĽA
# ============================================================

function update_field!(rotation)

    (
        X,
        Y,
        Z,
        I,
        IH,
        IV
    ) =
        calculate_field(rotation)

    maxI =
        max(
            maximum(I),
            1f-12
        )

    total_n =
        I ./ maxI

    horizontal_n =
        IH ./ maxI

    vertical_n =
        IV ./ maxI

    points =
        Point3f[]

    values =
        Float32[]

    for n in eachindex(X)

        q =
            total_n[n]

        if q < 0.05f0
            continue
        end

        push!(
            points,
            Point3f(
                X[n],
                Y[n],
                Z[n]
            )
        )

        push!(
            values,
            q
        )
    end

    field_points[] =
        points

    field_values[] =
        values

    hs =
        Point3f[]

    hd =
        Vec3f[]

    vs =
        Point3f[]

    vd =
        Vec3f[]

    for n in 1:14:length(X)

        q =
            total_n[n]

        if q < 0.40f0
            continue
        end

        x = X[n]
        y = Y[n]
        z = Z[n]

        # Vizualizačné radiálne horizontálne smerovanie.
        rxy =
            sqrt(
                x^2 +
                y^2
            )

        if rxy > 0.05

            hx =
                x / rxy

            hy =
                y / rxy

            hscale =
                0.12 *
                horizontal_n[n]

            push!(
                hs,
                Point3f(x, y, z)
            )

            push!(
                hd,
                Vec3f(
                    hx * hscale,
                    hy * hscale,
                    0.0
                )
            )
        end

        vscale =
            0.13 *
            vertical_n[n]

        push!(
            vs,
            Point3f(x, y, z)
        )

        push!(
            vd,
            Vec3f(
                0.0,
                0.0,
                vscale
            )
        )
    end

    H_start[] =
        hs

    H_direction[] =
        hd

    V_start[] =
        vs

    V_direction[] =
        vd
end


# ============================================================
# 28. UPDATE VÝBOJA KONDENZÁTORA
# ============================================================

function update_capacitor_discharge!(
    rotation,
    frame
)

    line_points =
        Point3f[]

    line_colors =
        Float32[]

    particles =
        Point3f[]

    pulse_phase =
        2π *
        DISCHARGE_CYCLES *
        (frame - 1) /
        FRAMES

    pulse =
        max(
            0.0,
            sin(pulse_phase)
        )^2

    visibility =
        0.08 +
        0.92 * pulse

    for line_index in 1:DISCHARGE_LINES

        θ0 =
            2π *
            (line_index - 1) /
            DISCHARGE_LINES

        radial_layer =
            0.26 +
            0.70 *
            mod(
                7 * line_index,
                DISCHARGE_LINES
            ) /
            DISCHARGE_LINES

        r0 =
            CAPACITOR_RADIUS *
            radial_layer

        x0 =
            r0 *
            cos(θ0)

        y0 =
            r0 *
            sin(θ0)

        z0 =
            CAPACITOR_Z -
            CAPACITOR_THICKNESS

        spiral =
            0.35 *
            sin(
                3 * θ0 -
                rotation
            )

        θ1 =
            θ0 +
            0.55 * rotation +
            spiral

        r1 =
            0.10 +
            0.55 * r0

        x1 =
            r1 *
            cos(θ1)

        y1 =
            r1 *
            sin(θ1)

        z1 =
            DISCHARGE_TARGET_Z

        tangent_x =
            -sin(
                θ0 +
                rotation
            )

        tangent_y =
            cos(
                θ0 +
                rotation
            )

        channel_phase =
            2π *
            line_index /
            DISCHARGE_LINES

        for segment in 0:DISCHARGE_SEGMENTS

            t =
                segment /
                DISCHARGE_SEGMENTS

            bend_envelope =
                sin(π * t)

            swirl =
                DISCHARGE_BEND *
                bend_envelope *
                (
                    0.35 +
                    0.65 * pulse
                ) *
                sin(
                    2π * t +
                    channel_phase +
                    1.5 * rotation
                )

            twist =
                0.22 *
                bend_envelope *
                sin(
                    3π * t +
                    channel_phase -
                    rotation
                )

            x =
                (1 - t) * x0 +
                t * x1 +
                swirl * tangent_x +
                twist * cos(θ0)

            y =
                (1 - t) * y0 +
                t * y1 +
                swirl * tangent_y +
                twist * sin(θ0)

            z =
                (1 - t) * z0 +
                t * z1

            push!(
                line_points,
                Point3f(x, y, z)
            )

            brightness =
                visibility *
                (
                    0.20 +
                    0.80 *
                    sin(π * t)^1.5
                )

            push!(
                line_colors,
                Float32(brightness)
            )
        end

        # Prerušenie medzi jednotlivými výbojovými kanálmi.
        push!(
            line_points,
            Point3f(NaN, NaN, NaN)
        )

        push!(
            line_colors,
            Float32(0)
        )

        # Pohybujúce sa častice zhora nadol.
        for particle in 1:PARTICLES_PER_LINE

            t =
                mod(
                    PARTICLE_SPEED *
                    (frame - 1) /
                    FRAMES +
                    0.37 * particle +
                    line_index /
                    DISCHARGE_LINES,
                    1.0
                )

            bend_envelope =
                sin(π * t)

            swirl =
                DISCHARGE_BEND *
                bend_envelope *
                (
                    0.35 +
                    0.65 * pulse
                ) *
                sin(
                    2π * t +
                    channel_phase +
                    1.5 * rotation
                )

            twist =
                0.22 *
                bend_envelope *
                sin(
                    3π * t +
                    channel_phase -
                    rotation
                )

            px =
                (1 - t) * x0 +
                t * x1 +
                swirl * tangent_x +
                twist * cos(θ0)

            py =
                (1 - t) * y0 +
                t * y1 +
                swirl * tangent_y +
                twist * sin(θ0)

            pz =
                (1 - t) * z0 +
                t * z1

            push!(
                particles,
                Point3f(px, py, pz)
            )
        end
    end

    discharge_lines[] =
        line_points

    discharge_colors[] =
        line_colors

    discharge_particles[] =
        particles
end


# ============================================================
# 29. PRVÝ VÝPOČET
# ============================================================

println()

println(
    "Pripravujem prvé 3D pole..."
)

@time update_antennas!(0.0)

@time update_field!(0.0)

@time update_capacitor_discharge!(0.0, 1)


# ============================================================
# 30. KAMERA
#
# Bočný pohľad s miernym nadhľadom.
# ============================================================

ax.azimuth[] =
    1.38π

ax.elevation[] =
    0.10π


# ============================================================
# 31. INFO
# ============================================================

println()

println(
    "============================================================"
)

println(
    " ZEM 11 — ROTUJÚCI KONDENZÁTOR"
)

println(
    "============================================================"
)

@printf(
    "Frekvencia: %.3f GHz\n",
    FREQ / 1e9
)

@printf(
    "Vlnová dĺžka: %.4f m\n",
    LAMBDA
)

@printf(
    "Vlnové číslo: %.4f rad/m\n",
    K
)

println(
    "Antény: 3"
)

println(
    "Rozostup: 120°"
)

println(
    "Výbojové kanály: $(DISCHARGE_LINES)"
)

println(
    "Rozlíšenie: 5120 × 2880"
)

println(
    "FPS: $(FPS)"
)

println(
    "Frames: $(FRAMES)"
)

println(
    "============================================================"
)

println()


# ============================================================
# 32. MP4 EXPORT
# ============================================================

const OUTPUT_FILE =
    "c_rotujuci_kondenzator_3D_vyboj_4K.mp4"

record(
    fig,
    OUTPUT_FILE,
    1:FRAMES;
    framerate = FPS,
    compression = 16,
    profile = "high",
    pixel_format = "yuv420p"
) do frame

    rotation =
        2π *
        ROTATIONS *
        (frame - 1) /
        FRAMES

    update_antennas!(
        rotation
    )

    update_field!(
        rotation
    )

    update_capacitor_discharge!(
        rotation,
        frame
    )

    degrees =
        rotation *
        180 /
        π

    phase_obs[] =
        @sprintf(
            "ROTÁCIA TANIERA = %7.2f°     |     PULZUJÚCI VÝBOJ KONDENZÁTORA ZHORA NADOL",
            degrees
        )

    ax.azimuth[] =
        1.38π +
        0.06 *
        sin(rotation)

    ax.elevation[] =
        0.10π +
        0.012 *
        sin(2 * rotation)
end


println()

println(
    "============================================================"
)

println(
    " HOTOVO"
)

println(
    "============================================================"
)

println(
    OUTPUT_FILE
)

println()

---