package main import ( "bytes" "compress/gzip" "encoding/csv" "encoding/json" "fmt" "io" "math" "net/http" "net/url" "os" "path/filepath" "sort" "strconv" "strings" "sync" "time" "lingniu/vehicle-data-platform/apps/api/internal/openplatform" ) const ( baseURL = "http://115.29.187.205:20200" hydrogenEnergyKWh = 16.0 maxIntegrationGap = 30 * time.Second ) type vehicleMetadata struct { VIN string `json:"vin"` Plate string `json:"plate"` Model string `json:"model"` BatteryCapacityKWh float64 `json:"battery_capacity_kwh"` TankCapacityL float64 `json:"tank_capacity_l"` } type rawFrame struct { TS string `json:"ts"` FrameID string `json:"frame_id"` EventID string `json:"event_id"` MessageID int `json:"message_id"` EventTime string `json:"event_time"` ParseStatus string `json:"parse_status"` SourceEndpoint string `json:"source_endpoint"` VIN string `json:"vin"` ParsedFields map[string]any `json:"parsed_fields"` } type rawResponse struct { Items []rawFrame `json:"items"` Total int `json:"total"` } type energySample struct { At time.Time VehicleStatus int ChargeStatus int SOC float64 Mileage float64 BatteryVoltageV float64 BatteryCurrentA float64 FuelCellVoltageV float64 FuelCellCurrentA float64 HasSOC bool HasMileage bool HasBatteryPower bool HasFuelCellPower bool HasVehicleStatus bool HasChargeStatus bool } type energyResult struct { FirstTime string `json:"firstTime"` LastTime string `json:"lastTime"` StartSOC float64 `json:"startSoc"` EndSOC float64 `json:"endSoc"` SOCChangePctEndMinusStart float64 `json:"socChangePctEndMinusStart"` StoredEnergyChangeKWhSOC float64 `json:"storedEnergyChangeKWhSoc"` BatteryNetOutputKWhSOC float64 `json:"batteryNetOutputKWhSoc"` BatteryNetOutputKWhIntegrated float64 `json:"batteryNetOutputKWhIntegrated"` FuelCellOutputKWhIntegrated float64 `json:"fuelCellOutputKWhIntegrated"` BatteryCoverageSeconds float64 `json:"batteryCoverageSeconds"` FuelCellCoverageSeconds float64 `json:"fuelCellCoverageSeconds"` OperatingSpanSeconds float64 `json:"operatingSpanSeconds"` BatteryCoverageRatio float64 `json:"batteryCoverageRatio"` FuelCellCoverageRatio float64 `json:"fuelCellCoverageRatio"` ExternalChargeFrameCount int `json:"externalChargeFrameCount"` EnergySampleCount int `json:"energySampleCount"` } type row struct { Date string `json:"date"` Plate string `json:"plate"` VIN string `json:"vin"` Model string `json:"model"` RawFrameCount int `json:"rawFrameCount"` CurrentQuality string `json:"currentQuality"` CurrentReason string `json:"currentReason"` RefuelCount int `json:"refuelCount"` ChargeCount int `json:"chargeCount"` TotalMileageKm float64 `json:"totalMileageKm"` PureElectricMileageKm float64 `json:"pureElectricMileageKm"` CurrentMixedMileageKm float64 `json:"currentMixedMileageKm"` PhysicalHydrogenKg float64 `json:"physicalHydrogenKg"` CurrentSOCBalancedKg float64 `json:"currentSocBalancedKg"` CurrentRatePerMixedKm float64 `json:"currentRatePerMixedKm"` PhysicalRatePerTotalKm float64 `json:"physicalRatePerTotalKm"` FullDayStartSOC float64 `json:"fullDayStartSoc"` FullDayEndSOC float64 `json:"fullDayEndSoc"` FullDaySOCChangePct float64 `json:"fullDaySocChangePct"` StoredEnergyChangeKWhSOC float64 `json:"storedEnergyChangeKWhSoc"` BatteryEquivalentKgFixed16 float64 `json:"batteryEquivalentKgFixed16"` StandardLikeBalancedKg float64 `json:"standardLikeBalancedKg"` StandardLikeRatePerTotalKm float64 `json:"standardLikeRatePerTotalKm"` StandardLikeApplicable bool `json:"standardLikeApplicable"` StandardLikeReason string `json:"standardLikeReason"` BatteryNetOutputKWhIntegrated float64 `json:"batteryNetOutputKWhIntegrated"` FuelCellOutputKWhIntegrated float64 `json:"fuelCellOutputKWhIntegrated"` BatteryEnergyShare float64 `json:"batteryEnergyShare"` FuelCellEnergyShare float64 `json:"fuelCellEnergyShare"` BatteryContributionKm float64 `json:"batteryContributionKm"` FuelCellContributionKm float64 `json:"fuelCellContributionKm"` HydrogenRatePerFCContributionKm float64 `json:"hydrogenRatePerFcContributionKm"` BatteryCoverageRatio float64 `json:"batteryCoverageRatio"` FuelCellCoverageRatio float64 `json:"fuelCellCoverageRatio"` ExternalChargeFrameCount int `json:"externalChargeFrameCount"` PowerIntegrationUsable bool `json:"powerIntegrationUsable"` } type job struct { Vehicle vehicleMetadata Date string } func main() { if len(os.Args) != 5 { panic("usage: standard-model-trial ") } metadataPath, startDate, endDate, outputDir := os.Args[1], os.Args[2], os.Args[3], os.Args[4] start := mustDate(startDate) end := mustDate(endDate) if end.Before(start) { panic("end date is before start date") } var vehicles []vehicleMetadata mustReadJSON(metadataPath, &vehicles) if len(vehicles) == 0 { panic("metadata is empty") } if err := os.MkdirAll(outputDir, 0o755); err != nil { panic(err) } jobs := make(chan job) results := make(chan row) errs := make(chan error, 128) var wg sync.WaitGroup for worker := 0; worker < 16; worker++ { wg.Add(1) go func() { defer wg.Done() for item := range jobs { result, err := process(item) if err != nil { errs <- fmt.Errorf("%s %s %s: %w", item.Date, item.Vehicle.Plate, item.Vehicle.VIN, err) continue } if result.RawFrameCount > 0 { results <- result } } }() } go func() { for day := start; !day.After(end); day = day.AddDate(0, 0, 1) { for _, vehicle := range vehicles { if len(strings.TrimSpace(vehicle.VIN)) != 17 || vehicle.TankCapacityL <= 0 || vehicle.BatteryCapacityKWh <= 0 { continue } jobs <- job{Vehicle: vehicle, Date: day.Format("2006-01-02")} } } close(jobs) wg.Wait() close(results) close(errs) }() var rows []row completed := 0 for result := range results { rows = append(rows, result) completed++ if completed%25 == 0 { fmt.Fprintf(os.Stderr, "completed=%d latest=%s %s quality=%s raw=%d\n", completed, result.Date, result.Plate, result.CurrentQuality, result.RawFrameCount) } } var errorMessages []string for err := range errs { errorMessages = append(errorMessages, err.Error()) } if len(errorMessages) > 0 { panic(strings.Join(errorMessages, "\n")) } sort.Slice(rows, func(i, j int) bool { if rows[i].Date != rows[j].Date { return rows[i].Date < rows[j].Date } if rows[i].Plate != rows[j].Plate { return rows[i].Plate < rows[j].Plate } return rows[i].VIN < rows[j].VIN }) writeJSON(filepath.Join(outputDir, "results.json"), rows) writeCSV(filepath.Join(outputDir, "results.csv"), rows) writeJSON(filepath.Join(outputDir, "summary.json"), summarize(rows)) fmt.Printf("vehicle_days=%d output=%s\n", len(rows), outputDir) } func process(item job) (row, error) { frames, total, err := fetchFrames(item.Vehicle.VIN, item.Date) if err != nil || total == 0 { return row{Date: item.Date, Plate: item.Vehicle.Plate, VIN: item.Vehicle.VIN, Model: item.Vehicle.Model, RawFrameCount: total}, err } sort.SliceStable(frames, func(i, j int) bool { if frames[i].EventTime != frames[j].EventTime { return frames[i].EventTime < frames[j].EventTime } return frames[i].EventID < frames[j].EventID }) observations := make([]openplatform.HydrogenObservation, 0, len(frames)) energySamples := make([]energySample, 0, len(frames)) for _, frame := range frames { if observation, ok := observationFromFrame(frame, item.Vehicle.TankCapacityL, item.Date); ok { observations = append(observations, observation) } if sample, ok := energySampleFromFrame(frame, item.Date); ok { energySamples = append(energySamples, sample) } } params := map[string]openplatform.HydrogenCalculationParameters{ item.Vehicle.VIN: {BatteryCapacityKWh: item.Vehicle.BatteryCapacityKWh, HydrogenEnergyKWhKg: hydrogenEnergyKWh}, } stats := openplatform.BuildHydrogenDailyStatsOrderedWithParameters(observations, item.Date, 0.05, 20, params) stat := openplatform.HydrogenDailyStat{VIN: item.Vehicle.VIN, Date: item.Date, QualityStatus: "NO_DATA", QualityReason: "无有效压力温度样本"} if len(stats) == 1 { stat = stats[0] } energy := calculateEnergy(energySamples, item.Vehicle.BatteryCapacityKWh) totalMileage := stat.MixedMileageKm + stat.PureElectricMileageKm result := row{ Date: item.Date, Plate: item.Vehicle.Plate, VIN: item.Vehicle.VIN, Model: item.Vehicle.Model, RawFrameCount: total, CurrentQuality: stat.QualityStatus, CurrentReason: stat.QualityReason, RefuelCount: stat.RefuelCount, ChargeCount: stat.ChargeCount, TotalMileageKm: totalMileage, PureElectricMileageKm: stat.PureElectricMileageKm, CurrentMixedMileageKm: stat.MixedMileageKm, PhysicalHydrogenKg: stat.ConsumptionKg, FullDayStartSOC: energy.StartSOC, FullDayEndSOC: energy.EndSOC, FullDaySOCChangePct: energy.SOCChangePctEndMinusStart, StoredEnergyChangeKWhSOC: energy.StoredEnergyChangeKWhSOC, BatteryNetOutputKWhIntegrated: energy.BatteryNetOutputKWhIntegrated, FuelCellOutputKWhIntegrated: energy.FuelCellOutputKWhIntegrated, BatteryCoverageRatio: energy.BatteryCoverageRatio, FuelCellCoverageRatio: energy.FuelCellCoverageRatio, ExternalChargeFrameCount: energy.ExternalChargeFrameCount, } if stat.SOCBalancedConsumptionKg != nil { result.CurrentSOCBalancedKg = *stat.SOCBalancedConsumptionKg } if stat.SOCBalancedKgPer100Km != nil { result.CurrentRatePerMixedKm = *stat.SOCBalancedKgPer100Km } if totalMileage > 0 { result.PhysicalRatePerTotalKm = round(stat.ConsumptionKg * 100 / totalMileage) result.BatteryEquivalentKgFixed16 = round(-energy.StoredEnergyChangeKWhSOC / hydrogenEnergyKWh) result.StandardLikeBalancedKg = round(stat.ConsumptionKg + result.BatteryEquivalentKgFixed16) result.StandardLikeRatePerTotalKm = round(result.StandardLikeBalancedKg * 100 / totalMileage) switch { case energy.ExternalChargeFrameCount > 0: result.StandardLikeReason = "检测到外部充电，整日SOC平衡修正不适用，应按CD/CS分段" case result.StandardLikeBalancedKg < 0: result.StandardLikeReason = "SOC平衡氢量为负，端点、SOC或换算系数需复核" default: result.StandardLikeApplicable = true } } else { result.StandardLikeReason = "无有效总里程" } // The GB/T 43252 contribution trial uses positive battery net output and // fuel-cell output measured over non-external-charge vehicle-on intervals. // Coverage gates prevent sparse power fields from being treated as precise. if totalMileage >= 10 && stat.ConsumptionKg > 0 && energy.ExternalChargeFrameCount == 0 && energy.BatteryCoverageRatio >= 0.98 && energy.FuelCellCoverageRatio >= 0.98 && energy.FuelCellOutputKWhIntegrated > 0 { batteryOutput := math.Max(0, energy.BatteryNetOutputKWhIntegrated) totalOutput := batteryOutput + energy.FuelCellOutputKWhIntegrated if totalOutput > 0 { result.PowerIntegrationUsable = true result.BatteryEnergyShare = round(batteryOutput / totalOutput) result.FuelCellEnergyShare = round(energy.FuelCellOutputKWhIntegrated / totalOutput) result.BatteryContributionKm = round(totalMileage * result.BatteryEnergyShare) result.FuelCellContributionKm = round(totalMileage * result.FuelCellEnergyShare) if result.FuelCellContributionKm > 0 { result.HydrogenRatePerFCContributionKm = round(stat.ConsumptionKg * 100 / result.FuelCellContributionKm) } } } return result, nil } func calculateEnergy(samples []energySample, batteryCapacityKWh float64) energyResult { result := energyResult{EnergySampleCount: len(samples)} if len(samples) == 0 { return result } for _, sample := range samples { if sample.HasChargeStatus && sample.ChargeStatus == 1 { result.ExternalChargeFrameCount++ } } operating := make([]energySample, 0, len(samples)) for _, sample := range samples { if sample.HasVehicleStatus && sample.VehicleStatus == 1 && (!sample.HasChargeStatus || sample.ChargeStatus != 1) { operating = append(operating, sample) } } if len(operating) == 0 { return result } result.FirstTime = operating[0].At.Format(time.RFC3339) result.LastTime = operating[len(operating)-1].At.Format(time.RFC3339) result.OperatingSpanSeconds = operating[len(operating)-1].At.Sub(operating[0].At).Seconds() for _, sample := range operating { if sample.HasSOC { result.StartSOC = sample.SOC break } } for index := len(operating) - 1; index >= 0; index-- { if operating[index].HasSOC { result.EndSOC = operating[index].SOC break } } result.SOCChangePctEndMinusStart = round(result.EndSOC - result.StartSOC) result.StoredEnergyChangeKWhSOC = round(batteryCapacityKWh * result.SOCChangePctEndMinusStart / 100) result.BatteryNetOutputKWhSOC = round(-result.StoredEnergyChangeKWhSOC) for index := 1; index < len(operating); index++ { previous, current := operating[index-1], operating[index] delta := current.At.Sub(previous.At) if delta <= 0 || delta > maxIntegrationGap { continue } hours := delta.Hours() if previous.HasBatteryPower && current.HasBatteryPower { power0 := previous.BatteryVoltageV * previous.BatteryCurrentA / 1000 power1 := current.BatteryVoltageV * current.BatteryCurrentA / 1000 result.BatteryNetOutputKWhIntegrated += (power0 + power1) * 0.5 * hours result.BatteryCoverageSeconds += delta.Seconds() } if previous.HasFuelCellPower && current.HasFuelCellPower { power0 := previous.FuelCellVoltageV * previous.FuelCellCurrentA / 1000 power1 := current.FuelCellVoltageV * current.FuelCellCurrentA / 1000 result.FuelCellOutputKWhIntegrated += (power0 + power1) * 0.5 * hours result.FuelCellCoverageSeconds += delta.Seconds() } } result.BatteryNetOutputKWhIntegrated = round(result.BatteryNetOutputKWhIntegrated) result.FuelCellOutputKWhIntegrated = round(result.FuelCellOutputKWhIntegrated) if result.OperatingSpanSeconds > 0 { result.BatteryCoverageRatio = round(result.BatteryCoverageSeconds / result.OperatingSpanSeconds) result.FuelCellCoverageRatio = round(result.FuelCellCoverageSeconds / result.OperatingSpanSeconds) } return result } func observationFromFrame(frame rawFrame, tankCapacity float64, statDate string) (openplatform.HydrogenObservation, bool) { if frame.MessageID != 2 || !strings.EqualFold(frame.ParseStatus, "OK") { return openplatform.HydrogenObservation{}, false } pressure, pressureOK := number(frame.ParsedFields["gb32960.fuel_cell.max_hydrogen_pressure_mpa"]) temperature, temperatureOK := number(frame.ParsedFields["gb32960.fuel_cell.max_hydrogen_temperature_c"]) if !pressureOK || !temperatureOK || pressure <= 0 || pressure > 70 || temperature <= -40 || temperature > 726.85 { return openplatform.HydrogenObservation{}, false } mass, ok := openplatform.PressureHydrogenMassKg(pressure, temperature, tankCapacity) if !ok { return openplatform.HydrogenObservation{}, false } step, _ := openplatform.PressureHydrogenMassKg(math.Max(0, pressure-0.2), temperature, tankCapacity) at, err := parseEventTime(frame.EventTime) if err != nil || at.Format("2006-01-02") != statDate { return openplatform.HydrogenObservation{}, false } parsed, _ := json.Marshal(frame.ParsedFields) _, _, active, known, _ := openplatform.ExtractHydrogenTelemetry(string(parsed)) observation := openplatform.HydrogenObservation{ VIN: frame.VIN, Source: frame.SourceEndpoint, EventID: frame.EventID, ObservedAt: at, MassKg: mass, TankCapacityLiter: tankCapacity, PressureMPa: pressure, TemperatureC: temperature, NoiseKg: math.Min(1, math.Max(0.05, mass-step)), RefuelThresholdKg: math.Max(1, mass*0.05), FuelCellActive: active, FuelCellStateKnown: known, } if value, ok := number(frame.ParsedFields["gb32960.vehicle.soc_percent"]); ok && value >= 0 && value <= 100 { observation.SOCPercent, observation.SOCKnown = value, true } if value, ok := number(frame.ParsedFields["gb32960.vehicle.total_mileage_km"]); ok && value >= 0 { observation.MileageKm, observation.MileageKnown = value, true } if value, ok := number(frame.ParsedFields["gb32960.vehicle.vehicle_status"]); ok { observation.VehicleState, observation.VehicleStateKnown = int(value), value >= 0 && value <= 255 } if value, ok := number(frame.ParsedFields["gb32960.vehicle.charge_status"]); ok { observation.ChargeState, observation.ChargeStateKnown = int(value), value >= 0 && value <= 255 } if value, ok := number(frame.ParsedFields["gb32960.vehicle.running_mode"]); ok { observation.RunningMode, observation.RunningModeKnown = int(value), value >= 0 && value <= 255 } return observation, true } func energySampleFromFrame(frame rawFrame, statDate string) (energySample, bool) { if frame.MessageID != 2 || !strings.EqualFold(frame.ParseStatus, "OK") { return energySample{}, false } at, err := parseEventTime(frame.EventTime) if err != nil || at.Format("2006-01-02") != statDate { return energySample{}, false } sample := energySample{At: at} if value, ok := number(frame.ParsedFields["gb32960.vehicle.vehicle_status"]); ok { sample.VehicleStatus, sample.HasVehicleStatus = int(value), true } if value, ok := number(frame.ParsedFields["gb32960.vehicle.charge_status"]); ok { sample.ChargeStatus, sample.HasChargeStatus = int(value), true } if value, ok := number(frame.ParsedFields["gb32960.vehicle.soc_percent"]); ok && value >= 0 && value <= 100 { sample.SOC, sample.HasSOC = value, true } if value, ok := number(frame.ParsedFields["gb32960.vehicle.total_mileage_km"]); ok && value >= 0 { sample.Mileage, sample.HasMileage = value, true } batteryVoltage, batteryVoltageOK := number(frame.ParsedFields["gb32960.vehicle.total_voltage_v"]) batteryCurrent, batteryCurrentOK := number(frame.ParsedFields["gb32960.vehicle.total_current_a"]) if batteryVoltageOK && batteryCurrentOK && batteryVoltage > 0 && batteryVoltage <= 1000 && batteryCurrent >= -1000 && batteryCurrent <= 1000 { sample.BatteryVoltageV, sample.BatteryCurrentA, sample.HasBatteryPower = batteryVoltage, batteryCurrent, true } fuelCellVoltage, fuelCellVoltageOK := number(frame.ParsedFields["gb32960.fuel_cell.fuel_cell_voltage_v"]) fuelCellCurrent, fuelCellCurrentOK := number(frame.ParsedFields["gb32960.fuel_cell.fuel_cell_current_a"]) if fuelCellVoltageOK && fuelCellCurrentOK && fuelCellVoltage >= 0 && fuelCellVoltage <= 2000 && fuelCellCurrent >= 0 && fuelCellCurrent <= 2000 { sample.FuelCellVoltageV, sample.FuelCellCurrentA, sample.HasFuelCellPower = fuelCellVoltage, fuelCellCurrent, true } return sample, sample.HasVehicleStatus || sample.HasSOC || sample.HasBatteryPower || sample.HasFuelCellPower } func fetchFrames(vin, date string) ([]rawFrame, int, error) { const limit = 500 first, err := fetchPage(vin, date, 0, limit, true) if err != nil { return nil, 0, err } frames := append([]rawFrame(nil), first.Items...) for offset := limit; offset < first.Total; offset += limit { page, err := fetchPage(vin, date, offset, limit, false) if err != nil { return nil, first.Total, err } frames = append(frames, page.Items...) } if len(frames) != first.Total { return nil, first.Total, fmt.Errorf("API total=%d fetched=%d", first.Total, len(frames)) } return frames, first.Total, nil } func fetchPage(vin, date string, offset, limit int, includeTotal bool) (rawResponse, error) { query := url.Values{ "protocol": {"GB32960"}, "vin": {vin}, "dateFrom": {date + " 00:00:00"}, "dateTo": {date + " 23:59:59"}, "orderBy": {"eventTime"}, "limit": {strconv.Itoa(limit)}, "offset": {strconv.Itoa(offset)}, "includeFields": {"true"}, "includePayload": {"false"}, "includeTotal": {strconv.FormatBool(includeTotal)}, } var response *http.Response var err error for attempt := 1; attempt <= 4; attempt++ { request, _ := http.NewRequest(http.MethodGet, baseURL+"/api/history/raw-frames?"+query.Encode(), nil) request.Header.Set("Accept-Encoding", "gzip") response, err = (&http.Client{Timeout: 90 * time.Second}).Do(request) if err == nil { break } if attempt < 4 { time.Sleep(time.Duration(attempt) * 500 * time.Millisecond) } } if err != nil { return rawResponse{}, err } defer response.Body.Close() if response.StatusCode != http.StatusOK { body, _ := io.ReadAll(response.Body) if response.StatusCode == http.StatusInternalServerError && bytes.Contains(body, []byte("Table does not exist")) { return rawResponse{}, nil } return rawResponse{}, fmt.Errorf("HTTP %d: %s", response.StatusCode, body) } var reader io.Reader = response.Body if response.Header.Get("Content-Encoding") == "gzip" { gzipReader, err := gzip.NewReader(response.Body) if err != nil { return rawResponse{}, err } defer gzipReader.Close() reader = gzipReader } var result rawResponse if err := json.NewDecoder(reader).Decode(&result); err != nil { return rawResponse{}, err } return result, nil } func summarize(rows []row) map[string]any { byDate := map[string]map[string]any{} for _, date := range uniqueDates(rows) { var dateRows []row for _, value := range rows { if value.Date == date { dateRows = append(dateRows, value) } } quality := map[string]int{} valid := 0 standardApplicable := 0 powerUsable := 0 physicalTotal, balancedTotal, mileageTotal, balancedMileageTotal := 0.0, 0.0, 0.0, 0.0 for _, value := range dateRows { quality[value.CurrentQuality]++ if value.CurrentQuality != "NO_DATA" && value.TotalMileageKm > 0 { valid++ physicalTotal += value.PhysicalHydrogenKg mileageTotal += value.TotalMileageKm } if value.StandardLikeApplicable { standardApplicable++ balancedTotal += value.StandardLikeBalancedKg balancedMileageTotal += value.TotalMileageKm } if value.PowerIntegrationUsable { powerUsable++ } } physicalRate, balancedRate := 0.0, 0.0 if mileageTotal > 0 { physicalRate = round(physicalTotal * 100 / mileageTotal) } if balancedMileageTotal > 0 { balancedRate = round(balancedTotal * 100 / balancedMileageTotal) } byDate[date] = map[string]any{ "vehicleDaysWithFrames": len(dateRows), "validVehicleDays": valid, "standardLikeApplicableVehicleDays": standardApplicable, "qualityCounts": quality, "powerIntegrationUsableVehicleDays": powerUsable, "totalMileageKm": round(mileageTotal), "physicalHydrogenKg": round(physicalTotal), "standardLikeBalancedHydrogenKg": round(balancedTotal), "standardLikeMileageKm": round(balancedMileageTotal), "fleetPhysicalRateKgPer100Km": physicalRate, "fleetStandardLikeRateKgPer100Km": balancedRate, } } return map[string]any{"vehicleDays": len(rows), "byDate": byDate} } func writeCSV(path string, rows []row) { file, err := os.Create(path) if err != nil { panic(err) } defer file.Close() writer := csv.NewWriter(file) defer writer.Flush() headers := []string{"日期", "车牌", "VIN", "车型", "原始帧数", "当前质量状态", "当前质量原因", "加氢次数", "充电次数", "总里程km", "当前纯电里程km", "当前混动里程km", "物理耗氢kg", "当前SOC平衡氢量kg", "当前修正氢耗_按混动里程", "物理氢耗_按总里程", "全日起始SOC", "全日终止SOC", "全日SOC变化_末减初", "全日电池储能变化kWh", "电池等效氢量_16kWhkg", "标准式平衡氢量kg", "标准式平衡氢耗_按总里程", "标准式修正可用", "标准式修正说明", "电流积分电池净输出kWh", "燃料电池输出积分kWh", "电池能量贡献占比", "燃料电池能量贡献占比", "电池贡献里程km", "燃料电池贡献里程km", "按燃料电池贡献里程氢耗", "电池功率覆盖率", "燃料电池功率覆盖率", "外充状态帧数", "功率积分可用"} _ = writer.Write(headers) for _, value := range rows { _ = writer.Write([]string{ value.Date, value.Plate, value.VIN, value.Model, integer(value.RawFrameCount), value.CurrentQuality, value.CurrentReason, integer(value.RefuelCount), integer(value.ChargeCount), decimal(value.TotalMileageKm), decimal(value.PureElectricMileageKm), decimal(value.CurrentMixedMileageKm), decimal(value.PhysicalHydrogenKg), decimal(value.CurrentSOCBalancedKg), decimal(value.CurrentRatePerMixedKm), decimal(value.PhysicalRatePerTotalKm), decimal(value.FullDayStartSOC), decimal(value.FullDayEndSOC), decimal(value.FullDaySOCChangePct), decimal(value.StoredEnergyChangeKWhSOC), decimal(value.BatteryEquivalentKgFixed16), decimal(value.StandardLikeBalancedKg), decimal(value.StandardLikeRatePerTotalKm), strconv.FormatBool(value.StandardLikeApplicable), value.StandardLikeReason, decimal(value.BatteryNetOutputKWhIntegrated), decimal(value.FuelCellOutputKWhIntegrated), decimal(value.BatteryEnergyShare), decimal(value.FuelCellEnergyShare), decimal(value.BatteryContributionKm), decimal(value.FuelCellContributionKm), decimal(value.HydrogenRatePerFCContributionKm), decimal(value.BatteryCoverageRatio), decimal(value.FuelCellCoverageRatio), integer(value.ExternalChargeFrameCount), strconv.FormatBool(value.PowerIntegrationUsable), }) } } func uniqueDates(rows []row) []string { seen := map[string]bool{} for _, value := range rows { seen[value.Date] = true } dates := make([]string, 0, len(seen)) for date := range seen { dates = append(dates, date) } sort.Strings(dates) return dates } func number(value any) (float64, bool) { switch typed := value.(type) { case float64: return typed, true case json.Number: parsed, err := typed.Float64() return parsed, err == nil case string: parsed, err := strconv.ParseFloat(strings.TrimSpace(typed), 64) return parsed, err == nil default: return 0, false } } func parseEventTime(value string) (time.Time, error) { location := time.FixedZone("CST", 8*3600) if parsed, err := time.ParseInLocation("2006-01-02 15:04:05.000", value, location); err == nil { return parsed, nil } return time.ParseInLocation("2006-01-02 15:04:05", value, location) } func mustDate(value string) time.Time { parsed, err := time.Parse("2006-01-02", value) if err != nil { panic(err) } return parsed } func mustReadJSON(path string, target any) { data, err := os.ReadFile(path) if err != nil { panic(err) } if err := json.Unmarshal(data, target); err != nil { panic(err) } } func writeJSON(path string, value any) { data, err := json.MarshalIndent(value, "", " ") if err != nil { panic(err) } if err := os.WriteFile(path, data, 0o644); err != nil { panic(err) } } func round(value float64) float64 { return math.Round(value*1000) / 1000 } func decimal(value float64) string { return strconv.FormatFloat(value, 'f', 3, 64) } func integer(value int) string { return strconv.Itoa(value) }