# Charge Curve Isolation Operation

Izolarea porţiunii relevante a curbei de încărcare: eliminarea zgomotului pre/post-charging.

## Responsabilități

- Detectarea punctului de start real al încărcării (0 watts baseline)

- Detectarea punctului de end real al încărcării (100% sau limit)

- Eliminarea zgomotului (ambient AC, meter offset)

- Determinarea timpului efectiv de charging

## Problema

**Raw data from meter:**

```

00:00 - 0.0W (pre-charge noise)

00:30 - 0.5W (background draw)

01:00 - 15.0W ← REAL START

01:30 - 18.5W

02:00 - 16.2W

...

05:00 - 2.5W (charging optimizer active)

05:30 - 1.0W

06:00 - 0.2W ← REAL END

06:15 - 0.0W (post-charge, device removed)

```

**Sarcini:**

1. Find real start (@ 01:00)

2. Find real end (@ 06:00)

3. Extract interval [01:00, 06:00]

4. Ignore pre/post noise

## Invarianţi

- **MUST**: `real_start_time > measurement_start_time` (or equal)

- **MUST**: `real_end_time <= measurement_end_time` (or equal)

- **MUST**: `real_start < real_end`

- **MUST**: Threshold determination trebuie consistent (nu random)

- **SHOULD**: Isolated curve ≥ 90% din total recorded measurements

- **MAY**: Isolated curve poate fi < 10% din total (very short charge)

## Detection algorithm

### Power threshold method

```swift

func findChargeStart(measurements: [Measurement]) -> Int? {

    let powerThreshold = 5.0 // Watts

    let minConsecutive = 3 // Measure must sustain > threshold for 3 samples

    var sustainCount = 0

    for (i, measurement) in measurements.enumerated() {

        if measurement.power > powerThreshold {

            sustainCount += 1

            if sustainCount >= minConsecutive {

                return i - minConsecutive + 1

            }

        } else {

            sustainCount = 0

        }

    }

    return nil

}

func findChargeEnd(measurements: [Measurement]) -> Int? {

    let powerThreshold = 1.0 // Watts (lower at end, trickle charge)

    let minConsecutive = 5 // Stay below threshold for 5 samples

    var sustainCount = 0

    for i in stride(from: measurements.count - 1, through: 0, by: -1) {

        let measurement = measurements[i]

        if measurement.power < powerThreshold {

            sustainCount += 1

            if sustainCount >= minConsecutive {

                return i + 1

            }

        } else {

            sustainCount = 0

        }

    }

    return nil

}

```

**Thresholds:**

- Start: 5W (must exceed noise level)

- End: 1W (lower, allows trickle detection)

- Sustain: 3 samples @start, 5 @end (hysteresis)

### Battery level method (fallback)

Dacă dispositiv raportează procent:

```swift

func findChargeStartByBattery(measurements: [Measurement]) -> Int? {

    // Find first battery level jump

    for i in 1..<measurements.count {

        let prev = measurements[i-1]

        let curr = measurements[i]

        let batteryChange = (curr.batteryPercent ?? 0) - (prev.batteryPercent ?? 0)

        if batteryChange > 1.0 {  // >1% jump = real charge

            return i - 1

        }

    }

    return nil

}

func findChargeEndByBattery(measurements: [Measurement]) -> Int? {

    // Find last battery level change

    for i in stride(from: measurements.count - 1, through: 1, by: -1) {

        let prev = measurements[i-1]

        let curr = measurements[i]

        let batteryChange = (curr.batteryPercent ?? 0) - (prev.batteryPercent ?? 0)

        if batteryChange > 0.5 {  // Still charging

            return i

        }

    }

    return nil

}

```

### Combined method (best)

```swift

func isolateChargeRange(measurements: [Measurement]) -> (start: Int, end: Int)? {

    // Primary: use power threshold

    guard var start = findChargeStart(measurements: measurements),

          var end = findChargeEnd(measurements: measurements) else {

        // Fallback: use battery level

        guard var start = findChargeStartByBattery(measurements: measurements),

              var end = findChargeEndByBattery(measurements: measurements) else {

            return nil

        }

        return (start, end)

    }

    // Validate result

    guard start < end && (end - start) >= 10 else {

        return nil  // Too short (< 10 seconds @ 1Hz)

    }

    return (start, end)

}

```

## API Public

### Metode

```swift

// Detection

func findChargeStart(measurements: [Measurement]) -> Int?

func findChargeEnd(measurements: [Measurement]) -> Int?

func isolateChargeRange(measurements: [Measurement]) -> (start: Int, end: Int)?

// Extraction

func extractIsolatedCurve(measurements: [Measurement])

    -> [Measurement]?

// Validation

func isValidChargeRange(start: Int, end: Int, total: Int) -> Bool

func estimateNoisePercentage(measurements: [Measurement]) -> Double

```

