### What this code does: The provided code implements **Jacobi's iterative...

January 2, 2025 at 03:20 PM

using CUDA

# Jacobi metoda
function jacobi_solver_kernel!(G, B, X, X_new, n)
    i = threadIdx().x + (blockIdx().x - 1) * blockDim().x
    if i <= n
        sum = B[i]
        for j in 1:n
            if j != i
                sum -= G[(i-1) * n + j] * X[j]
            end
        end
        X_new[i] = sum / G[(i-1) * n + i]
    end
    return
end

# Glavna funkcija za analizu DC tokova snaga
function dc_power_flow_analysis(G, B, X, n, iterations)
    # Kopiranje podataka na GPU
    d_G = CuArray(G)
    d_B = CuArray(B)
    d_X = CuArray(X)
    d_X_new = CuArray(zeros(n))

    # Definisanje CUDA mreže
    threads_per_block = 256
    blocks = cld(n, threads_per_block)

    for iter in 1:iterations
        @cuda threads=threads_per_block blocks=blocks jacobi_solver_kernel!(d_G, d_B, d_X, d_X_new, n)
        CUDA.copyto!(d_X, d_X_new)
    end

    X_result = Array(d_X)
    return X_result
end

function main()
    n = 3 # Broj čvorova
    G = [ 4.0 -1.0 -1.0; 
         -1.0  3.0 -1.0; 
         -1.0 -1.0  3.0 ] |> vec # Matrica admitansi
    B = [1.0, 0.0, -1.0]
    X = [0.0, 0.0, 0.0] 
    iterations = 100

    result = dc_power_flow_analysis(G, B, X, n, iterations)

    println("Rezultati:")
    for i in 1:n
        println("V[$i] = $(result[i])")
    end
end

main()

What this code does:

The provided code implements Jacobi's iterative method on the GPU (using CUDA) for solving a specific type of linear equation system. Specifically, it is used to calculate the Direct Current (DC) power flow in electrical circuits modeled by nodal admittance matrices.

Here’s a detailed breakdown:

1. Kernel Function (`jacobi_solver_kernel!`)

This is a CUDA kernel designed to compute a single Jacobi iteration for the system ( G \cdot X = B ), where:

( G ) is the nodal admittance matrix (the coefficient matrix).
( B ) is the vector of constants (external current injections or power demands).
( X ) is the solution vector (e.g., voltage at nodes in a grid).

The function performs the Jacobi update on the GPU:

Each thread processes a specific row of the system (if relevant based on the thread's index).
For each row, it calculates the new ( X[i] ): [ X[i]{\text{new}} = \frac{B[i] - \sum{j \neq i} G[i, j] \cdot X[j]}{G[i, i]} ]
- Here, ( G ) is indexed as a flattened array (1D), and ( G[i, j] ) is accessed as G[(i-1)*n + j].

2. Main Functionality (`dc_power_flow_analysis`)

This function orchestrates the DC power flow analysis and the iterative Jacobi solver:

The primary inputs are:
- ( G ): Nodal admittance matrix (flattened for GPU computation).
- ( B ): Constants vector (right-hand side of the equation).
- ( X ): Initial solution guess (usually zeros).
- ( n ): Number of nodes.
- iterations: Maximum number of Jacobi iterations to perform.

Data Transfer to GPU:
- The ( G ), ( B ), and ( X ) arrays are copied to GPU memory via CuArray.
CUDA Kernel Execution:
- The kernel is launched repeatedly (iterations times) using a CUDA grid specified by:
  - threads_per_block: Number of threads per block.
  - blocks: Number of thread blocks.
Copying Results Back from GPU:
- The updated solution ( X ) is copied back to the CPU after each iteration.
Output:
- After the final iteration, the solution ( X ) is converted back to a CPU array and returned.

3. Main Program Execution (`main`)

This section provides a specific example setup for analyzing a 3-node DC grid:

The nodal admittance matrix ( G ): [ G = \begin{bmatrix} 4 & -1 & -1 \ -1 & 3 & -1 \ -1 & -1 & 3 \end{bmatrix} ] This models the connections and properties of the grid.
The ( B ) vector:
- Describes external current injections or net power consumption: ( B = [1.0, 0.0, -1.0] ).
The initial ( X ) vector (guesses): Initialized as zeros.

Finally, it prints the resulting node voltages ( V[i] ).

Purpose

This CUDA-based code solves the linear problem ( G \cdot X = B ) using Jacobi iteration and computes the DC power flow in an electrical network iteratively for a given number of iterations. It leverages GPU acceleration to perform the updates in parallel for all rows.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr

### What this code does: The provided code implements **Jacobi's iterative...