---
id: model-03
title: "Distributed Model Theory"
section: "Advanced Modeling"
difficulty: "advanced"
estimated_time: 40
prerequisites: ["model-01", "model-02"]
objectives:
  - Understand when and why distributed models are necessary
  - Master nth-order segmentation strategy and circuit topology
  - Learn the trade-offs between lumped and distributed approaches
  - Apply distributed models to long sparks and research applications
tags: ["distributed-model", "segmentation", "nth-order", "circuit-topology"]
---

# Distributed Model Theory

The **distributed spark model** divides the spark into multiple segments, each with its own resistance and capacitance network. This captures spatial variations in current, voltage, and plasma properties along the spark length.

## Why Distributed Models?

### Limitations of Lumped Models

Lumped models treat the entire spark as a single element, which **fails to capture:**

**1. Current distribution along spark**
```
Base: Full current (directly coupled to topload)
Middle: Reduced current (capacitive shunting)
Tip: Much lower current (weak coupling, high shunt)

Lumped model: Assumes uniform current everywhere (wrong!)
```

**2. Voltage distribution**
```
Actual: Non-linear voltage drop due to distributed capacitance
Lumped: Assumes simple voltage divider (oversimplified)

Capacitive divider effects occur at EACH point along spark
```

**3. Base vs tip physical differences**
```
Base properties:
- Hot plasma (continuously heated)
- Well-coupled to topload
- Low resistance (leader regime)
- High current density

Tip properties:
- Cool plasma (sporadic heating)
- Weakly coupled
- High resistance (streamer regime)
- Low current density

Lumped model: Single R averages this out (loses physics!)
```

**4. Leader/streamer transitions**
```
Long sparks: Base forms leader, tip remains streamer
Different physics: Different R, different behavior
Lumped R: Cannot represent this transition zone
```

**5. Very long sparks (>3 m)**
```
Distributed effects dominate
Single lumped R is poor approximation
Error: Can be factor of 2-5 in current distribution
```

### When to Use Distributed Models

**Use distributed when:**

1. **Spark length > 1-2 meters**
   - Spatial variations become significant
   - Base-to-tip differences critical

2. **Current distribution matters**
   - Measuring actual current profile along spark
   - Validating against detailed experimental data
   - Understanding leader formation dynamics

3. **Research applications**
   - Physics investigations
   - Leader/streamer transition studies
   - Publication-quality results

4. **Extreme parameters**
   - Very low frequency (λ comparable to L)
   - Very high voltage (breakdown physics critical)
   - Unusual geometries (horizontal, branched)

**Stick with lumped when:**

1. **Quick design iterations**
   - Impedance matching studies
   - Component selection
   - Performance estimates

2. **Short sparks (<1 m)**
   - Uniform properties adequate
   - Computational efficiency critical

3. **Engineering estimates**
   - ±20% accuracy sufficient
   - Fast turnaround needed

**Computational trade-off:**
```
Lumped model: <1 second
Distributed (n=10): ~10-30 seconds
Distributed (n=20): ~1-5 minutes

Speedup factor: 600-18000×

Use distributed only when benefits justify cost!
```

## Segmentation Strategy

### Dividing the Spark

**Equal-length segments:**
```
n = number of segments (typically 5-20)
L_segment = L_total / n

Segment numbering:
  i = 1: Base (connected to topload)
  i = 2, 3, ..., n-1: Middle sections
  i = n: Tip (furthest from topload)
```

**Example: 2.4 m spark, n=6 segments**
```
L_segment = 2.4 / 6 = 0.4 m each

Segment 1 (base): z = 0 to -0.4 m
Segment 2: z = -0.4 to -0.8 m
Segment 3: z = -0.8 to -1.2 m
Segment 4: z = -1.2 to -1.6 m
Segment 5: z = -1.6 to -2.0 m
Segment 6 (tip): z = -2.0 to -2.4 m
```

### Why Equal Lengths?

**Advantages:**
```
1. Simple FEMM geometry
   - Uniform cylinder sections
   - Easy to script/automate

2. Uniform discretization
   - No bias toward any region
   - Straightforward convergence analysis

3. Easy implementation
   - Regular array indexing
   - Simple matrix structure

4. Standard practice
   - Literature comparisons
   - Validated approach
```

**Non-uniform segmentation possible:**
```
Alternative: Finer near tip (where R changes rapidly)

Example: Geometric progression
  L[i] = L_base × ratio^(i-1)

Benefits: Better captures tip physics with fewer segments

Drawbacks:
  - More complex FEMM setup
  - Harder to interpret results
  - Diminishing returns for extra complexity

Recommendation: Use equal lengths unless specific research need
```

### Choosing n (Number of Segments)

**Convergence vs computational cost:**

```
n = 1: Lumped model (fastest, least accurate for long sparks)
n = 5: Coarse distributed (captures main trends)
n = 10: Standard distributed (good balance)
n = 20: Fine distributed (research quality)
n = 50: Overkill (no improvement, much slower)
```