### Rezultat

```swift

struct IsolatedChargeData {

    let originalMeasurements: [Measurement]

    let isolatedMeasurements: [Measurement]

    let startIndex: Int

    let endIndex: Int

    let realStartTime: Date

    let realEndTime: Date

    let noisePercentagePre: Double

    let noisePercentagePost: Double

    var effectiveChargeTime: TimeInterval {

        realEndTime.timeIntervalSince(realStartTime)

    }

}

```

## Comportamente critice

### Threshold sensitivity

**Problem: threshold prea mare**

```

Threshold: 10W

Reality: charger 12W on iPhone 15

Result: detectează corect ✓

But: low-power charger 5W → missed (fails)

```

**Problem: threshold prea mic**

```

Threshold: 0.5W

Reality: background AC noise 1.5W

Result: detectează noise, invalid start (fails)

```

**Solution:** Adaptive threshold:

```swift

let baselineNoise = measurements.prefix(10).map { $0.power }.max() ?? 0

let powerThreshold = baselineNoise * 1.5 + 2.0  // 50% margin + 2W

```

### Short charges

```

Charge duration: 30 seconds (e.g., quick top-up)

Measurements: 30 samples @ 1Hz

Noise isolation: 3 samples start + 5 samples end = 8 samples

Remaining: 22 samples (73% valid)

⟹ Valid

```

**SHOULD**: Accept short charges

**MUST**: Still isolate pre/post

### Noisy environment

```

Pre-charge noise: 2W baseline (poor outlet)

Charge power: 18W

Power jump: 16W (obvious)

⟹ Easy to detect

Vs.

Pre-charge noise: 8W (strong interference)

Charge power: 10W

Power jump: 2W (ambiguous!)

⟹ Hard, need fallback (battery level)

```

**SHOULD**: Use combined method (power + battery)

**MUST**: Fall back if ambiguous

### Charging profile changes

```

Curve:

- 0-1h: 20W (fast charge phase)

- 1-2h: 10W (medium phase)

- 2-3h: 3W (taper phase)

- 3h+: 0.5W (trickle/done)

Isolated region: 0h-3h (valid)

Threshold: 1W (catches all phases)

⟹ Correct

```

**MUST**: Detect end even with tapering

## Testare

### Unit tests

```swift

test_findChargeStart_ValidThreshold()

test_findChargeStart_NoiseIgnored()

test_findChargeEnd_ValidThreshold()

test_findChargeEnd_WithTrickleCharge()

test_isolateChargeRange_ValidData()

test_isolateChargeRange_TooShortIgnored()

test_isolateChargeRange_HighNoise_FallbackToBattery()

test_isValidChargeRange_StartBeforeEnd()

test_isValidChargeRange_MinimumDuration()

test_estimateNoisePercentage()

test_extractIsolatedCurve_PreservesMeasurements()

```

### Integration tests

- [ ] Raw data: 6h recording, 15 min real charge → correctly isolated

- [ ] High pre-charge noise (8W) → still detected

- [ ] Low power charger (5W) → detected

- [ ] Multiple charge phases → end detected at trickle

- [ ] Isolated curve used for energy calculation

## Edge cases

### No charge (meter ON, device not charging)

```

Measurements: all ~0W

Start detection: fails (no power jump)

End detection: fails (no charging detected)

Result: (nil, nil)

⟹ Skip session (valid, no charging occurred)

```

**MUST**: Handle gracefully

### Meter added after charge started

```

Recording: 03:00-07:00 (4 hours)

Real charge: 01:00-06:00 (5 hours, but missed first 2h)

Measurements: 10W constant (already in charge phase)

Start: 03:00 (best guess)

End: 06:00 (detected from power drop)

⟹ Partial isolation OK

```

**SHOULD**: Use what data we have

**MAY**: Mark as "incomplete start"

### USB power delivery with negotiation

```

Time 00:00: Meter ON, no device

Time 00:10: Device plugged in, negotiation 100ms

Time 00:12: Charging starts (power jump 20W)

Samples: ?, ?, [19.5W, 19.8W, ...] ← isolated start

⟹ Correct

```

**SHOULD**: OK, negotiation time negligible

## Dependencies

- [Charging Monitoring](./ChargingMonitoring.md): input measurements

- [Charge Curve Storage](./ChargeCurveStorage.md): store isolated data

- Core Data: battery levels (fallback)

## Notes

- Power threshold: device/charger dependent, may need tuning

- Battery level fallback: only if power method ambiguous

- Resolution: 1Hz (1000ms), ~1W precision typical

- Legat: [Charge Session Integrity](../Charge%20Session%20Integrity%20and%20Conflict%20Healing.md)