mirror of
https://github.com/acamarata/nrel-spa-dart.git
synced 2026-06-30 19:04:24 +00:00
573 lines
18 KiB
Dart
573 lines
18 KiB
Dart
import 'package:nrel_spa/nrel_spa.dart';
|
||
import 'package:test/test.dart';
|
||
|
||
void main() {
|
||
// ─── formatTime ─────────────────────────────────────────────────────────────
|
||
|
||
group('formatTime', () {
|
||
test('formats basic time correctly', () {
|
||
expect(formatTime(12.5), equals('12:30:00'));
|
||
expect(formatTime(0.0), equals('00:00:00'));
|
||
expect(formatTime(23.9997), equals('23:59:59'));
|
||
});
|
||
|
||
test('returns N/A for non-finite values', () {
|
||
expect(formatTime(double.nan), equals('N/A'));
|
||
expect(formatTime(double.infinity), equals('N/A'));
|
||
expect(formatTime(double.negativeInfinity), equals('N/A'));
|
||
});
|
||
|
||
test('returns N/A for negative values', () {
|
||
expect(formatTime(-1.0), equals('N/A'));
|
||
expect(formatTime(-0.001), equals('N/A'));
|
||
});
|
||
|
||
test('wraps at 24h boundary', () {
|
||
// 24.0 hours should wrap to 00:00:00
|
||
expect(formatTime(24.0), equals('00:00:00'));
|
||
});
|
||
|
||
test('pads hours, minutes, seconds with leading zeros', () {
|
||
expect(formatTime(6.0 + 5.0 / 60 + 3.0 / 3600), equals('06:05:03'));
|
||
});
|
||
});
|
||
|
||
// ─── function code constants ─────────────────────────────────────────────────
|
||
|
||
group('function code constants', () {
|
||
test('spaZa = 0', () => expect(spaZa, equals(0)));
|
||
test('spaZaInc = 1', () => expect(spaZaInc, equals(1)));
|
||
test('spaZaRts = 2', () => expect(spaZaRts, equals(2)));
|
||
test('spaAll = 3', () => expect(spaAll, equals(3)));
|
||
});
|
||
|
||
// ─── getSpa — basic functionality ───────────────────────────────────────────
|
||
|
||
group('getSpa — basic functionality', () {
|
||
test('returns valid zenith and azimuth', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect(result.zenith, inInclusiveRange(0.0, 180.0));
|
||
expect(result.azimuth, inInclusiveRange(0.0, 360.0));
|
||
});
|
||
|
||
test('sunrise is before sunset', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect(result.sunrise, lessThan(result.sunset));
|
||
});
|
||
|
||
test('solar noon is between sunrise and sunset', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect(result.solarNoon, greaterThan(result.sunrise));
|
||
expect(result.solarNoon, lessThan(result.sunset));
|
||
});
|
||
|
||
test('incidence is NaN for default spaZaRts', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect(result.incidence.isNaN, isTrue);
|
||
});
|
||
});
|
||
|
||
// ─── getSpa — spaZa function code ───────────────────────────────────────────
|
||
|
||
group('getSpa — spaZa (zenith+azimuth only)', () {
|
||
test('zenith and azimuth are valid', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZa,
|
||
);
|
||
expect(result.zenith, inInclusiveRange(0.0, 180.0));
|
||
expect(result.azimuth, inInclusiveRange(0.0, 360.0));
|
||
});
|
||
|
||
test('sunrise, solarNoon, sunset are NaN', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZa,
|
||
);
|
||
expect(result.sunrise.isNaN, isTrue);
|
||
expect(result.solarNoon.isNaN, isTrue);
|
||
expect(result.sunset.isNaN, isTrue);
|
||
});
|
||
|
||
test('incidence is NaN for spaZa', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZa,
|
||
);
|
||
expect(result.incidence.isNaN, isTrue);
|
||
});
|
||
|
||
test('matches spaZaRts zenith/azimuth to within floating point tolerance',
|
||
() {
|
||
final za = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZa,
|
||
);
|
||
final rts = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect((za.zenith - rts.zenith).abs(), lessThan(1e-10));
|
||
expect((za.azimuth - rts.azimuth).abs(), lessThan(1e-10));
|
||
});
|
||
|
||
test('throws when customAngles used with spaZa', () {
|
||
expect(
|
||
() => getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZa,
|
||
customAngles: [96.0],
|
||
),
|
||
throwsA(isA<ArgumentError>()),
|
||
);
|
||
});
|
||
});
|
||
|
||
// ─── getSpa — spaZaInc function code ────────────────────────────────────────
|
||
|
||
group('getSpa — spaZaInc (surface incidence)', () {
|
||
test('incidence angle is populated', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZaInc,
|
||
slope: 30.0,
|
||
azmRotation: 180.0,
|
||
);
|
||
expect(result.incidence, inInclusiveRange(0.0, 180.0));
|
||
});
|
||
|
||
test('sunrise, solarNoon, sunset are NaN', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZaInc,
|
||
slope: 30.0,
|
||
azmRotation: 180.0,
|
||
);
|
||
expect(result.sunrise.isNaN, isTrue);
|
||
expect(result.solarNoon.isNaN, isTrue);
|
||
expect(result.sunset.isNaN, isTrue);
|
||
});
|
||
|
||
test('flat surface incidence equals zenith', () {
|
||
// slope=0, azmRotation=0: incidence should equal zenith
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZaInc,
|
||
slope: 0.0,
|
||
azmRotation: 0.0,
|
||
);
|
||
expect((result.incidence - result.zenith).abs(), lessThan(1e-6));
|
||
});
|
||
});
|
||
|
||
// ─── getSpa — spaAll function code ──────────────────────────────────────────
|
||
|
||
group('getSpa — spaAll (zenith+azimuth+incidence+RTS)', () {
|
||
test('incidence, sunrise, solarNoon, sunset all populated', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaAll,
|
||
slope: 30.0,
|
||
azmRotation: 180.0,
|
||
);
|
||
expect(result.incidence, inInclusiveRange(0.0, 180.0));
|
||
expect(result.sunrise, greaterThan(0.0));
|
||
expect(result.solarNoon, greaterThan(0.0));
|
||
expect(result.sunset, greaterThan(0.0));
|
||
});
|
||
|
||
test('spaAll matches spaZaRts RTS fields', () {
|
||
final all = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaAll,
|
||
slope: 30.0,
|
||
azmRotation: 180.0,
|
||
);
|
||
final rts = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect((all.sunrise - rts.sunrise).abs(), lessThan(1e-6));
|
||
expect((all.sunset - rts.sunset).abs(), lessThan(1e-6));
|
||
expect((all.solarNoon - rts.solarNoon).abs(), lessThan(1e-6));
|
||
});
|
||
|
||
test('throws when customAngles used with spaZaInc', () {
|
||
expect(
|
||
() => getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZaInc,
|
||
customAngles: [96.0],
|
||
),
|
||
throwsA(isA<ArgumentError>()),
|
||
);
|
||
});
|
||
});
|
||
|
||
// ─── getSpa — custom angles ──────────────────────────────────────────────────
|
||
|
||
group('getSpa — custom angles', () {
|
||
test('civil and astronomical twilight pairs', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
customAngles: [96.0, 108.0],
|
||
);
|
||
expect(result.angles.length, equals(2));
|
||
// Civil (96°) sunrise is later than astronomical (108°)
|
||
expect(result.angles[0].sunrise, greaterThan(result.angles[1].sunrise));
|
||
// Civil sunset is earlier than astronomical
|
||
expect(result.angles[0].sunset, lessThan(result.angles[1].sunset));
|
||
});
|
||
|
||
test('nautical twilight (102)', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
customAngles: [102.0],
|
||
);
|
||
expect(result.angles.length, equals(1));
|
||
expect(result.angles[0].sunrise, lessThan(result.sunrise));
|
||
expect(result.angles[0].sunset, greaterThan(result.sunset));
|
||
});
|
||
});
|
||
|
||
// ─── getSpa — locations ──────────────────────────────────────────────────────
|
||
|
||
group('getSpa — locations', () {
|
||
test('Mecca summer solstice', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
21.3891,
|
||
39.8579,
|
||
3.0,
|
||
);
|
||
expect(result.zenith, inInclusiveRange(0.0, 90.0));
|
||
expect(result.sunrise, greaterThan(0));
|
||
expect(result.sunset, greaterThan(0));
|
||
});
|
||
|
||
test('London winter solstice', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 12, 21, 12, 0, 0),
|
||
51.5074,
|
||
-0.1278,
|
||
0.0,
|
||
);
|
||
expect(result.zenith, greaterThan(60.0)); // Sun is low
|
||
expect(result.sunrise, greaterThan(7.0)); // Late sunrise
|
||
});
|
||
|
||
test('equator at equinox — zenith near 0 at noon', () {
|
||
final result = getSpa(DateTime.utc(2024, 3, 20, 12, 0, 0), 0.0, 0.0, 0.0);
|
||
expect(result.zenith, lessThan(10.0));
|
||
});
|
||
|
||
test('Sydney summer (December)', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 12, 21, 3, 0, 0),
|
||
-33.8688,
|
||
151.2093,
|
||
11.0,
|
||
);
|
||
expect(result.sunrise, greaterThan(0));
|
||
expect(result.sunset, greaterThan(0));
|
||
});
|
||
});
|
||
|
||
// ─── getSpa — edge cases ─────────────────────────────────────────────────────
|
||
|
||
group('getSpa — edge cases', () {
|
||
test('throws for invalid input (latitude > 90)', () {
|
||
expect(
|
||
() => getSpa(DateTime.utc(2024, 1, 1), 91.0, 0.0, 0.0),
|
||
throwsA(isA<ArgumentError>()),
|
||
);
|
||
});
|
||
|
||
test('handles elevation parameter', () {
|
||
final sea = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
final mountain = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
elevation: 3000,
|
||
);
|
||
// Zenith should differ slightly due to parallax correction
|
||
expect((sea.zenith - mountain.zenith).abs(), greaterThan(0));
|
||
});
|
||
|
||
test('throws for invalid functionCode', () {
|
||
expect(
|
||
() => getSpa(DateTime.utc(2024, 1, 1), 40.0, -74.0, -5.0,
|
||
functionCode: 4),
|
||
throwsA(isA<ArgumentError>()),
|
||
);
|
||
});
|
||
});
|
||
|
||
// ─── calcSpa ─────────────────────────────────────────────────────────────────
|
||
|
||
group('calcSpa', () {
|
||
test('returns SpaFormattedResult with string times', () {
|
||
final result = calcSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect(result, isA<SpaFormattedResult>());
|
||
expect(result.sunrise, matches(RegExp(r'^\d{2}:\d{2}:\d{2}$')));
|
||
expect(result.solarNoon, matches(RegExp(r'^\d{2}:\d{2}:\d{2}$')));
|
||
expect(result.sunset, matches(RegExp(r'^\d{2}:\d{2}:\d{2}$')));
|
||
});
|
||
|
||
test('zenith and azimuth match getSpa', () {
|
||
final dt = DateTime.utc(2024, 3, 15, 12, 0, 0);
|
||
final raw = getSpa(dt, 40.7128, -74.0060, -5.0);
|
||
final fmt = calcSpa(dt, 40.7128, -74.0060, -5.0);
|
||
expect(fmt.zenith, closeTo(raw.zenith, 1e-10));
|
||
expect(fmt.azimuth, closeTo(raw.azimuth, 1e-10));
|
||
});
|
||
|
||
test('spaZa returns N/A for time fields', () {
|
||
final result = calcSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaZa,
|
||
);
|
||
expect(result.sunrise, equals('N/A'));
|
||
expect(result.solarNoon, equals('N/A'));
|
||
expect(result.sunset, equals('N/A'));
|
||
});
|
||
|
||
test('formats custom angles as HH:MM:SS', () {
|
||
final result = calcSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
customAngles: [96.0],
|
||
);
|
||
expect(result.angles.length, equals(1));
|
||
expect(result.angles[0], isA<SpaFormattedAnglesResult>());
|
||
expect(
|
||
result.angles[0].sunrise,
|
||
matches(RegExp(r'^\d{2}:\d{2}:\d{2}$')),
|
||
);
|
||
});
|
||
|
||
test('incidence populated for spaAll', () {
|
||
final result = calcSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
functionCode: spaAll,
|
||
slope: 30.0,
|
||
azmRotation: 180.0,
|
||
);
|
||
expect(result.incidence, inInclusiveRange(0.0, 180.0));
|
||
});
|
||
});
|
||
|
||
// ─── Numerical cross-validation against JS reference ────────────────────────
|
||
// Reference values computed from nrel-spa JS package (spa.js v2.0.1)
|
||
// for the NREL SPA example date: 2003-10-17 12:30:30 UTC, Golden CO.
|
||
// JS call: getSpa(new Date('2003-10-17T12:30:30Z'), 39.742476, -105.1786,
|
||
// -7.0, {elevation:1830.14, pressure:820, temperature:11,
|
||
// deltaT:67, deltaUt1:0})
|
||
// Expected: zenith=50.0°±0.5°, azimuth=194.0°±1.0°
|
||
// Sunrise ≈ 06:12, Sunset ≈ 17:20 (local time, -7h)
|
||
|
||
group('numerical cross-validation — NREL SPA reference date', () {
|
||
late SpaResult ref;
|
||
|
||
setUp(() {
|
||
ref = getSpa(
|
||
DateTime.utc(2003, 10, 17, 12, 30, 30),
|
||
39.742476, // Golden CO
|
||
-105.1786,
|
||
-7.0,
|
||
elevation: 1830.14,
|
||
pressure: 820,
|
||
temperature: 11,
|
||
deltaT: 67,
|
||
deltaUt1: 0,
|
||
);
|
||
});
|
||
|
||
test('zenith within 0.5° of expected ~50.1°', () {
|
||
expect(ref.zenith, closeTo(50.1, 0.5));
|
||
});
|
||
|
||
test('azimuth within 1.0° of expected ~194°', () {
|
||
expect(ref.azimuth, closeTo(194.0, 1.0));
|
||
});
|
||
|
||
test('sunrise in range 5.5–7.0h local', () {
|
||
expect(ref.sunrise, inInclusiveRange(5.5, 7.0));
|
||
});
|
||
|
||
test('sunset in range 16.5–18.0h local', () {
|
||
expect(ref.sunset, inInclusiveRange(16.5, 18.0));
|
||
});
|
||
|
||
test('solar noon in range 11.5–13.5h local', () {
|
||
expect(ref.solarNoon, inInclusiveRange(11.5, 13.5));
|
||
});
|
||
});
|
||
|
||
// ─── Numerical cross-validation — incidence angle ───────────────────────────
|
||
// JS: getSpa(new Date('2003-10-17T12:30:30Z'), 39.742476, -105.1786, -7,
|
||
// {elevation:1830.14, pressure:820, temperature:11, slope:30,
|
||
// azmRotation:-10, function:1})
|
||
// Expected incidence ≈ 25°±5°
|
||
|
||
group('numerical cross-validation — incidence angle', () {
|
||
test('surface incidence for tilted panel ≈ 25° (±5°)', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2003, 10, 17, 12, 30, 30),
|
||
39.742476,
|
||
-105.1786,
|
||
-7.0,
|
||
elevation: 1830.14,
|
||
pressure: 820,
|
||
temperature: 11,
|
||
deltaT: 67,
|
||
deltaUt1: 0,
|
||
functionCode: spaZaInc,
|
||
slope: 30.0,
|
||
azmRotation: -10.0,
|
||
);
|
||
expect(result.incidence, inInclusiveRange(20.0, 30.0));
|
||
});
|
||
});
|
||
|
||
// ─── Numerical cross-validation — formatTime round-trip ──────────────────────
|
||
|
||
group('formatTime — round-trip with getSpa', () {
|
||
test('formatted sunrise parses back to within 1 second', () {
|
||
final raw = getSpa(
|
||
DateTime.utc(2024, 6, 21, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
final str = formatTime(raw.sunrise);
|
||
final parts = str.split(':');
|
||
final h = int.parse(parts[0]);
|
||
final m = int.parse(parts[1]);
|
||
final s = int.parse(parts[2]);
|
||
final decoded = h + m / 60.0 + s / 3600.0;
|
||
expect((decoded - raw.sunrise).abs(), lessThan(1 / 3600.0 + 1e-9));
|
||
});
|
||
});
|
||
|
||
// ─── Type checks ─────────────────────────────────────────────────────────────
|
||
|
||
group('type checks', () {
|
||
test('SpaResult angles default to empty list', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
);
|
||
expect(result.angles, isEmpty);
|
||
});
|
||
|
||
test('SpaAnglesResult has sunrise and sunset', () {
|
||
final result = getSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
customAngles: [96.0],
|
||
);
|
||
expect(result.angles[0].sunrise, isA<double>());
|
||
expect(result.angles[0].sunset, isA<double>());
|
||
});
|
||
|
||
test('SpaFormattedAnglesResult has string sunrise and sunset', () {
|
||
final result = calcSpa(
|
||
DateTime.utc(2024, 3, 15, 12, 0, 0),
|
||
40.7128,
|
||
-74.0060,
|
||
-5.0,
|
||
customAngles: [96.0],
|
||
);
|
||
expect(result.angles[0].sunrise, isA<String>());
|
||
expect(result.angles[0].sunset, isA<String>());
|
||
});
|
||
});
|
||
}
|