**Rule of thumb:**
```
L < 1 m: Use lumped (n=1)
L = 1-2 m: n = 5-10
L = 2-4 m: n = 10-15
L > 4 m: n = 15-20

Convergence test: Double n, check if results change <10%
If yes: Original n sufficient
If no: Use higher n
```

**Practical limitations:**
```
FEMM: (n+1)×(n+1) matrix, scales as O(n²)
SPICE: Network complexity, scales as O(n²-n³)
Optimization: R sweep, scales as O(n)

Total time ≈ t_FEMM × n² + t_SPICE × n² + t_optimize × n

Diminishing returns beyond n ≈ 20
```

## Circuit Topology

### Per-Segment Components

**Each segment i has:**

**1. Resistance R[i]**
```
Physical meaning: Plasma resistance of that segment
Units: Ohms (typically kΩ to MΩ)
Variable: To be optimized
Expectation: Monotonically increasing from base to tip
```

**2. Mutual capacitances C[i,j]**
```
Coupling to:
  - Topload (j=0)
  - All other segments (j=1 to n, j≠i)

Extracted from FEMM (n+1)×(n+1) matrix

Expectation:
  - Stronger coupling to nearby segments
  - Weaker coupling to distant segments
  - C[i,j] decreases with |i-j|
```

**3. Shunt capacitance to ground**
```
Included in capacitance matrix diagonal
NOT a separate component in circuit

C[i,i] (diagonal) represents self-capacitance
Includes ground coupling implicitly
```

### Network Structure

**Full distributed network:**

```
Topload (node 0, V_top)
   |
   +---[C[0,1]]---+
   |              |
   +---[C[0,2]]---|---+
   |              |   |
   +---[C[0,3]]---|---|---+
   |              |   |   |
   ...            |   |   |
                  |   |   |
                [R[1]] |   |
                  |   |   |
              Node 1  |   |
                  |   |   |
              [C[1,2]]|   |
              [C[1,3]]|---|
                  |   |   |
                [R[2]] |   |
                  |   |   |
              Node 2  |   |
                  |   |   |
              [C[2,3]]|---|
                  |   |   |
                [R[3]] |   |
                  |   |   |
              Node 3  |   |
                  |   |   |
                  |   |   |
                 GND GND GND
                 (implicit in C matrix)
```

**Matrix representation:**
```
For n=3 segments + topload (4×4 matrix):

         [0]    [1]    [2]    [3]
[0]  [  C₀₀    C₀₁    C₀₂    C₀₃  ]  Topload
[1]  [  C₁₀    C₁₁    C₁₂    C₁₃  ]  Segment 1 (base)
[2]  [  C₂₀    C₂₁    C₂₂    C₂₃  ]  Segment 2
[3]  [  C₃₀    C₃₁    C₃₂    C₃₃  ]  Segment 3 (tip)

Plus resistances:
R[1], R[2], R[3] (one per segment)

Total unknowns: 3 R values (n in general)
```

### Complexity Analysis

**For n segments:**
```
Capacitance matrix: (n+1)×(n+1) = n² + 2n + 1 elements
Due to symmetry: (n+1)(n+2)/2 unique values

Resistances: n values

Circuit nodes: n+1 (including topload)

SPICE equations: O(n²) for capacitance network
                 O(n) for resistances

Total complexity: O(n²) dominated by capacitance couplings
```

## Physical Expectations

### Resistance Distribution

**Expected profile:**
```
R[1] < R[2] < R[3] < ... < R[n]

Monotonically increasing from base to tip
```

**Typical values at 200 kHz:**
```
Base (segment 1):
  R[1] ≈ 5-20 kΩ
  Hot leader, well-coupled
  High current, low resistance

Middle (segments 2 to n-1):
  R[i] ≈ 10-100 kΩ
  Transition region
  Moderate coupling

Tip (segment n):
  R[n] ≈ 100 kΩ - 10 MΩ
  Cool streamer, weakly coupled
  Low current, high resistance
```

**Total resistance:**
```
R_total = Σ R[i]

Expected: 50-500 kΩ at 200 kHz for 2-3 m spark

Compare to lumped: Should be similar order of magnitude
If factor >5 different: Check model carefully
```

### Capacitance Patterns

**Mutual capacitance C[i,j] (i≠j):**
```
Nearby segments: Larger |C[i,j]|
  Example: |C[2,3]| > |C[2,5]|

Distant segments: Smaller |C[i,j]|
  Example: |C[1,10]| << |C[1,2]|

Topload coupling: Decreases with distance
  |C[0,1]| > |C[0,2]| > ... > |C[0,n]|
```

**Self-capacitance C[i,i] (diagonal):**
```
Positive (always)
Includes shunt to ground
Typically: 5-15 pF per segment

Total shunt: Σᵢ (C[i,i] - |C[i,0]|) ≈ 2 pF/ft × L_total
(Approximate, factor of 2-3 variation acceptable)
```

### Current Distribution

**Expected behavior:**
```
|I[1]| > |I[2]| > ... > |I[n]|

Current decreases from base to tip
```

**Physical reason:**
```
Capacitive shunting at each segment:
- Some current diverts to ground through C_sh
- Less current reaches next segment
- Accumulates along spark length

Weak coupling at tip:
- High R, low current naturally
- Capacitive shunting reduces current further
- Tip current can be 10-50× lower than base
```

**Validation:**
```
After simulation, plot I[i] vs position
Should be monotonically decreasing
If not: Check R distribution, C matrix
```

### Voltage Distribution

**Expected behavior:**
```
V[1] > V[2] > ... > V[n]

Voltage decreases from base to tip
```

**But NOT linear!**
```
Simple resistor chain: ΔV = I × R (linear)

Distributed spark: Capacitive divider at each point
  - Voltage "leaks" to ground through shunt capacitance
  - Non-linear profile
  - Steeper drop near base (high current)
  - Flatter near tip (low current)
```

## Lumped vs Distributed Comparison

### Equivalent Impedance

**Both models should give similar Z_spark at topload:**
```
Lumped: Z = R + 1/(jωC_total)
Distributed: Z = [complex network impedance]

At topload port, similar order of magnitude
Difference: Typically 10-30% for well-designed models
```

**If very different (factor >2):**
```
Check:
1. Total resistance: Σ R[i] vs R_lumped
2. Total capacitance: C_total_distributed vs C_mut + C_sh
3. Matrix extraction errors
4. Convergence of n (try higher n)
```

### Power Dissipation

**Lumped:**
```
P_total = 0.5 × I² × R

Single power value
```

**Distributed:**
```
P[i] = 0.5 × I[i]² × R[i]
P_total = Σ P[i]

Can see where power is dissipated:
- Base: High current, moderate R → high power
- Middle: Moderate current and R → moderate power
- Tip: Low current, high R → low power (often <10% of base)
```

**Insight from distributed model:**
```
Most power dissipated in base 1/3 of spark
Tip contributes little to total power
But tip electric field critical for growth!

This explains why:
- Short sparks easier (more efficient power coupling)
- Long sparks harder (tip poorly coupled)
- QCW benefits (maintains hot base channel)
```

## Worked Example: 3-Segment Model

**Given:**
- Total spark: 1.5 m
- Divide into n = 3 equal segments
- Each segment: 0.5 m

**Segment locations:**
```
Segment 1 (base): z = 0 to -0.5 m
Segment 2 (middle): z = -0.5 to -1.0 m
Segment 3 (tip): z = -1.0 to -1.5 m
```

**Expected capacitance matrix (example values):**
```
         [0]     [1]     [2]     [3]
[0]  [  30.0    -9.0    -3.5    -1.5  ]  pF
[1]  [  -9.0    14.0    -3.0    -1.0  ]
[2]  [  -3.5    -3.0    10.5    -2.5  ]
[3]  [  -1.5    -1.0    -2.5     8.0  ]

Properties:
✓ Symmetric
✓ Diagonal positive
✓ Off-diagonal negative
✓ Nearby segments more strongly coupled
```

**Expected resistance distribution:**
```
R[1] = 30 kΩ   (base, hot)
R[2] = 60 kΩ   (middle, moderate)
R[3] = 150 kΩ  (tip, cool)

Total: 240 kΩ

Monotonically increasing ✓
```

**Circuit implementation:**
```
Convert capacitance matrix to SPICE (see next lesson)
Add resistances R[1], R[2], R[3]
Simulate to get currents and voltages
```

**Expected results (qualitative):**
```
If V_topload = 1 V (test):

I[1] ≈ 15 μA   (base current)
I[2] ≈ 8 μA    (middle current, ~50% of base)
I[3] ≈ 3 μA    (tip current, ~20% of base)

V[1] ≈ 0.8 V   (base voltage)
V[2] ≈ 0.5 V   (middle voltage)
V[3] ≈ 0.2 V   (tip voltage, non-linear drop!)

P[1] ≈ 7 μW    (base power, 50% of total)
P[2] ≈ 4 μW    (middle power, 30%)
P[3] ≈ 3 μW    (tip power, 20%)
```

## Key Takeaways

- **Distributed models** divide spark into n segments, capturing spatial variations in current, voltage, and resistance
- **Use when:** sparks >2 m, current distribution needed, research applications, extreme parameters
- **Segmentation:** equal-length segments, n = 5-20 typical, convergence test by doubling n
- **Circuit topology:** (n+1)×(n+1) capacitance matrix plus n resistances, O(n²) complexity
- **Physical expectations:** R monotonically increasing, current decreasing, voltage non-linear, power concentrated at base
- **Trade-off:** 1000-2000× slower than lumped, use only when benefits justify computational cost
- **Validation:** Compare to lumped model (similar Z_spark), check physical trends (I, V, R distributions)
- **Next steps:** FEMM extraction for n-segment geometry (Lesson 4), resistance optimization (Lesson 5)

## Practice

{exercise:model-ex-03}

---
**Next Lesson:** [FEMM Extraction for Distributed Models](04-femm-extraction-distributed.md)