zhangwen/front_linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ebefd6b2aecd392fea42efc746d6a4097f52b223
front_linux/LFtid1056/pqdif_thread_processor.cpp

7927 lines
341 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include "pqdif_thread_processor.h"
#include <algorithm>
#include <chrono>
#include <thread>
#include <cctype>
#include <cmath>
#include <ctime>
#include <deque>
#include <iostream>
#include <mutex>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <experimental/filesystem>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <limits>
#include <utility>
// PQDIF 解析库
#include "pqdif/PQDIF.h"
#include "pqdif/include/pqdif_ph.h"
#include "pqdif/include/pqdif_id.h"
#include "pqdif/include/pqdif_lg.h"
#include "pqdif_semantic_ids.h"
namespace fs = std::experimental::filesystem;
namespace {
constexpr int kScanIntervalSec = 60;
constexpr int kBackupLimit = 4800;
constexpr int kMaxPqdifFilesPerScan = 1;
constexpr size_t kParsedCacheLimit = 128;
const char* kPqdRootDir = "download";
const char* kDoneRootDir = "download_done";
const char* kFailRootDir = "download_fail";
std::deque<ParsedPqdifFile> g_parsed_cache;
std::mutex g_parsed_cache_mutex;
// PQDIF 统计桶 Base64 文件级“生成队列”。
// 对象用途：解析线程在完成一个 PQDIF 文件的桶数据组装后，会把一个
// PqdifStatBase64FileBatch 放入这个队列。
// 数据粒度：一个队列元素 = 一个 PQDIF 文件批次；批次内部再按
// “时间点 -> Max/Min/Avg/P95 子记录”保存，避免不同 PQDIF 文件的数据混合。
constexpr size_t kPqdifStatBase64QueueLimit = 128;
std::deque<PqdifStatBase64FileBatch> g_pqdif_stat_base64_queue;
std::mutex g_pqdif_stat_base64_mutex;
// PQDIF 统计桶 Base64 文件级“待后续处理队列”。
// 对象用途：RunPqdifScanLoop() 每轮循环末尾会从生成队列取出最多一个
// PqdifStatBase64FileBatch，并移动到这个队列中，后续入库/上传/推送逻辑
// 可以从这里取数据。
// 设计原因：避免在扫描解析队列上直接做耗时业务处理，同时保证取出的文件批次
// 不会因为局部变量析构而丢失。
std::deque<PqdifStatBase64FileBatch> g_pqdif_stat_base64_ready_queue;
std::mutex g_pqdif_stat_base64_ready_mutex;
std::string guid_to_string(const GUID& g)
{
char buf[64] = { 0 };
std::snprintf(buf, sizeof(buf),
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
static_cast<unsigned int>(g.Data1),
static_cast<unsigned int>(g.Data2),
static_cast<unsigned int>(g.Data3),
static_cast<unsigned int>(g.Data4[0]),
static_cast<unsigned int>(g.Data4[1]),
static_cast<unsigned int>(g.Data4[2]),
static_cast<unsigned int>(g.Data4[3]),
static_cast<unsigned int>(g.Data4[4]),
static_cast<unsigned int>(g.Data4[5]),
static_cast<unsigned int>(g.Data4[6]),
static_cast<unsigned int>(g.Data4[7]));
return std::string(buf);
}
std::string safe_tag_name(const GUID& tag)
{
const char* name = theInfo.GetNameOfTag(tag);
if (name != nullptr && name[0] != '\0')
return std::string(name);
return guid_to_string(tag);
}
PqdifGuidValue make_guid_value(const GUID& guid)
{
PqdifGuidValue out;
out.value = guid;
out.symbolic_name = safe_tag_name(guid);
return out;
}
std::string format_time_text(time_t ts)
{
if (ts == 0)
return std::string();
std::tm tm_value{};
#if defined(_WIN32)
localtime_s(&tm_value, &ts);
#else
std::tm* ptm = std::localtime(&ts);
if (ptm == nullptr)
return std::string();
tm_value = *ptm;
#endif
char buf[32] = { 0 };
if (std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm_value) == 0)
return std::string();
return std::string(buf);
}
PqdifTimestampValue make_timestamp_value(CPQDIF& file_convert, const TIMESTAMPPQDIF& ts)
{
PqdifTimestampValue out;
out.day = ts.day;
out.second = ts.sec;
if (ts.day != 0 || std::fabs(ts.sec) > 1e-12)
{
DATE dt = static_cast<DATE>(ts.day) + (ts.sec / static_cast<double>(SECONDS_PER_DAY));
file_convert.GetTime(dt, &out.unix_time);
out.text = format_time_text(out.unix_time);
}
return out;
}
PqdifRecordHeaderInfo build_record_header_info(CPQDIFRecord* record, long record_index)
{
PqdifRecordHeaderInfo info;
info.record_index = record_index;
if (record == nullptr)
return info;
LINKABS4 pos = 0;
LINKABS4 next_pos = 0;
SIZE4 size_header = 0;
SIZE4 size_data = 0;
UINT checksum = 0;
GUID record_tag{};
record->HeaderGetPos(pos);
record->HeaderGetTag(record_tag);
record->HeaderGetSize(size_header, size_data);
record->HeaderGetPosNextRecord(next_pos);
record->HeaderGetChecksum(checksum);
info.file_position = static_cast<long>(pos);
info.record_type = make_guid_value(record_tag);
info.header_size = static_cast<long>(size_header);
info.data_size = static_cast<long>(size_data);
info.next_record_position = static_cast<long>(next_pos);
info.checksum = static_cast<unsigned int>(checksum);
return info;
}
std::string trim_trailing_nulls(const std::string& value)
{
std::string out = value;
while (!out.empty() && out.back() == '\0')
out.pop_back();
return out;
}
bool dump_file_basic_info(const std::string& file_path, std::string& err)
{
std::error_code ec;
fs::path p(file_path);
if (!fs::exists(p, ec))
{
err = "file not exists";
return false;
}
if (!fs::is_regular_file(p, ec))
{
err = "not a regular file";
return false;
}
auto file_size = fs::file_size(p, ec);
if (ec)
{
err = "cannot get file size";
return false;
}
std::ifstream ifs(file_path, std::ios::binary);
if (!ifs.is_open())
{
err = "ifstream open failed";
return false;
}
std::cout << "[PQDIF] file basic info: path=" << file_path
<< ", size=" << file_size << std::endl;
unsigned char buf[32] = { 0 };
ifs.read(reinterpret_cast<char*>(buf), sizeof(buf));
std::streamsize n = ifs.gcount();
std::ostringstream oss;
oss << "[PQDIF] first " << n << " bytes: ";
for (std::streamsize i = 0; i < n; ++i)
{
oss << std::hex << std::setw(2) << std::setfill('0')
<< static_cast<int>(buf[i]) << " ";
}
std::cout << oss.str() << std::endl;
return true;
}
std::string to_upper_copy(std::string s)
{
std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) {
return static_cast<char>(std::toupper(c));
});
return s;
}
std::string trim_copy(const std::string& s)
{
size_t beg = 0;
while (beg < s.size() && std::isspace(static_cast<unsigned char>(s[beg])))
++beg;
size_t end = s.size();
while (end > beg && std::isspace(static_cast<unsigned char>(s[end - 1])))
--end;
return s.substr(beg, end - beg);
}
std::string normalize_key(const std::string& src)
{
std::string out;
out.reserve(src.size());
for (char c : src)
{
unsigned char uc = static_cast<unsigned char>(c);
if (std::isalnum(uc) || c == '[' || c == ']')
out.push_back(static_cast<char>(std::toupper(uc)));
}
return out;
}
bool is_pqdif_file(const fs::path& path)
{
if (!fs::is_regular_file(path))
return false;
const std::string ext = to_upper_copy(path.extension().string());
return ext == ".PQD" || ext == ".PQDIF";
}
bool ensure_dir(const fs::path& dir)
{
std::error_code ec;
if (fs::exists(dir, ec))
return true;
return fs::create_directories(dir, ec) || fs::exists(dir, ec);
}
bool move_file_with_fallback(const fs::path& src, const fs::path& dst)
{
std::error_code ec;
ensure_dir(dst.parent_path());
fs::rename(src, dst, ec);
if (!ec)
return true;
ec.clear();
fs::copy_file(src, dst, fs::copy_options::overwrite_existing, ec);
if (ec)
return false;
ec.clear();
fs::remove(src, ec);
return !ec;
}
void cleanup_backup_dir(const fs::path& dir, int limit)
{
if (limit < 0)
return;
std::error_code ec;
if (!fs::exists(dir, ec) || !fs::is_directory(dir, ec))
return;
std::vector<fs::path> files;
for (fs::directory_iterator it(dir, ec), end; !ec && it != end; it.increment(ec))
{
if (!ec && is_pqdif_file(it->path()))
files.push_back(it->path());
}
if (files.size() <= static_cast<size_t>(limit))
return;
std::sort(files.begin(), files.end(), [](const fs::path& a, const fs::path& b) {
std::error_code ea, eb;
return fs::last_write_time(a, ea) < fs::last_write_time(b, eb);
});
const size_t remove_count = files.size() - static_cast<size_t>(limit);
for (size_t i = 0; i < remove_count; ++i)
{
std::error_code remove_ec;
fs::remove(files[i], remove_ec);
}
}
bool push_parsed_result_to_cache(ParsedPqdifFile&& parsed)
{
std::lock_guard<std::mutex> guard(g_parsed_cache_mutex);
if (g_parsed_cache.size() >= kParsedCacheLimit)
{
std::cout << "[PQDIF] cache full, drop oldest: "
<< g_parsed_cache.front().source_file << std::endl;
g_parsed_cache.pop_front();
}
g_parsed_cache.emplace_back(std::move(parsed));
return true;
}
bool read_scalar_raw(CPQDIF_E_Collection* collection, const GUID& tag, long& physical_type, PQDIFValue& value)
{
if (collection == nullptr)
return false;
CPQDIF_Element* element = collection->GetElement(tag, ID_ELEMENT_TYPE_SCALAR);
if (element == nullptr)
return false;
CPQDIF_E_Scalar* scalar = static_cast<CPQDIF_E_Scalar*>(element);
return scalar->GetValue(physical_type, value);
}
bool read_string_tag(CPQDIF_E_Collection* collection, const GUID& tag, std::string& out)
{
if (collection == nullptr)
return false;
CPQDIF_Element* element = collection->GetElement(tag, ID_ELEMENT_TYPE_VECTOR);
if (element == nullptr)
return false;
CPQDIF_E_Vector* vector = static_cast<CPQDIF_E_Vector*>(element);
std::string text;
if (!vector->GetValues(text))
return false;
out = trim_trailing_nulls(text);
return true;
}
bool read_uint_tag(CPQDIF_E_Collection* collection, const GUID& tag, unsigned int& out)
{
long physical_type = -1;
PQDIFValue value{};
if (!read_scalar_raw(collection, tag, physical_type, value))
return false;
switch (physical_type)
{
case ID_PHYS_TYPE_UNS_INTEGER1: out = static_cast<unsigned int>(value.uint1); return true;
case ID_PHYS_TYPE_UNS_INTEGER2: out = static_cast<unsigned int>(value.uint2); return true;
case ID_PHYS_TYPE_UNS_INTEGER4: out = static_cast<unsigned int>(value.uint4); return true;
case ID_PHYS_TYPE_INTEGER1: out = static_cast<unsigned int>(value.int1); return true;
case ID_PHYS_TYPE_INTEGER2: out = static_cast<unsigned int>(value.int2); return true;
case ID_PHYS_TYPE_INTEGER4: out = static_cast<unsigned int>(value.int4); return true;
default: return false;
}
}
bool read_int_tag(CPQDIF_E_Collection* collection, const GUID& tag, int& out)
{
long physical_type = -1;
PQDIFValue value{};
if (!read_scalar_raw(collection, tag, physical_type, value))
return false;
switch (physical_type)
{
case ID_PHYS_TYPE_INTEGER1: out = static_cast<int>(value.int1); return true;
case ID_PHYS_TYPE_INTEGER2: out = static_cast<int>(value.int2); return true;
case ID_PHYS_TYPE_INTEGER4: out = static_cast<int>(value.int4); return true;
case ID_PHYS_TYPE_UNS_INTEGER1: out = static_cast<int>(value.uint1); return true;
case ID_PHYS_TYPE_UNS_INTEGER2: out = static_cast<int>(value.uint2); return true;
case ID_PHYS_TYPE_UNS_INTEGER4: out = static_cast<int>(value.uint4); return true;
default: return false;
}
}
bool read_bool_tag(CPQDIF_E_Collection* collection, const GUID& tag, bool& out)
{
long physical_type = -1;
PQDIFValue value{};
if (!read_scalar_raw(collection, tag, physical_type, value))
return false;
switch (physical_type)
{
case ID_PHYS_TYPE_BOOLEAN1: out = (value.bool1 != 0); return true;
case ID_PHYS_TYPE_BOOLEAN2: out = (value.bool2 != 0); return true;
case ID_PHYS_TYPE_BOOLEAN4: out = (value.bool4 != 0); return true;
default: return false;
}
}
bool read_double_tag(CPQDIF_E_Collection* collection, const GUID& tag, double& out)
{
long physical_type = -1;
PQDIFValue value{};
if (!read_scalar_raw(collection, tag, physical_type, value))
return false;
switch (physical_type)
{
case ID_PHYS_TYPE_REAL4: out = static_cast<double>(value.real4); return true;
case ID_PHYS_TYPE_REAL8: out = value.real8; return true;
case ID_PHYS_TYPE_INTEGER1: out = static_cast<double>(value.int1); return true;
case ID_PHYS_TYPE_INTEGER2: out = static_cast<double>(value.int2); return true;
case ID_PHYS_TYPE_INTEGER4: out = static_cast<double>(value.int4); return true;
case ID_PHYS_TYPE_UNS_INTEGER1: out = static_cast<double>(value.uint1); return true;
case ID_PHYS_TYPE_UNS_INTEGER2: out = static_cast<double>(value.uint2); return true;
case ID_PHYS_TYPE_UNS_INTEGER4: out = static_cast<double>(value.uint4); return true;
default: return false;
}
}
bool read_guid_tag(CPQDIF_E_Collection* collection, const GUID& tag, PqdifGuidValue& out)
{
long physical_type = -1;
PQDIFValue value{};
if (!read_scalar_raw(collection, tag, physical_type, value))
return false;
if (physical_type != ID_PHYS_TYPE_GUID)
return false;
out = make_guid_value(value.guid);
return true;
}
bool read_timestamp_tag(CPQDIF_E_Collection* collection, const GUID& tag, CPQDIF& file_convert, PqdifTimestampValue& out)
{
long physical_type = -1;
PQDIFValue value{};
if (!read_scalar_raw(collection, tag, physical_type, value))
return false;
if (physical_type != ID_PHYS_TYPE_TIMESTAMPPQDIF)
return false;
out = make_timestamp_value(file_convert, value.ts);
return true;
}
std::vector<unsigned int> read_vector_uint_values(CPQDIF_E_Collection* collection, const GUID& tag)
{
std::vector<unsigned int> out;
if (collection == nullptr)
return out;
CPQDIF_Element* element = collection->GetElement(tag, ID_ELEMENT_TYPE_VECTOR);
if (element == nullptr)
return out;
CPQDIF_E_Vector* vector = static_cast<CPQDIF_E_Vector*>(element);
long count = 0;
vector->GetCount(count);
for (long i = 0; i < count; ++i)
{
PQDIFValue value{};
if (!vector->GetValue(i, value))
continue;
switch (vector->GetPhysicalType())
{
case ID_PHYS_TYPE_UNS_INTEGER1: out.push_back(static_cast<unsigned int>(value.uint1)); break;
case ID_PHYS_TYPE_UNS_INTEGER2: out.push_back(static_cast<unsigned int>(value.uint2)); break;
case ID_PHYS_TYPE_UNS_INTEGER4: out.push_back(static_cast<unsigned int>(value.uint4)); break;
case ID_PHYS_TYPE_INTEGER1: out.push_back(static_cast<unsigned int>(value.int1)); break;
case ID_PHYS_TYPE_INTEGER2: out.push_back(static_cast<unsigned int>(value.int2)); break;
case ID_PHYS_TYPE_INTEGER4: out.push_back(static_cast<unsigned int>(value.int4)); break;
default: break;
}
}
return out;
}
std::vector<int> read_vector_int_values(CPQDIF_E_Collection* collection, const GUID& tag)
{
std::vector<int> out;
if (collection == nullptr)
return out;
CPQDIF_Element* element = collection->GetElement(tag, ID_ELEMENT_TYPE_VECTOR);
if (element == nullptr)
return out;
CPQDIF_E_Vector* vector = static_cast<CPQDIF_E_Vector*>(element);
long count = 0;
vector->GetCount(count);
for (long i = 0; i < count; ++i)
{
PQDIFValue value{};
if (!vector->GetValue(i, value))
continue;
switch (vector->GetPhysicalType())
{
case ID_PHYS_TYPE_INTEGER1: out.push_back(static_cast<int>(value.int1)); break;
case ID_PHYS_TYPE_INTEGER2: out.push_back(static_cast<int>(value.int2)); break;
case ID_PHYS_TYPE_INTEGER4: out.push_back(static_cast<int>(value.int4)); break;
case ID_PHYS_TYPE_UNS_INTEGER1: out.push_back(static_cast<int>(value.uint1)); break;
case ID_PHYS_TYPE_UNS_INTEGER2: out.push_back(static_cast<int>(value.uint2)); break;
case ID_PHYS_TYPE_UNS_INTEGER4: out.push_back(static_cast<int>(value.uint4)); break;
default: break;
}
}
return out;
}
PqdifValueArray extract_vector_values(CPQDIF_E_Vector* vector, CPQDIF& file_convert)
{
PqdifValueArray out;
if (vector == nullptr)
return out;
out.physical_type = vector->GetPhysicalType();
vector->GetCount(out.count);
if (out.physical_type == ID_PHYS_TYPE_CHAR1 || out.physical_type == ID_PHYS_TYPE_CHAR2)
{
std::string text;
if (vector->GetValues(text))
out.text_values.push_back(trim_trailing_nulls(text));
return out;
}
for (long i = 0; i < out.count; ++i)
{
PQDIFValue value{};
if (!vector->GetValue(i, value))
continue;
switch (out.physical_type)
{
case ID_PHYS_TYPE_BOOLEAN1: out.bool_values.push_back(value.bool1 != 0); break;
case ID_PHYS_TYPE_BOOLEAN2: out.bool_values.push_back(value.bool2 != 0); break;
case ID_PHYS_TYPE_BOOLEAN4: out.bool_values.push_back(value.bool4 != 0); break;
case ID_PHYS_TYPE_INTEGER1: out.int_values.push_back(static_cast<long long>(value.int1)); break;
case ID_PHYS_TYPE_INTEGER2: out.int_values.push_back(static_cast<long long>(value.int2)); break;
case ID_PHYS_TYPE_INTEGER4: out.int_values.push_back(static_cast<long long>(value.int4)); break;
case ID_PHYS_TYPE_UNS_INTEGER1: out.uint_values.push_back(static_cast<unsigned long long>(value.uint1)); break;
case ID_PHYS_TYPE_UNS_INTEGER2: out.uint_values.push_back(static_cast<unsigned long long>(value.uint2)); break;
case ID_PHYS_TYPE_UNS_INTEGER4: out.uint_values.push_back(static_cast<unsigned long long>(value.uint4)); break;
case ID_PHYS_TYPE_REAL4: out.real_values.push_back(static_cast<double>(value.real4)); break;
case ID_PHYS_TYPE_REAL8: out.real_values.push_back(value.real8); break;
case ID_PHYS_TYPE_COMPLEX8: out.complex_values.push_back(std::complex<double>(value.complex8.real, value.complex8.image)); break;
case ID_PHYS_TYPE_COMPLEX16: out.complex_values.push_back(std::complex<double>(value.complex16.real, value.complex16.image)); break;
case ID_PHYS_TYPE_TIMESTAMPPQDIF: out.timestamp_values.push_back(make_timestamp_value(file_convert, value.ts)); break;
case ID_PHYS_TYPE_GUID: out.guid_values.push_back(make_guid_value(value.guid)); break;
default: break;
}
}
return out;
}
std::string scalar_value_to_text(long physical_type, const PQDIFValue& value, CPQDIF& file_convert)
{
std::ostringstream oss;
switch (physical_type)
{
case ID_PHYS_TYPE_BOOLEAN1: oss << (value.bool1 ? "true" : "false"); break;
case ID_PHYS_TYPE_BOOLEAN2: oss << (value.bool2 ? "true" : "false"); break;
case ID_PHYS_TYPE_BOOLEAN4: oss << (value.bool4 ? "true" : "false"); break;
case ID_PHYS_TYPE_INTEGER1: oss << static_cast<int>(value.int1); break;
case ID_PHYS_TYPE_INTEGER2: oss << value.int2; break;
case ID_PHYS_TYPE_INTEGER4: oss << value.int4; break;
case ID_PHYS_TYPE_UNS_INTEGER1: oss << static_cast<unsigned int>(value.uint1); break;
case ID_PHYS_TYPE_UNS_INTEGER2: oss << value.uint2; break;
case ID_PHYS_TYPE_UNS_INTEGER4: oss << value.uint4; break;
case ID_PHYS_TYPE_REAL4: oss << value.real4; break;
case ID_PHYS_TYPE_REAL8: oss << value.real8; break;
case ID_PHYS_TYPE_COMPLEX8: oss << value.complex8.real << "+" << value.complex8.image << "j"; break;
case ID_PHYS_TYPE_COMPLEX16: oss << value.complex16.real << "+" << value.complex16.image << "j"; break;
case ID_PHYS_TYPE_TIMESTAMPPQDIF:
{
PqdifTimestampValue ts = make_timestamp_value(file_convert, value.ts);
oss << ts.text;
break;
}
case ID_PHYS_TYPE_GUID: oss << safe_tag_name(value.guid) << "(" << guid_to_string(value.guid) << ")"; break;
default: oss << "physical_type=" << physical_type; break;
}
return oss.str();
}
std::string element_to_text(CPQDIF_Element* element, CPQDIF& file_convert)
{
if (element == nullptr)
return std::string();
std::ostringstream oss;
if (element->GetElementType() == ID_ELEMENT_TYPE_SCALAR)
{
CPQDIF_E_Scalar* scalar = static_cast<CPQDIF_E_Scalar*>(element);
long physical_type = -1;
PQDIFValue value{};
if (scalar->GetValue(physical_type, value))
return scalar_value_to_text(physical_type, value, file_convert);
return std::string();
}
if (element->GetElementType() == ID_ELEMENT_TYPE_VECTOR)
{
CPQDIF_E_Vector* vector = static_cast<CPQDIF_E_Vector*>(element);
PqdifValueArray values = extract_vector_values(vector, file_convert);
oss << "vector(type=" << values.physical_type << ", count=" << values.count << ")";
size_t shown = 0;
auto append_preview = [&](const std::string& text) {
if (shown == 0)
oss << " [";
else
oss << ", ";
oss << text;
++shown;
if (shown == 5)
return false;
return true;
};
for (size_t i = 0; i < values.real_values.size() && shown < 5; ++i)
append_preview(std::to_string(values.real_values[i]));
for (size_t i = 0; i < values.int_values.size() && shown < 5; ++i)
append_preview(std::to_string(values.int_values[i]));
for (size_t i = 0; i < values.uint_values.size() && shown < 5; ++i)
append_preview(std::to_string(values.uint_values[i]));
for (size_t i = 0; i < values.bool_values.size() && shown < 5; ++i)
append_preview(values.bool_values[i] ? "true" : "false");
for (size_t i = 0; i < values.text_values.size() && shown < 5; ++i)
append_preview(values.text_values[i]);
for (size_t i = 0; i < values.timestamp_values.size() && shown < 5; ++i)
append_preview(values.timestamp_values[i].text);
for (size_t i = 0; i < values.guid_values.size() && shown < 5; ++i)
append_preview(values.guid_values[i].symbolic_name);
if (shown > 0)
oss << (values.count > 5 ? ", ...]" : "]");
return oss.str();
}
if (element->GetElementType() == ID_ELEMENT_TYPE_COLLECTION)
{
CPQDIF_E_Collection* collection = static_cast<CPQDIF_E_Collection*>(element);
oss << "collection(count=" << collection->GetCount() << ")";
return oss.str();
}
return std::string();
}
void collect_extra_tags(CPQDIF_E_Collection* collection,
const std::set<std::string>& known_tag_names,
CPQDIF& file_convert,
PqdifExtraTagMap& out)
{
out.clear();
if (collection == nullptr)
return;
const long count = collection->GetCount();
for (long i = 0; i < count; ++i)
{
CPQDIF_Element* element = collection->GetElement(i);
if (element == nullptr)
continue;
const std::string tag_name = safe_tag_name(element->GetTag());
if (known_tag_names.find(tag_name) != known_tag_names.end())
continue;
out[tag_name] = element_to_text(element, file_convert);
}
}
void dump_logical_summary(const ParsedPqdifFile& parsed_file)
{
std::cout << "========== PQDIF LOGICAL SUMMARY ==========" << std::endl;
std::cout << "file=" << parsed_file.source_file
<< ", records=" << parsed_file.logical_file.record_headers.size()
<< ", containers=" << parsed_file.logical_file.containers.size()
<< ", data_sources=" << parsed_file.logical_file.data_sources.size()
<< ", settings=" << parsed_file.logical_file.monitor_settings.size()
<< ", observations=" << parsed_file.logical_file.observations.size()
<< std::endl;
if (!parsed_file.logical_file.observations.empty())
{
const PqdifObservationRecord& obs = parsed_file.logical_file.observations.front();
std::cout << " first_observation=" << obs.observation_name
<< ", start=" << obs.time_start.text
<< ", channels=" << obs.channel_instances.size()
<< std::endl;
}
std::cout << "==========================================" << std::endl;
}
/// @brief PQDIF 日志级别。
/// @details
/// 后续新增打印时请按级别输出：
/// - Core：默认核心摘要，必须短，适合平时测试；
/// - Info：处理流程、fallback 命中情况、文件移动等；
/// - Debug：observation 列表、疑似通道、指标来源排查；
/// - Trace：逐通道/逐序列/全量 bucket 明细，日志量很大。
enum class PqdifLogLevel
{
Core = 0,
Info = 1,
Debug = 2,
Trace = 3
};
bool pqdif_env_truthy(const char* v)
{
if (v == nullptr)
return false;
std::string s(v);
for (char& ch : s)
ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
return s == "1" || s == "TRUE" || s == "YES" || s == "ON" ||
s == "DEBUG" || s == "DETAIL" || s == "TRACE" || s == "VERBOSE";
}
PqdifLogLevel pqdif_parse_log_level(const char* v)
{
if (v == nullptr || *v == '\0')
return PqdifLogLevel::Core;
std::string s(v);
for (char& ch : s)
ch = static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
if (s == "0" || s == "CORE" || s == "QUIET") return PqdifLogLevel::Core;
if (s == "1" || s == "INFO") return PqdifLogLevel::Info;
if (s == "2" || s == "DEBUG" || s == "DETAIL") return PqdifLogLevel::Debug;
if (s == "3" || s == "TRACE" || s == "VERBOSE") return PqdifLogLevel::Trace;
return pqdif_env_truthy(v) ? PqdifLogLevel::Debug : PqdifLogLevel::Core;
}
PqdifLogLevel pqdif_current_log_level()
{
static int cached = -1;
if (cached >= 0)
return static_cast<PqdifLogLevel>(cached);
PqdifLogLevel level = pqdif_parse_log_level(std::getenv("PQDIF_LOG_LEVEL"));
// 向后兼容旧开关。
if (level == PqdifLogLevel::Core)
{
if (pqdif_env_truthy(std::getenv("PQDIF_DETAIL_LOG")))
level = PqdifLogLevel::Debug;
if (pqdif_env_truthy(std::getenv("PQDIF_VERBOSE")))
level = PqdifLogLevel::Trace;
}
cached = static_cast<int>(level);
return level;
}
bool pqdif_log_enabled(PqdifLogLevel level)
{
return static_cast<int>(pqdif_current_log_level()) >= static_cast<int>(level);
}
/// @brief 是否开启详细调试日志。保留旧函数名，便于已有打印逻辑复用。
bool pqdif_is_detail_log_enabled()
{
return pqdif_log_enabled(PqdifLogLevel::Debug);
}
bool pqdif_is_trace_log_enabled()
{
return pqdif_log_enabled(PqdifLogLevel::Trace);
}
std::string short_guid_name(const PqdifGuidValue& g)
{
if (!g.symbolic_name.empty())
return g.symbolic_name;
return guid_to_string(g.value);
}
std::string preview_value_array(const PqdifValueArray& v)
{
std::ostringstream oss;
oss << "physical_type=" << v.physical_type
<< ", count=" << v.count;
auto append_real_preview = [&](const std::vector<double>& arr, const char* name)
{
if (arr.empty())
return;
oss << ", " << name << "=[";
for (size_t i = 0; i < arr.size() && i < 3; ++i)
{
if (i > 0) oss << ", ";
oss << arr[i];
}
if (arr.size() > 3) oss << ", ...";
oss << "]";
};
auto append_int_preview = [&](const std::vector<long long>& arr, const char* name)
{
if (arr.empty())
return;
oss << ", " << name << "=[";
for (size_t i = 0; i < arr.size() && i < 3; ++i)
{
if (i > 0) oss << ", ";
oss << arr[i];
}
if (arr.size() > 3) oss << ", ...";
oss << "]";
};
auto append_uint_preview = [&](const std::vector<unsigned long long>& arr, const char* name)
{
if (arr.empty())
return;
oss << ", " << name << "=[";
for (size_t i = 0; i < arr.size() && i < 3; ++i)
{
if (i > 0) oss << ", ";
oss << arr[i];
}
if (arr.size() > 3) oss << ", ...";
oss << "]";
};
auto append_time_preview = [&](const std::vector<PqdifTimestampValue>& arr, const char* name)
{
if (arr.empty())
return;
oss << ", " << name << "=[";
for (size_t i = 0; i < arr.size() && i < 3; ++i)
{
if (i > 0) oss << ", ";
oss << arr[i].text;
}
if (arr.size() > 3) oss << ", ...";
oss << "]";
};
append_real_preview(v.real_values, "real");
append_int_preview(v.int_values, "int");
append_uint_preview(v.uint_values, "uint");
append_time_preview(v.timestamp_values, "time");
if (!v.text_values.empty())
{
oss << ", text=[";
for (size_t i = 0; i < v.text_values.size() && i < 2; ++i)
{
if (i > 0) oss << ", ";
oss << "\"" << v.text_values[i] << "\"";
}
if (v.text_values.size() > 2) oss << ", ...";
oss << "]";
}
return oss.str();
}
void dump_semantic_probe(const ParsedPqdifFile& parsed_file)
{
const auto& lf = parsed_file.logical_file;
const auto& reg = pqdif_sem::GetGuidSemanticRegistry();
std::cout << "========== PQDIF SEMANTIC PROBE ==========" << std::endl;
std::cout << "file=" << parsed_file.source_file << std::endl;
std::cout << "data_sources=" << lf.data_sources.size()
<< ", observations=" << lf.observations.size()
<< std::endl;
// --------------------------------------------------------------------
// 1) 打印第一条数据源的前几个通道定义
// --------------------------------------------------------------------
if (!lf.data_sources.empty())
{
const auto& ds = lf.data_sources.front();
std::cout << "[DEF] data_source[0]"
<< " name=" << ds.name
<< ", model=" << ds.instrument_model_name
<< ", channels=" << ds.channel_definitions.size()
<< std::endl;
const size_t ch_limit = std::min<size_t>(ds.channel_definitions.size(), 3);
for (size_t i = 0; i < ch_limit; ++i)
{
const auto& ch = ds.channel_definitions[i];
std::cout << " [CH-DEF " << i << "]"
<< " name=" << ch.channel_name
<< ", phase=" << pqdif_sem::FindPhaseName(ch.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(ch.quantity_measured_id)
<< ", qty_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityType,
ch.quantity_type_id.value,
short_guid_name(ch.quantity_type_id).c_str())
<< ", series_defs=" << ch.series_definitions.size()
<< std::endl;
const size_t sd_limit = std::min<size_t>(ch.series_definitions.size(), 5);
for (size_t j = 0; j < sd_limit; ++j)
{
const auto& sd = ch.series_definitions[j];
std::cout << " [SER-DEF " << j << "]"
<< " value_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::ValueType,
sd.value_type_id.value,
short_guid_name(sd.value_type_id).c_str())
<< ", characteristic=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityCharacteristic,
sd.quantity_characteristic_id.value,
short_guid_name(sd.quantity_characteristic_id).c_str())
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(sd.quantity_units_id)
<< ", storage=" << pqdif_sem::FindStorageMethodFlagsName(sd.storage_method_id)
<< ", nominal=" << sd.nominal_quantity
<< std::endl;
}
}
}
// --------------------------------------------------------------------
// 2) 打印第一条 observation 的前几个通道实例
// --------------------------------------------------------------------
if (!lf.observations.empty())
{
const auto& obs = lf.observations.front();
std::cout << "[OBS] observation[0]"
<< " name=" << obs.observation_name
<< ", start=" << obs.time_start.text
<< ", trigger=" << pqdif_sem::FindTriggerMethodName(obs.trigger_method_id)
<< ", channels=" << obs.channel_instances.size()
<< std::endl;
const size_t ch_limit = std::min<size_t>(obs.channel_instances.size(), 3);
for (size_t i = 0; i < ch_limit; ++i)
{
const auto& ch = obs.channel_instances[i];
std::cout << " [CH-INS " << i << "]"
<< " name=" << ch.channel_name
<< ", phase=" << pqdif_sem::FindPhaseName(ch.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(ch.quantity_measured_id)
<< ", qty_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityType,
ch.quantity_type_id.value,
short_guid_name(ch.quantity_type_id).c_str())
<< ", freq=" << ch.channel_frequency
<< ", group=" << ch.channel_group_id
<< ", series_instances=" << ch.series_instances.size()
<< std::endl;
const size_t si_limit = std::min<size_t>(ch.series_instances.size(), 5);
for (size_t j = 0; j < si_limit; ++j)
{
const auto& si = ch.series_instances[j];
std::cout << " [SER-INS " << j << "]"
<< " value_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::ValueType,
si.value_type_id.value,
short_guid_name(si.value_type_id).c_str())
<< ", characteristic=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityCharacteristic,
si.quantity_characteristic_id.value,
short_guid_name(si.quantity_characteristic_id).c_str())
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(si.quantity_units_id)
<< ", storage=N/A"
<< ", " << preview_value_array(si.values)
<< ", share_ch=" << si.share_channel_index
<< ", share_ser=" << si.share_series_index
<< ", scale=" << si.scale
<< ", offset=" << si.offset
<< std::endl;
}
}
}
std::cout << "==========================================" << std::endl;
}
long max_series_value_count_in_channel(const PqdifChannelInstance& ch)
{
long max_count = 0;
for (const auto& si : ch.series_instances)
max_count = std::max<long>(max_count, si.values.count);
return max_count;
}
long max_series_value_count_in_observation(const PqdifObservationRecord& obs)
{
long max_count = 0;
for (const auto& ch : obs.channel_instances)
max_count = std::max<long>(max_count, max_series_value_count_in_channel(ch));
return max_count;
}
const PqdifChannelDefinition* find_channel_definition(
const PqdifLogicalFile& lf,
const PqdifObservationRecord& obs,
const PqdifChannelInstance& ch)
{
if (obs.related_data_source_index < 0 ||
obs.related_data_source_index >= static_cast<int>(lf.data_sources.size()))
return nullptr;
const auto& ds = lf.data_sources[static_cast<size_t>(obs.related_data_source_index)];
if (ch.channel_def_index < 0 ||
ch.channel_def_index >= static_cast<int>(ds.channel_definitions.size()))
return nullptr;
return &ds.channel_definitions[static_cast<size_t>(ch.channel_def_index)];
}
bool is_integer_in_range(double value, int min_value, int max_value)
{
if (!std::isfinite(value))
return false;
const double rounded = std::floor(value + 0.5);
if (std::fabs(value - rounded) > 1e-6)
return false;
const int n = static_cast<int>(rounded);
return n >= min_value && n <= max_value;
}
std::string harmonic_order_token(int order)
{
char buf[8] = { 0 };
std::snprintf(buf, sizeof(buf), "%02d", order);
return std::string(buf);
}
bool text_looks_like_harmonic(const std::string& text)
{
const std::string key = normalize_key(text);
if (key.empty())
return false;
if (key.find("HARM") != std::string::npos ||
key.find("HARMONIC") != std::string::npos ||
key.find("THD") != std::string::npos ||
key.find("IHD") != std::string::npos ||
key.find("VHD") != std::string::npos ||
key.find("HRMS") != std::string::npos)
return true;
for (int order = 2; order <= 50; ++order)
{
const std::string two = harmonic_order_token(order);
const std::string plain = std::to_string(order);
const std::string patterns[] = {
"H" + two, "H" + plain,
"HD" + two, "HD" + plain,
"VH" + two, "VH" + plain,
"UH" + two, "UH" + plain,
"IH" + two, "IH" + plain
};
for (const auto& pat : patterns)
{
if (key.find(pat) != std::string::npos)
return true;
}
}
return false;
}
bool extra_tags_look_like_harmonic(const PqdifExtraTagMap& tags)
{
for (const auto& kv : tags)
{
if (text_looks_like_harmonic(kv.first) || text_looks_like_harmonic(kv.second))
return true;
}
return false;
}
bool series_definition_looks_like_harmonic(const PqdifSeriesDefinition& sd)
{
if (is_integer_in_range(sd.nominal_quantity, 2, 50))
return true;
if (text_looks_like_harmonic(sd.value_type_name) ||
text_looks_like_harmonic(sd.value_type_id.symbolic_name) ||
text_looks_like_harmonic(sd.quantity_characteristic_id.symbolic_name) ||
extra_tags_look_like_harmonic(sd.extra_tags))
return true;
return false;
}
bool series_instance_looks_like_harmonic(const PqdifSeriesInstance& si)
{
if (is_integer_in_range(si.series_base_quantity, 2, 50) ||
is_integer_in_range(si.nominal_quantity, 2, 50))
return true;
if (text_looks_like_harmonic(si.value_type_id.symbolic_name) ||
text_looks_like_harmonic(si.quantity_characteristic_id.symbolic_name) ||
extra_tags_look_like_harmonic(si.extra_tags))
return true;
return false;
}
bool channel_definition_looks_like_harmonic(const PqdifChannelDefinition& ch)
{
if (text_looks_like_harmonic(ch.channel_name) ||
text_looks_like_harmonic(ch.quantity_name) ||
text_looks_like_harmonic(ch.group_name) ||
text_looks_like_harmonic(ch.other_channel_identifier) ||
text_looks_like_harmonic(ch.quantity_type_id.symbolic_name) ||
extra_tags_look_like_harmonic(ch.extra_tags))
return true;
for (const auto& sd : ch.series_definitions)
{
if (series_definition_looks_like_harmonic(sd))
return true;
}
return false;
}
bool channel_instance_looks_like_harmonic(
const PqdifChannelInstance& ch,
const PqdifChannelDefinition* def)
{
if (text_looks_like_harmonic(ch.channel_name) ||
text_looks_like_harmonic(ch.quantity_type_id.symbolic_name) ||
extra_tags_look_like_harmonic(ch.extra_tags))
return true;
if (def != nullptr && channel_definition_looks_like_harmonic(*def))
return true;
for (const auto& si : ch.series_instances)
{
if (series_instance_looks_like_harmonic(si))
return true;
}
return false;
}
void dump_observation_list(const ParsedPqdifFile& parsed_file)
{
const auto& lf = parsed_file.logical_file;
std::cout << "========== PQDIF OBSERVATION LIST ==========" << std::endl;
std::cout << "file=" << parsed_file.source_file
<< ", observation_count=" << lf.observations.size()
<< std::endl;
for (size_t i = 0; i < lf.observations.size(); ++i)
{
const auto& obs = lf.observations[i];
std::cout << " [OBS " << i << "]"
<< " index=" << obs.observation_index
<< ", record=" << obs.record_index
<< ", name=" << obs.observation_name
<< ", start=" << obs.time_start.text
<< ", create=" << obs.time_create.text
<< ", trigger=" << pqdif_sem::FindTriggerMethodName(obs.trigger_method_id)
<< ", triggered=" << obs.time_triggered.text
<< ", channels=" << obs.channel_instances.size()
<< ", max_series_count=" << max_series_value_count_in_observation(obs)
<< ", related_ds=" << obs.related_data_source_index
<< ", related_settings=" << obs.related_settings_index
<< std::endl;
const size_t preview_count = std::min<size_t>(obs.channel_instances.size(), 10);
if (preview_count > 0)
{
std::cout << " channel_preview=";
for (size_t j = 0; j < preview_count; ++j)
{
const auto& ch = obs.channel_instances[j];
if (j > 0)
std::cout << " | ";
std::cout << "#" << ch.channel_instance_index << ":" << ch.channel_name;
}
if (obs.channel_instances.size() > preview_count)
std::cout << " | ...";
std::cout << std::endl;
}
}
std::cout << "============================================" << std::endl;
}
void dump_harmonic_channel_probe(const ParsedPqdifFile& parsed_file)
{
const auto& lf = parsed_file.logical_file;
const auto& reg = pqdif_sem::GetGuidSemanticRegistry();
std::cout << "========== PQDIF HARMONIC CHANNEL PROBE ==========" << std::endl;
std::cout << "file=" << parsed_file.source_file << std::endl;
std::cout << "rule=print channel definitions/instances whose name, GUID name, extra tags, "
<< "series_base_quantity or nominal_quantity looks like harmonic order 2-50"
<< std::endl;
size_t def_hits = 0;
for (size_t ds_idx = 0; ds_idx < lf.data_sources.size(); ++ds_idx)
{
const auto& ds = lf.data_sources[ds_idx];
for (size_t ch_idx = 0; ch_idx < ds.channel_definitions.size(); ++ch_idx)
{
const auto& ch = ds.channel_definitions[ch_idx];
if (!channel_definition_looks_like_harmonic(ch))
continue;
++def_hits;
std::cout << " [HARM-DEF " << def_hits << "]"
<< " ds=" << ds_idx
<< ", ch_def=" << ch.channel_def_index
<< ", name=" << ch.channel_name
<< ", phase=" << pqdif_sem::FindPhaseName(ch.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(ch.quantity_measured_id)
<< ", qty_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityType,
ch.quantity_type_id.value,
short_guid_name(ch.quantity_type_id).c_str())
<< ", physical_ch=" << ch.physical_channel
<< ", primary_series=" << ch.primary_series_index
<< ", series_defs=" << ch.series_definitions.size()
<< std::endl;
const size_t sd_limit = std::min<size_t>(ch.series_definitions.size(), 8);
for (size_t j = 0; j < sd_limit; ++j)
{
const auto& sd = ch.series_definitions[j];
std::cout << " [HARM-SER-DEF " << j << "]"
<< " value_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::ValueType,
sd.value_type_id.value,
short_guid_name(sd.value_type_id).c_str())
<< ", characteristic=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityCharacteristic,
sd.quantity_characteristic_id.value,
short_guid_name(sd.quantity_characteristic_id).c_str())
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(sd.quantity_units_id)
<< ", storage=" << pqdif_sem::FindStorageMethodFlagsName(sd.storage_method_id)
<< ", nominal=" << sd.nominal_quantity
<< ", percentile=" << sd.prob_percentile
<< std::endl;
}
}
}
size_t inst_hits = 0;
for (size_t obs_idx = 0; obs_idx < lf.observations.size(); ++obs_idx)
{
const auto& obs = lf.observations[obs_idx];
for (size_t ch_idx = 0; ch_idx < obs.channel_instances.size(); ++ch_idx)
{
const auto& ch = obs.channel_instances[ch_idx];
const PqdifChannelDefinition* def = find_channel_definition(lf, obs, ch);
if (!channel_instance_looks_like_harmonic(ch, def))
continue;
++inst_hits;
std::cout << " [HARM-INS " << inst_hits << "]"
<< " obs=" << obs_idx
<< ", obs_name=" << obs.observation_name
<< ", obs_start=" << obs.time_start.text
<< ", ch=" << ch.channel_instance_index
<< ", ch_def=" << ch.channel_def_index
<< ", name=" << ch.channel_name
<< ", def_name=" << (def != nullptr ? def->channel_name : std::string())
<< ", phase=" << pqdif_sem::FindPhaseName(ch.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(ch.quantity_measured_id)
<< ", qty_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityType,
ch.quantity_type_id.value,
short_guid_name(ch.quantity_type_id).c_str())
<< ", group=" << ch.channel_group_id
<< ", freq=" << ch.channel_frequency
<< ", primary_series=" << ch.primary_series_index
<< ", series_instances=" << ch.series_instances.size()
<< std::endl;
const size_t si_limit = std::min<size_t>(ch.series_instances.size(), 8);
for (size_t j = 0; j < si_limit; ++j)
{
const auto& si = ch.series_instances[j];
std::cout << " [HARM-SER-INS " << j << "]"
<< " value_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::ValueType,
si.value_type_id.value,
short_guid_name(si.value_type_id).c_str())
<< ", characteristic=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityCharacteristic,
si.quantity_characteristic_id.value,
short_guid_name(si.quantity_characteristic_id).c_str())
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(si.quantity_units_id)
<< ", base_q=" << si.series_base_quantity
<< ", nominal=" << si.nominal_quantity
<< ", scale=" << si.scale
<< ", offset=" << si.offset
<< ", share_ch=" << si.share_channel_index
<< ", share_ser=" << si.share_series_index
<< ", " << preview_value_array(si.values)
<< std::endl;
}
}
}
if (def_hits == 0 && inst_hits == 0)
{
std::cout << " [HARMONIC PROBE RESULT] no suspected harmonic channel found in definitions or observations"
<< std::endl;
}
else
{
std::cout << " [HARMONIC PROBE RESULT] definition_candidates=" << def_hits
<< ", observation_channel_candidates=" << inst_hits
<< std::endl;
}
std::cout << "=================================================" << std::endl;
}
int stat_make_channel_spectrum_order_hint(
const PqdifObservationRecord& obs,
const PqdifChannelInstance& ch,
int& block_offset,
int& block_size);
bool pqdif_probe_guid_is_harmonic_characteristic(const GUID& g)
{
return PQDIF_IsEqualGUID(g, ID_QC_HRMS) ||
PQDIF_IsEqualGUID(g, ID_QC_SPECTRA) ||
PQDIF_IsEqualGUID(g, ID_QC_SPECTRA_HGROUP);
}
bool pqdif_probe_guid_is_interharmonic_characteristic(const GUID& g)
{
return PQDIF_IsEqualGUID(g, ID_QC_SPECTRA_IGROUP);
}
bool pqdif_probe_guid_is_phase_angle_value_type(const GUID& g)
{
return PQDIF_IsEqualGUID(g, ID_SERIES_VALUE_TYPE_PHASEANGLE) ||
PQDIF_IsEqualGUID(g, ID_SERIES_VALUE_TYPE_PHASEANGLE_MIN) ||
PQDIF_IsEqualGUID(g, ID_SERIES_VALUE_TYPE_PHASEANGLE_MAX) ||
PQDIF_IsEqualGUID(g, ID_SERIES_VALUE_TYPE_PHASEANGLE_AVG);
}
bool pqdif_probe_text_looks_like_interharmonic(const std::string& text)
{
const std::string key = normalize_key(text);
return key.find("INTERHARM") != std::string::npos ||
key.find("INTERHARMONIC") != std::string::npos ||
key.find("IHARM") != std::string::npos ||
key.find("IGROUP") != std::string::npos ||
key.find("IHGROUP") != std::string::npos;
}
bool pqdif_probe_text_looks_like_angle(const std::string& text)
{
const std::string key = normalize_key(text);
return key.find("ANGLE") != std::string::npos ||
key.find("PHASEANGLE") != std::string::npos ||
key.find("PANGLE") != std::string::npos ||
key.find("HANGLE") != std::string::npos;
}
bool pqdif_probe_phase_is_line_voltage(unsigned int phase_id, const std::string& name)
{
if (phase_id == ID_PHASE_AB || phase_id == ID_PHASE_BC || phase_id == ID_PHASE_CA)
return true;
const std::string key = normalize_key(name);
return key.find("UAB") != std::string::npos || key.find("VAB") != std::string::npos ||
key.find("UBC") != std::string::npos || key.find("VBC") != std::string::npos ||
key.find("UCA") != std::string::npos || key.find("VCA") != std::string::npos ||
key.find("AB") != std::string::npos || key.find("BC") != std::string::npos || key.find("CA") != std::string::npos;
}
bool pqdif_probe_series_def_is_dynamic_candidate(const PqdifSeriesDefinition& sd)
{
return pqdif_probe_guid_is_harmonic_characteristic(sd.quantity_characteristic_id.value) ||
pqdif_probe_guid_is_interharmonic_characteristic(sd.quantity_characteristic_id.value) ||
pqdif_probe_guid_is_phase_angle_value_type(sd.value_type_id.value) ||
sd.quantity_units_id == ID_QU_DEGREES ||
text_looks_like_harmonic(sd.quantity_characteristic_id.symbolic_name) ||
pqdif_probe_text_looks_like_interharmonic(sd.quantity_characteristic_id.symbolic_name) ||
pqdif_probe_text_looks_like_angle(sd.value_type_id.symbolic_name);
}
bool pqdif_probe_series_ins_is_dynamic_candidate(const PqdifSeriesInstance& si)
{
return pqdif_probe_guid_is_harmonic_characteristic(si.quantity_characteristic_id.value) ||
pqdif_probe_guid_is_interharmonic_characteristic(si.quantity_characteristic_id.value) ||
pqdif_probe_guid_is_phase_angle_value_type(si.value_type_id.value) ||
si.quantity_units_id == ID_QU_DEGREES ||
is_integer_in_range(si.series_base_quantity, 2, 50) ||
is_integer_in_range(si.nominal_quantity, 2, 50) ||
text_looks_like_harmonic(si.quantity_characteristic_id.symbolic_name) ||
pqdif_probe_text_looks_like_interharmonic(si.quantity_characteristic_id.symbolic_name) ||
pqdif_probe_text_looks_like_angle(si.value_type_id.symbolic_name);
}
void dump_dynamic_spectrum_candidate_probe(const ParsedPqdifFile& parsed_file)
{
const auto& lf = parsed_file.logical_file;
const auto& reg = pqdif_sem::GetGuidSemanticRegistry();
std::cout << "========== PQDIF DYNAMIC SPECTRUM CANDIDATE PROBE ==========" << std::endl;
std::cout << "file=" << parsed_file.source_file << std::endl;
std::cout << "rule=DEBUG level: print all channel definitions/instances that look like harmonic, angle, interharmonic, spectra, HRMS, HGroup or IGroup" << std::endl;
size_t def_hits = 0;
size_t def_line_like = 0;
size_t def_inter_like = 0;
for (size_t ds_idx = 0; ds_idx < lf.data_sources.size(); ++ds_idx)
{
const auto& ds = lf.data_sources[ds_idx];
for (size_t ch_idx = 0; ch_idx < ds.channel_definitions.size(); ++ch_idx)
{
const auto& ch = ds.channel_definitions[ch_idx];
bool candidate = channel_definition_looks_like_harmonic(ch) ||
pqdif_probe_text_looks_like_interharmonic(ch.channel_name) ||
pqdif_probe_text_looks_like_angle(ch.channel_name);
for (const auto& sd : ch.series_definitions)
candidate = candidate || pqdif_probe_series_def_is_dynamic_candidate(sd);
if (!candidate)
continue;
const bool line_like = pqdif_probe_phase_is_line_voltage(ch.phase_id, ch.channel_name);
bool inter_like = pqdif_probe_text_looks_like_interharmonic(ch.channel_name);
bool angle_like = pqdif_probe_text_looks_like_angle(ch.channel_name);
bool harmonic_like = text_looks_like_harmonic(ch.channel_name);
for (const auto& sd : ch.series_definitions)
{
inter_like = inter_like || pqdif_probe_guid_is_interharmonic_characteristic(sd.quantity_characteristic_id.value) ||
pqdif_probe_text_looks_like_interharmonic(sd.quantity_characteristic_id.symbolic_name);
angle_like = angle_like || pqdif_probe_guid_is_phase_angle_value_type(sd.value_type_id.value) ||
sd.quantity_units_id == ID_QU_DEGREES || pqdif_probe_text_looks_like_angle(sd.value_type_id.symbolic_name);
harmonic_like = harmonic_like || pqdif_probe_guid_is_harmonic_characteristic(sd.quantity_characteristic_id.value) ||
text_looks_like_harmonic(sd.quantity_characteristic_id.symbolic_name);
}
++def_hits;
if (line_like) ++def_line_like;
if (inter_like) ++def_inter_like;
std::cout << " [DYN-DEF " << def_hits << "]"
<< " ds=" << ds_idx
<< ", ch_def=" << ch.channel_def_index
<< ", name=" << ch.channel_name
<< ", phase=" << pqdif_sem::FindPhaseName(ch.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(ch.quantity_measured_id)
<< ", line_like=" << (line_like ? "true" : "false")
<< ", harmonic_like=" << (harmonic_like ? "true" : "false")
<< ", interharmonic_like=" << (inter_like ? "true" : "false")
<< ", angle_like=" << (angle_like ? "true" : "false")
<< ", series_defs=" << ch.series_definitions.size()
<< std::endl;
for (size_t j = 0; j < ch.series_definitions.size(); ++j)
{
const auto& sd = ch.series_definitions[j];
if (!pqdif_probe_series_def_is_dynamic_candidate(sd) && !pqdif_is_trace_log_enabled())
continue;
std::cout << " [DYN-SER-DEF " << j << "]"
<< " value_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::ValueType,
sd.value_type_id.value,
short_guid_name(sd.value_type_id).c_str())
<< ", characteristic=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityCharacteristic,
sd.quantity_characteristic_id.value,
short_guid_name(sd.quantity_characteristic_id).c_str())
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(sd.quantity_units_id)
<< ", nominal=" << sd.nominal_quantity
<< ", percentile=" << sd.prob_percentile
<< std::endl;
}
}
}
size_t inst_hits = 0;
size_t inst_line_like = 0;
size_t inst_inter_like = 0;
for (size_t obs_idx = 0; obs_idx < lf.observations.size(); ++obs_idx)
{
const auto& obs = lf.observations[obs_idx];
for (size_t ch_idx = 0; ch_idx < obs.channel_instances.size(); ++ch_idx)
{
const auto& ch = obs.channel_instances[ch_idx];
const PqdifChannelDefinition* def = find_channel_definition(lf, obs, ch);
bool candidate = channel_instance_looks_like_harmonic(ch, def) ||
pqdif_probe_text_looks_like_interharmonic(ch.channel_name) ||
pqdif_probe_text_looks_like_angle(ch.channel_name);
for (const auto& si : ch.series_instances)
candidate = candidate || pqdif_probe_series_ins_is_dynamic_candidate(si);
if (!candidate)
continue;
const bool line_like = pqdif_probe_phase_is_line_voltage(ch.phase_id, ch.channel_name);
bool inter_like = pqdif_probe_text_looks_like_interharmonic(ch.channel_name);
bool angle_like = pqdif_probe_text_looks_like_angle(ch.channel_name);
bool harmonic_like = text_looks_like_harmonic(ch.channel_name);
for (const auto& si : ch.series_instances)
{
inter_like = inter_like || pqdif_probe_guid_is_interharmonic_characteristic(si.quantity_characteristic_id.value) ||
pqdif_probe_text_looks_like_interharmonic(si.quantity_characteristic_id.symbolic_name);
angle_like = angle_like || pqdif_probe_guid_is_phase_angle_value_type(si.value_type_id.value) ||
si.quantity_units_id == ID_QU_DEGREES || pqdif_probe_text_looks_like_angle(si.value_type_id.symbolic_name);
harmonic_like = harmonic_like || pqdif_probe_guid_is_harmonic_characteristic(si.quantity_characteristic_id.value) ||
text_looks_like_harmonic(si.quantity_characteristic_id.symbolic_name);
}
int hint_offset = -1;
int hint_size = 0;
const int hint_order = stat_make_channel_spectrum_order_hint(obs, ch, hint_offset, hint_size);
++inst_hits;
if (line_like) ++inst_line_like;
if (inter_like) ++inst_inter_like;
std::cout << " [DYN-INS " << inst_hits << "]"
<< " obs=" << obs_idx
<< ", obs_name=" << obs.observation_name
<< ", ch=" << ch.channel_instance_index
<< ", ch_def=" << ch.channel_def_index
<< ", name=" << ch.channel_name
<< ", def_name=" << (def != nullptr ? def->channel_name : std::string())
<< ", phase=" << pqdif_sem::FindPhaseName(ch.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(ch.quantity_measured_id)
<< ", group=" << ch.channel_group_id
<< ", order_hint=" << hint_order
<< ", hint_offset=" << hint_offset
<< ", hint_block_size=" << hint_size
<< ", line_like=" << (line_like ? "true" : "false")
<< ", harmonic_like=" << (harmonic_like ? "true" : "false")
<< ", interharmonic_like=" << (inter_like ? "true" : "false")
<< ", angle_like=" << (angle_like ? "true" : "false")
<< ", series_instances=" << ch.series_instances.size()
<< std::endl;
for (size_t j = 0; j < ch.series_instances.size(); ++j)
{
const auto& si = ch.series_instances[j];
if (!pqdif_probe_series_ins_is_dynamic_candidate(si) && !pqdif_is_trace_log_enabled())
continue;
std::cout << " [DYN-SER-INS " << j << "]"
<< " value_type=" << reg.FindName(
pqdif_sem::GuidSemanticField::ValueType,
si.value_type_id.value,
short_guid_name(si.value_type_id).c_str())
<< ", characteristic=" << reg.FindName(
pqdif_sem::GuidSemanticField::QuantityCharacteristic,
si.quantity_characteristic_id.value,
short_guid_name(si.quantity_characteristic_id).c_str())
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(si.quantity_units_id)
<< ", base_q=" << si.series_base_quantity
<< ", nominal=" << si.nominal_quantity
<< ", scale=" << si.scale
<< ", offset=" << si.offset
<< ", share_ch=" << si.share_channel_index
<< ", share_ser=" << si.share_series_index
<< ", " << preview_value_array(si.values)
<< std::endl;
}
}
}
std::cout << " [DYNAMIC SPECTRUM PROBE RESULT] definition_candidates=" << def_hits
<< ", definition_line_like=" << def_line_like
<< ", definition_interharmonic_like=" << def_inter_like
<< ", observation_channel_candidates=" << inst_hits
<< ", observation_line_like=" << inst_line_like
<< ", observation_interharmonic_like=" << inst_inter_like
<< std::endl;
std::cout << "==========================================================" << std::endl;
}
void dump_monitor_settings_probe(const ParsedPqdifFile& parsed_file)
{
const auto& lf = parsed_file.logical_file;
std::cout << "========== PQDIF MONITOR SETTINGS ==========" << std::endl;
std::cout << "settings_count=" << lf.monitor_settings.size() << std::endl;
for (size_t i = 0; i < lf.monitor_settings.size() && i < 3; ++i)
{
const auto& s = lf.monitor_settings[i];
std::cout << " [SET " << i << "]"
<< " effective=" << s.effective_time.text
<< ", nominal_freq=" << s.nominal_frequency
<< ", nominal_voltage=" << s.nominal_voltage
<< ", physical_connection=" << s.physical_connection
<< ", is_pcc=" << (s.is_pcc ? "true" : "false")
<< ", use_transducer=" << (s.use_transducer ? "true" : "false")
<< std::endl;
}
std::cout << "===========================================" << std::endl;
}
std::string stat_two_digit(int n);
int stat_dynamic_metric_base(StatMetricId id)
{
return static_cast<int>(id);
}
enum class StatDynamicMetricGroup
{
None = 0,
VoltageHarmonic,
LineVoltageHarmonic,
CurrentHarmonic,
VoltageHarmonicAngle,
LineVoltageHarmonicAngle,
CurrentHarmonicAngle,
HarmonicActivePower,
HarmonicReactivePower,
HarmonicApparentPower,
VoltageHarmonicRatio,
LineVoltageHarmonicRatio,
CurrentHarmonicRatio,
VoltageInterharmonic,
LineVoltageInterharmonic,
CurrentInterharmonic
};
struct StatDynamicMetricRange
{
StatDynamicMetricGroup group;
int base;
int phase_index;
const char* phase_label;
const char* prefix;
bool interharmonic;
};
const std::vector<StatDynamicMetricRange>& stat_dynamic_metric_ranges()
{
static const std::vector<StatDynamicMetricRange> ranges = {
{ StatDynamicMetricGroup::VoltageHarmonic, static_cast<int>(StatMetricId::VoltageHarmonicUaBase), 0, "a", "U", false },
{ StatDynamicMetricGroup::VoltageHarmonic, static_cast<int>(StatMetricId::VoltageHarmonicUbBase), 1, "b", "U", false },
{ StatDynamicMetricGroup::VoltageHarmonic, static_cast<int>(StatMetricId::VoltageHarmonicUcBase), 2, "c", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonic, static_cast<int>(StatMetricId::LineVoltageHarmonicUabBase), 0, "ab", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonic, static_cast<int>(StatMetricId::LineVoltageHarmonicUbcBase), 1, "bc", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonic, static_cast<int>(StatMetricId::LineVoltageHarmonicUcaBase), 2, "ca", "U", false },
{ StatDynamicMetricGroup::CurrentHarmonic, static_cast<int>(StatMetricId::CurrentHarmonicIaBase), 0, "a", "I", false },
{ StatDynamicMetricGroup::CurrentHarmonic, static_cast<int>(StatMetricId::CurrentHarmonicIbBase), 1, "b", "I", false },
{ StatDynamicMetricGroup::CurrentHarmonic, static_cast<int>(StatMetricId::CurrentHarmonicIcBase), 2, "c", "I", false },
{ StatDynamicMetricGroup::VoltageHarmonicAngle, static_cast<int>(StatMetricId::VoltageHarmonicAngleUaBase), 0, "a", "U", false },
{ StatDynamicMetricGroup::VoltageHarmonicAngle, static_cast<int>(StatMetricId::VoltageHarmonicAngleUbBase), 1, "b", "U", false },
{ StatDynamicMetricGroup::VoltageHarmonicAngle, static_cast<int>(StatMetricId::VoltageHarmonicAngleUcBase), 2, "c", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonicAngle, static_cast<int>(StatMetricId::LineVoltageHarmonicAngleUabBase), 0, "ab", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonicAngle, static_cast<int>(StatMetricId::LineVoltageHarmonicAngleUbcBase), 1, "bc", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonicAngle, static_cast<int>(StatMetricId::LineVoltageHarmonicAngleUcaBase), 2, "ca", "U", false },
{ StatDynamicMetricGroup::CurrentHarmonicAngle, static_cast<int>(StatMetricId::CurrentHarmonicAngleIaBase), 0, "a", "I", false },
{ StatDynamicMetricGroup::CurrentHarmonicAngle, static_cast<int>(StatMetricId::CurrentHarmonicAngleIbBase), 1, "b", "I", false },
{ StatDynamicMetricGroup::CurrentHarmonicAngle, static_cast<int>(StatMetricId::CurrentHarmonicAngleIcBase), 2, "c", "I", false },
{ StatDynamicMetricGroup::HarmonicActivePower, static_cast<int>(StatMetricId::HarmonicActivePowerPaBase), 0, "a", "P", false },
{ StatDynamicMetricGroup::HarmonicActivePower, static_cast<int>(StatMetricId::HarmonicActivePowerPbBase), 1, "b", "P", false },
{ StatDynamicMetricGroup::HarmonicActivePower, static_cast<int>(StatMetricId::HarmonicActivePowerPcBase), 2, "c", "P", false },
{ StatDynamicMetricGroup::HarmonicActivePower, static_cast<int>(StatMetricId::HarmonicActivePowerTotalBase), 3, "total", "P", false },
{ StatDynamicMetricGroup::HarmonicReactivePower, static_cast<int>(StatMetricId::HarmonicReactivePowerQaBase), 0, "a", "Q", false },
{ StatDynamicMetricGroup::HarmonicReactivePower, static_cast<int>(StatMetricId::HarmonicReactivePowerQbBase), 1, "b", "Q", false },
{ StatDynamicMetricGroup::HarmonicReactivePower, static_cast<int>(StatMetricId::HarmonicReactivePowerQcBase), 2, "c", "Q", false },
{ StatDynamicMetricGroup::HarmonicReactivePower, static_cast<int>(StatMetricId::HarmonicReactivePowerTotalBase), 3, "total", "Q", false },
{ StatDynamicMetricGroup::HarmonicApparentPower, static_cast<int>(StatMetricId::HarmonicApparentPowerSaBase), 0, "a", "S", false },
{ StatDynamicMetricGroup::HarmonicApparentPower, static_cast<int>(StatMetricId::HarmonicApparentPowerSbBase), 1, "b", "S", false },
{ StatDynamicMetricGroup::HarmonicApparentPower, static_cast<int>(StatMetricId::HarmonicApparentPowerScBase), 2, "c", "S", false },
{ StatDynamicMetricGroup::HarmonicApparentPower, static_cast<int>(StatMetricId::HarmonicApparentPowerTotalBase), 3, "total", "S", false },
{ StatDynamicMetricGroup::VoltageHarmonicRatio, static_cast<int>(StatMetricId::VoltageHarmonicRatioUaBase), 0, "a", "U", false },
{ StatDynamicMetricGroup::VoltageHarmonicRatio, static_cast<int>(StatMetricId::VoltageHarmonicRatioUbBase), 1, "b", "U", false },
{ StatDynamicMetricGroup::VoltageHarmonicRatio, static_cast<int>(StatMetricId::VoltageHarmonicRatioUcBase), 2, "c", "U", false },
{ StatDynamicMetricGroup::CurrentHarmonicRatio, static_cast<int>(StatMetricId::CurrentHarmonicRatioIaBase), 0, "a", "I", false },
{ StatDynamicMetricGroup::CurrentHarmonicRatio, static_cast<int>(StatMetricId::CurrentHarmonicRatioIbBase), 1, "b", "I", false },
{ StatDynamicMetricGroup::CurrentHarmonicRatio, static_cast<int>(StatMetricId::CurrentHarmonicRatioIcBase), 2, "c", "I", false },
{ StatDynamicMetricGroup::LineVoltageHarmonicRatio, static_cast<int>(StatMetricId::LineVoltageHarmonicRatioUabBase), 0, "ab", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonicRatio, static_cast<int>(StatMetricId::LineVoltageHarmonicRatioUbcBase), 1, "bc", "U", false },
{ StatDynamicMetricGroup::LineVoltageHarmonicRatio, static_cast<int>(StatMetricId::LineVoltageHarmonicRatioUcaBase), 2, "ca", "U", false },
{ StatDynamicMetricGroup::VoltageInterharmonic, static_cast<int>(StatMetricId::VoltageInterharmonicUaBase), 0, "a", "U", true },
{ StatDynamicMetricGroup::VoltageInterharmonic, static_cast<int>(StatMetricId::VoltageInterharmonicUbBase), 1, "b", "U", true },
{ StatDynamicMetricGroup::VoltageInterharmonic, static_cast<int>(StatMetricId::VoltageInterharmonicUcBase), 2, "c", "U", true },
{ StatDynamicMetricGroup::LineVoltageInterharmonic, static_cast<int>(StatMetricId::LineVoltageInterharmonicUabBase), 0, "ab", "U", true },
{ StatDynamicMetricGroup::LineVoltageInterharmonic, static_cast<int>(StatMetricId::LineVoltageInterharmonicUbcBase), 1, "bc", "U", true },
{ StatDynamicMetricGroup::LineVoltageInterharmonic, static_cast<int>(StatMetricId::LineVoltageInterharmonicUcaBase), 2, "ca", "U", true },
{ StatDynamicMetricGroup::CurrentInterharmonic, static_cast<int>(StatMetricId::CurrentInterharmonicIaBase), 0, "a", "I", true },
{ StatDynamicMetricGroup::CurrentInterharmonic, static_cast<int>(StatMetricId::CurrentInterharmonicIbBase), 1, "b", "I", true },
{ StatDynamicMetricGroup::CurrentInterharmonic, static_cast<int>(StatMetricId::CurrentInterharmonicIcBase), 2, "c", "I", true }
};
return ranges;
}
int stat_dynamic_metric_min_offset(bool interharmonic)
{
return interharmonic ? 0 : 2;
}
int stat_dynamic_metric_max_offset(bool interharmonic)
{
return interharmonic ? 49 : 50;
}
const StatDynamicMetricRange* stat_find_dynamic_metric_range(StatMetricId id)
{
const int v = static_cast<int>(id);
for (const auto& r : stat_dynamic_metric_ranges())
{
const int min_offset = stat_dynamic_metric_min_offset(r.interharmonic);
const int max_offset = stat_dynamic_metric_max_offset(r.interharmonic);
if (v >= r.base + min_offset && v <= r.base + max_offset)
return &r;
}
return nullptr;
}
bool stat_is_dynamic_metric(StatMetricId id)
{
return stat_find_dynamic_metric_range(id) != nullptr;
}
bool stat_is_dynamic_metric_group(StatMetricId id, StatDynamicMetricGroup group)
{
const StatDynamicMetricRange* r = stat_find_dynamic_metric_range(id);
return r != nullptr && r->group == group;
}
int stat_dynamic_metric_order_or_slot(StatMetricId id)
{
const StatDynamicMetricRange* r = stat_find_dynamic_metric_range(id);
if (r == nullptr)
return -1;
return static_cast<int>(id) - r->base;
}
double stat_dynamic_metric_order_value(StatMetricId id)
{
const StatDynamicMetricRange* r = stat_find_dynamic_metric_range(id);
if (r == nullptr)
return -1.0;
const int offset = stat_dynamic_metric_order_or_slot(id);
return r->interharmonic ? (static_cast<double>(offset) + 0.5) : static_cast<double>(offset);
}
StatMetricId stat_dynamic_metric_id(StatDynamicMetricGroup group, int phase_index, int offset)
{
for (const auto& r : stat_dynamic_metric_ranges())
{
if (r.group != group || r.phase_index != phase_index)
continue;
const int min_offset = stat_dynamic_metric_min_offset(r.interharmonic);
const int max_offset = stat_dynamic_metric_max_offset(r.interharmonic);
if (offset < min_offset || offset > max_offset)
return StatMetricId::Unknown;
return static_cast<StatMetricId>(r.base + offset);
}
return StatMetricId::Unknown;
}
std::string stat_format_interharmonic_slot(int slot)
{
char buf[16] = { 0 };
std::snprintf(buf, sizeof(buf), "%02dp5", slot);
return std::string(buf);
}
std::string stat_dynamic_metric_name(StatMetricId id)
{
const StatDynamicMetricRange* r = stat_find_dynamic_metric_range(id);
if (r == nullptr)
return "Unknown";
const int offset = stat_dynamic_metric_order_or_slot(id);
std::string phase(r->phase_label);
if (!phase.empty())
phase[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(phase[0])));
std::ostringstream os;
os << r->prefix << phase;
switch (r->group)
{
case StatDynamicMetricGroup::VoltageHarmonic:
case StatDynamicMetricGroup::LineVoltageHarmonic:
case StatDynamicMetricGroup::CurrentHarmonic:
os << "Harm" << stat_two_digit(offset);
break;
case StatDynamicMetricGroup::VoltageHarmonicAngle:
case StatDynamicMetricGroup::LineVoltageHarmonicAngle:
case StatDynamicMetricGroup::CurrentHarmonicAngle:
os << "HarmAng" << stat_two_digit(offset);
break;
case StatDynamicMetricGroup::HarmonicActivePower:
case StatDynamicMetricGroup::HarmonicReactivePower:
case StatDynamicMetricGroup::HarmonicApparentPower:
os << "Harm" << stat_two_digit(offset);
break;
case StatDynamicMetricGroup::VoltageHarmonicRatio:
case StatDynamicMetricGroup::LineVoltageHarmonicRatio:
case StatDynamicMetricGroup::CurrentHarmonicRatio:
os << "HarmRatio" << stat_two_digit(offset);
break;
case StatDynamicMetricGroup::VoltageInterharmonic:
case StatDynamicMetricGroup::LineVoltageInterharmonic:
case StatDynamicMetricGroup::CurrentInterharmonic:
os << "InterHarm" << stat_format_interharmonic_slot(offset);
break;
default:
os << "Dynamic" << offset;
break;
}
return os.str();
}
std::vector<StatMetricId> stat_dynamic_metric_order_for_group(StatDynamicMetricGroup group)
{
std::vector<StatMetricId> out;
for (const auto& r : stat_dynamic_metric_ranges())
{
if (r.group != group)
continue;
const int min_offset = stat_dynamic_metric_min_offset(r.interharmonic);
const int max_offset = stat_dynamic_metric_max_offset(r.interharmonic);
for (int offset = min_offset; offset <= max_offset; ++offset)
out.push_back(static_cast<StatMetricId>(r.base + offset));
}
return out;
}
std::vector<StatMetricId> stat_all_dynamic_metric_order()
{
std::vector<StatMetricId> out;
const std::vector<StatDynamicMetricGroup> groups = {
StatDynamicMetricGroup::VoltageHarmonic,
StatDynamicMetricGroup::LineVoltageHarmonic,
StatDynamicMetricGroup::CurrentHarmonic,
StatDynamicMetricGroup::VoltageHarmonicAngle,
StatDynamicMetricGroup::LineVoltageHarmonicAngle,
StatDynamicMetricGroup::CurrentHarmonicAngle,
StatDynamicMetricGroup::HarmonicActivePower,
StatDynamicMetricGroup::HarmonicReactivePower,
StatDynamicMetricGroup::HarmonicApparentPower,
StatDynamicMetricGroup::VoltageHarmonicRatio,
StatDynamicMetricGroup::LineVoltageHarmonicRatio,
StatDynamicMetricGroup::CurrentHarmonicRatio,
StatDynamicMetricGroup::VoltageInterharmonic,
StatDynamicMetricGroup::LineVoltageInterharmonic,
StatDynamicMetricGroup::CurrentInterharmonic
};
for (auto g : groups)
{
auto part = stat_dynamic_metric_order_for_group(g);
out.insert(out.end(), part.begin(), part.end());
}
return out;
}
/// @brief 兼容旧调用：判断三相电压 2-50 次谐波 RMS。
bool stat_is_voltage_harmonic_metric(StatMetricId id)
{
return stat_is_dynamic_metric_group(id, StatDynamicMetricGroup::VoltageHarmonic);
}
int stat_voltage_harmonic_order(StatMetricId id)
{
if (!stat_is_voltage_harmonic_metric(id))
return -1;
return stat_dynamic_metric_order_or_slot(id);
}
int stat_voltage_harmonic_phase_index(StatMetricId id)
{
const StatDynamicMetricRange* r = stat_find_dynamic_metric_range(id);
if (r == nullptr || r->group != StatDynamicMetricGroup::VoltageHarmonic)
return -1;
return r->phase_index;
}
StatMetricId stat_voltage_harmonic_metric_id(int phase_index, int order)
{
return stat_dynamic_metric_id(StatDynamicMetricGroup::VoltageHarmonic, phase_index, order);
}
std::string stat_voltage_harmonic_metric_name(StatMetricId id)
{
return stat_dynamic_metric_name(id);
}
/// @brief 将业务指标 ID 转为可读字符串。
/// @param id 业务指标枚举。
/// @return 指标名称字符串，便于调试日志输出。
std::string stat_metric_name(StatMetricId id)
{
if (stat_is_dynamic_metric(id))
return stat_dynamic_metric_name(id);
switch (id)
{
case StatMetricId::UaRms: return "UaRms";
case StatMetricId::UbRms: return "UbRms";
case StatMetricId::UcRms: return "UcRms";
case StatMetricId::IaRms: return "IaRms";
case StatMetricId::IbRms: return "IbRms";
case StatMetricId::IcRms: return "IcRms";
case StatMetricId::UabRms: return "UabRms";
case StatMetricId::UbcRms: return "UbcRms";
case StatMetricId::UcaRms: return "UcaRms";
case StatMetricId::UaDeviation: return "UaDeviation";
case StatMetricId::UbDeviation: return "UbDeviation";
case StatMetricId::UcDeviation: return "UcDeviation";
case StatMetricId::UabDeviation: return "UabDeviation";
case StatMetricId::UbcDeviation: return "UbcDeviation";
case StatMetricId::UcaDeviation: return "UcaDeviation";
case StatMetricId::Frequency: return "Frequency";
case StatMetricId::FrequencyDeviation: return "FrequencyDeviation";
case StatMetricId::UZeroSeq: return "UZeroSeq";
case StatMetricId::UNegSeq: return "UNegSeq";
case StatMetricId::UPosSeq: return "UPosSeq";
case StatMetricId::UNegSeqUnbalance: return "UNegSeqUnbalance";
case StatMetricId::IZeroSeq: return "IZeroSeq";
case StatMetricId::INegSeq: return "INegSeq";
case StatMetricId::IPosSeq: return "IPosSeq";
case StatMetricId::INegSeqUnbalance: return "INegSeqUnbalance";
case StatMetricId::PaPower: return "PaPower";
case StatMetricId::PbPower: return "PbPower";
case StatMetricId::PcPower: return "PcPower";
case StatMetricId::PTotalPower: return "PTotalPower";
case StatMetricId::QaPower: return "QaPower";
case StatMetricId::QbPower: return "QbPower";
case StatMetricId::QcPower: return "QcPower";
case StatMetricId::QTotalPower: return "QTotalPower";
case StatMetricId::SaPower: return "SaPower";
case StatMetricId::SbPower: return "SbPower";
case StatMetricId::ScPower: return "ScPower";
case StatMetricId::STotalPower: return "STotalPower";
case StatMetricId::PFa: return "PFa";
case StatMetricId::PFb: return "PFb";
case StatMetricId::PFc: return "PFc";
case StatMetricId::PFTotal: return "PFTotal";
case StatMetricId::FundPFa: return "FundPFa";
case StatMetricId::FundPFb: return "FundPFb";
case StatMetricId::FundPFc: return "FundPFc";
case StatMetricId::FundPFTotal: return "FundPFTotal";
case StatMetricId::UaDvc: return "UaDvc";
case StatMetricId::UbDvc: return "UbDvc";
case StatMetricId::UcDvc: return "UcDvc";
case StatMetricId::UabDvc: return "UabDvc";
case StatMetricId::UbcDvc: return "UbcDvc";
case StatMetricId::UcaDvc: return "UcaDvc";
case StatMetricId::UaPst: return "UaPst";
case StatMetricId::UbPst: return "UbPst";
case StatMetricId::UcPst: return "UcPst";
case StatMetricId::UabPst: return "UabPst";
case StatMetricId::UbcPst: return "UbcPst";
case StatMetricId::UcaPst: return "UcaPst";
case StatMetricId::UaPlt: return "UaPlt";
case StatMetricId::UbPlt: return "UbPlt";
case StatMetricId::UcPlt: return "UcPlt";
case StatMetricId::UabPlt: return "UabPlt";
case StatMetricId::UbcPlt: return "UbcPlt";
case StatMetricId::UcaPlt: return "UcaPlt";
case StatMetricId::PaFundPower: return "PaFundPower";
case StatMetricId::PbFundPower: return "PbFundPower";
case StatMetricId::PcFundPower: return "PcFundPower";
case StatMetricId::PTotalFundPower: return "PTotalFundPower";
case StatMetricId::QaFundPower: return "QaFundPower";
case StatMetricId::QbFundPower: return "QbFundPower";
case StatMetricId::QcFundPower: return "QcFundPower";
case StatMetricId::QTotalFundPower: return "QTotalFundPower";
case StatMetricId::SaFundPower: return "SaFundPower";
case StatMetricId::SbFundPower: return "SbFundPower";
case StatMetricId::ScFundPower: return "ScFundPower";
case StatMetricId::STotalFundPower: return "STotalFundPower";
case StatMetricId::UaFundRms: return "UaFundRms";
case StatMetricId::UbFundRms: return "UbFundRms";
case StatMetricId::UcFundRms: return "UcFundRms";
case StatMetricId::UaFundAngle: return "UaFundAngle";
case StatMetricId::UbFundAngle: return "UbFundAngle";
case StatMetricId::UcFundAngle: return "UcFundAngle";
case StatMetricId::IaFundRms: return "IaFundRms";
case StatMetricId::IbFundRms: return "IbFundRms";
case StatMetricId::IcFundRms: return "IcFundRms";
case StatMetricId::IaFundAngle: return "IaFundAngle";
case StatMetricId::IbFundAngle: return "IbFundAngle";
case StatMetricId::IcFundAngle: return "IcFundAngle";
case StatMetricId::UabFundRms: return "UabFundRms";
case StatMetricId::UbcFundRms: return "UbcFundRms";
case StatMetricId::UcaFundRms: return "UcaFundRms";
case StatMetricId::UabFundAngle: return "UabFundAngle";
case StatMetricId::UbcFundAngle: return "UbcFundAngle";
case StatMetricId::UcaFundAngle: return "UcaFundAngle";
case StatMetricId::UaThd: return "UaThd";
case StatMetricId::UbThd: return "UbThd";
case StatMetricId::UcThd: return "UcThd";
case StatMetricId::IaThd: return "IaThd";
case StatMetricId::IbThd: return "IbThd";
case StatMetricId::IcThd: return "IcThd";
case StatMetricId::UabThd: return "UabThd";
case StatMetricId::UbcThd: return "UbcThd";
case StatMetricId::UcaThd: return "UcaThd";
default: return "Unknown";
}
}
/// @brief 将统计值类型转为可读字符串。
/// @param kind 统计值类型。
/// @return 统计值类型名称。
std::string stat_value_kind_name(StatValueKind kind)
{
switch (kind)
{
case StatValueKind::Min: return "Min";
case StatValueKind::Max: return "Max";
case StatValueKind::Avg: return "Avg";
case StatValueKind::P95: return "P95";
default: return "Unknown";
}
}
/// @brief 将接线方式枚举转为可读字符串。
/// @param kind 接线方式枚举。
/// @return 可读字符串。
std::string stat_connection_kind_name(ParsedConnectionKind kind)
{
switch (kind)
{
case ParsedConnectionKind::Wye: return "Wye";
case ParsedConnectionKind::Delta: return "Delta";
default: return "Unknown";
}
}
/// @brief 将指标质量状态转为可读字符串。
/// @param q 指标质量状态。
/// @return 可读质量状态名称。
std::string stat_metric_quality_name(StatMetricQuality q)
{
switch (q)
{
case StatMetricQuality::Normal: return "OK";
case StatMetricQuality::AllZero: return "ALL_ZERO";
case StatMetricQuality::DuplicateSource: return "DUPLICATE_SOURCE";
case StatMetricQuality::SuspiciousRange: return "SUSPICIOUS_RANGE";
case StatMetricQuality::Missing: return "MISSING";
default: return "UNKNOWN";
}
}
/// @brief 非谐波核心指标打印顺序。
/// @details 平时核心日志只打印这些指标，避免 2-50 次谐波全部展开导致日志过大。
const std::vector<StatMetricId>& stat_core_metric_print_order()
{
static const std::vector<StatMetricId> order = {
StatMetricId::UaRms,
StatMetricId::UbRms,
StatMetricId::UcRms,
StatMetricId::IaRms,
StatMetricId::IbRms,
StatMetricId::IcRms,
StatMetricId::UabRms,
StatMetricId::UbcRms,
StatMetricId::UcaRms,
StatMetricId::UaDeviation,
StatMetricId::UbDeviation,
StatMetricId::UcDeviation,
StatMetricId::Frequency,
StatMetricId::FrequencyDeviation,
StatMetricId::UZeroSeq,
StatMetricId::UNegSeq,
StatMetricId::UPosSeq,
StatMetricId::UNegSeqUnbalance,
StatMetricId::IZeroSeq,
StatMetricId::INegSeq,
StatMetricId::IPosSeq,
StatMetricId::INegSeqUnbalance,
StatMetricId::PaPower,
StatMetricId::PbPower,
StatMetricId::PcPower,
StatMetricId::PTotalPower,
StatMetricId::QaPower,
StatMetricId::QbPower,
StatMetricId::QcPower,
StatMetricId::QTotalPower,
StatMetricId::SaPower,
StatMetricId::SbPower,
StatMetricId::ScPower,
StatMetricId::STotalPower,
StatMetricId::PFa,
StatMetricId::PFb,
StatMetricId::PFc,
StatMetricId::PFTotal,
StatMetricId::FundPFa,
StatMetricId::FundPFb,
StatMetricId::FundPFc,
StatMetricId::FundPFTotal,
StatMetricId::UaDvc,
StatMetricId::UbDvc,
StatMetricId::UcDvc,
StatMetricId::UabDvc,
StatMetricId::UbcDvc,
StatMetricId::UcaDvc,
StatMetricId::UaPst,
StatMetricId::UbPst,
StatMetricId::UcPst,
StatMetricId::UabPst,
StatMetricId::UbcPst,
StatMetricId::UcaPst,
StatMetricId::UaPlt,
StatMetricId::UbPlt,
StatMetricId::UcPlt,
StatMetricId::UabPlt,
StatMetricId::UbcPlt,
StatMetricId::UcaPlt,
StatMetricId::PaFundPower,
StatMetricId::PbFundPower,
StatMetricId::PcFundPower,
StatMetricId::PTotalFundPower,
StatMetricId::QaFundPower,
StatMetricId::QbFundPower,
StatMetricId::QcFundPower,
StatMetricId::QTotalFundPower,
StatMetricId::SaFundPower,
StatMetricId::SbFundPower,
StatMetricId::ScFundPower,
StatMetricId::STotalFundPower,
StatMetricId::UaFundRms,
StatMetricId::UbFundRms,
StatMetricId::UcFundRms,
StatMetricId::UaFundAngle,
StatMetricId::UbFundAngle,
StatMetricId::UcFundAngle,
StatMetricId::IaFundRms,
StatMetricId::IbFundRms,
StatMetricId::IcFundRms,
StatMetricId::IaFundAngle,
StatMetricId::IbFundAngle,
StatMetricId::IcFundAngle,
StatMetricId::UabFundRms,
StatMetricId::UbcFundRms,
StatMetricId::UcaFundRms,
StatMetricId::UabFundAngle,
StatMetricId::UbcFundAngle,
StatMetricId::UcaFundAngle,
StatMetricId::UaThd,
StatMetricId::UbThd,
StatMetricId::UcThd,
StatMetricId::IaThd,
StatMetricId::IbThd,
StatMetricId::IcThd,
StatMetricId::UabThd,
StatMetricId::UbcThd,
StatMetricId::UcaThd
};
return order;
}
/// @brief 动态生成三相电压 2-50 次谐波指标顺序。
/// @details 兼容旧调用；新的谐波/间谐波族统一走 stat_dynamic_metric_order_for_group / stat_all_dynamic_metric_order。
std::vector<StatMetricId> stat_voltage_harmonic_metric_order()
{
return stat_dynamic_metric_order_for_group(StatDynamicMetricGroup::VoltageHarmonic);
}
/// @brief 当前全部主要指标打印顺序。
/// @details 核心 22 项 + 所有动态谐波/间谐波指标。动态指标不逐项写 enum，统一按族和区间生成。
const std::vector<StatMetricId>& stat_primary_metric_print_order()
{
static const std::vector<StatMetricId> order = []() {
std::vector<StatMetricId> out = stat_core_metric_print_order();
const std::vector<StatMetricId> dynamic_metrics = stat_all_dynamic_metric_order();
out.insert(out.end(), dynamic_metrics.begin(), dynamic_metrics.end());
return out;
}();
return order;
}
/// @brief 已声明但当前 14 项之外的扩展指标打印顺序。
/// @details 这些指标不会计入“14 项”，但如果后续规则命中，也会在日志末尾显示，便于扩展核查。
const std::vector<StatMetricId>& stat_extra_metric_print_order()
{
static const std::vector<StatMetricId> order = {
StatMetricId::UabDeviation,
StatMetricId::UbcDeviation,
StatMetricId::UcaDeviation
};
return order;
}
bool stat_is_line_voltage_metric(StatMetricId id)
{
return id == StatMetricId::UabRms ||
id == StatMetricId::UbcRms ||
id == StatMetricId::UcaRms;
}
bool stat_is_phase_voltage_metric(StatMetricId id)
{
return id == StatMetricId::UaRms ||
id == StatMetricId::UbRms ||
id == StatMetricId::UcRms;
}
bool stat_is_current_metric(StatMetricId id)
{
return id == StatMetricId::IaRms ||
id == StatMetricId::IbRms ||
id == StatMetricId::IcRms;
}
bool stat_is_frequency_metric(StatMetricId id)
{
return id == StatMetricId::Frequency || id == StatMetricId::FrequencyDeviation;
}
bool stat_is_voltage_sequence_component_metric(StatMetricId id)
{
return id == StatMetricId::UZeroSeq ||
id == StatMetricId::UNegSeq ||
id == StatMetricId::UPosSeq;
}
bool stat_is_voltage_sequence_unbalance_metric(StatMetricId id)
{
return id == StatMetricId::UNegSeqUnbalance;
}
bool stat_is_current_sequence_component_metric(StatMetricId id)
{
return id == StatMetricId::IZeroSeq ||
id == StatMetricId::INegSeq ||
id == StatMetricId::IPosSeq;
}
bool stat_is_current_sequence_unbalance_metric(StatMetricId id)
{
return id == StatMetricId::INegSeqUnbalance;
}
bool stat_allow_all_zero_without_score_penalty(StatMetricId id)
{
return stat_is_current_metric(id) ||
stat_is_dynamic_metric(id) ||
id == StatMetricId::UZeroSeq ||
id == StatMetricId::UNegSeq ||
id == StatMetricId::UNegSeqUnbalance ||
stat_is_current_sequence_component_metric(id) ||
stat_is_current_sequence_unbalance_metric(id);
}
bool stat_has_value_kind(const AggregatedStatValues& agg, StatValueKind kind)
{
switch (kind)
{
case StatValueKind::Min: return agg.has_min;
case StatValueKind::Max: return agg.has_max;
case StatValueKind::Avg: return agg.has_avg;
case StatValueKind::P95: return agg.has_p95;
default: return false;
}
}
double stat_get_value_by_kind(const AggregatedStatValues& agg, StatValueKind kind)
{
switch (kind)
{
case StatValueKind::Min: return agg.min_value;
case StatValueKind::Max: return agg.max_value;
case StatValueKind::Avg: return agg.avg_value;
case StatValueKind::P95: return agg.p95_value;
default: return 0.0;
}
}
/// @brief 根据 observation 找到其关联的数据源定义。
/// @param lf 已解析完成的完整 PQDIF 逻辑对象。
/// @param obs 当前 observation。
/// @return 关联到的数据源定义指针；找不到时返回 nullptr。
const PqdifDataSourceRecord* stat_find_related_data_source(
const PqdifLogicalFile& lf,
const PqdifObservationRecord& obs)
{
if (obs.related_data_source_index >= 0 &&
static_cast<size_t>(obs.related_data_source_index) < lf.data_sources.size())
{
return &lf.data_sources[static_cast<size_t>(obs.related_data_source_index)];
}
if (!lf.data_sources.empty())
return &lf.data_sources.front();
return nullptr;
}
/// @brief 根据通道定义索引查找通道定义。
/// @param ds 数据源定义指针。
/// @param channel_def_index 通道定义索引。
/// @return 通道定义指针；找不到时返回 nullptr。
const PqdifChannelDefinition* stat_find_channel_definition(
const PqdifDataSourceRecord* ds,
int channel_def_index)
{
if (ds == nullptr || channel_def_index < 0)
return nullptr;
const size_t idx = static_cast<size_t>(channel_def_index);
if (idx >= ds->channel_definitions.size())
return nullptr;
return &ds->channel_definitions[idx];
}
/// @brief 根据序列定义索引查找序列定义。
/// @param ch_def 通道定义指针。
/// @param series_def_index 序列定义索引。
/// @return 序列定义指针；找不到时返回 nullptr。
const PqdifSeriesDefinition* stat_find_series_definition(
const PqdifChannelDefinition* ch_def,
int series_def_index)
{
if (ch_def == nullptr || series_def_index < 0)
return nullptr;
const size_t idx = static_cast<size_t>(series_def_index);
if (idx >= ch_def->series_definitions.size())
return nullptr;
return &ch_def->series_definitions[idx];
}
/// @brief 根据 monitor settings 与相别分布识别接线方式。
/// @details
/// 优先使用正式配置字段 physical_connection；若不可用，则回退到相别启发式判断。
/// @param lf 已解析完成的完整 PQDIF 逻辑对象。
/// @return 识别出的接线方式。
ParsedConnectionKind stat_classify_connection_kind(const PqdifLogicalFile& lf)
{
if (!lf.monitor_settings.empty())
{
const unsigned int pc = lf.monitor_settings.front().physical_connection;
switch (pc)
{
case ID_2_5ELEMENT_WYE:
case ID_3ELMENT_WYE:
return ParsedConnectionKind::Wye;
case ID_2ELEMENT_DELTA:
case ID_3ELEMENT_DELTA:
return ParsedConnectionKind::Delta;
default:
break;
}
}
bool has_phase_to_neutral = false;
bool has_line_to_line = false;
for (const auto& ds : lf.data_sources)
{
for (const auto& ch : ds.channel_definitions)
{
if (ch.phase_id == ID_PHASE_AN || ch.phase_id == ID_PHASE_BN || ch.phase_id == ID_PHASE_CN)
has_phase_to_neutral = true;
if (ch.phase_id == ID_PHASE_AB || ch.phase_id == ID_PHASE_BC || ch.phase_id == ID_PHASE_CA)
has_line_to_line = true;
}
}
if (has_phase_to_neutral)
return ParsedConnectionKind::Wye;
if (has_line_to_line)
return ParsedConnectionKind::Delta;
return ParsedConnectionKind::Unknown;
}
/// @brief 判断 observation 是否为当前阶段需要处理的“统计类 observation”。
/// @details
/// 当前阶段不处理全部 observation，而是先筛出统计类 observation。判断顺序：
/// 1) 触发方式为 ID_TRIGGER_METH_PERIODIC_STATS；
/// 2) 名称中包含 TREND / STAT / STATISTIC；
/// 3) 只要 observation 下有 VALUELOG 型通道，也认为它是统计 observation。
/// @param obs 当前 observation。
/// @param lf 完整 PQDIF 逻辑对象。
/// @return 若是统计类 observation，则返回 true。
bool stat_is_statistical_observation(
const PqdifLogicalFile& lf,
const PqdifObservationRecord& obs)
{
if (obs.trigger_method_id == ID_TRIGGER_METH_PERIODIC_STATS)
return true;
auto compact = [&](const std::string& s) {
std::string out;
for (unsigned char ch : s)
{
if (std::isalnum(ch))
out.push_back(static_cast<char>(std::toupper(ch)));
}
return out;
};
const std::string obs_name = compact(obs.observation_name);
if (obs_name.find("TREND") != std::string::npos ||
obs_name.find("STAT") != std::string::npos ||
obs_name.find("STATISTIC") != std::string::npos)
{
return true;
}
for (const auto& ch : obs.channel_instances)
{
if (pqdif_sem::IsQuantityTypeValueLog(ch.quantity_type_id.value))
return true;
}
(void)lf;
return false;
}
/// @brief 选择当前阶段要处理的“主统计 observation”。
/// @details
/// 当前阶段为了避免不同 observation 在同一 timestamp 上相互覆盖，
/// 只选择第一条命中的统计类 observation 参与识别与聚合。
/// @param lf 完整 PQDIF 逻辑对象。
/// @return 命中的 observation 指针；若没有则返回 nullptr。
const PqdifObservationRecord* stat_select_primary_statistical_observation(const PqdifLogicalFile& lf)
{
for (const auto& obs : lf.observations)
{
if (stat_is_statistical_observation(lf, obs))
return &obs;
}
return nullptr;
}
/// @brief 解析共享序列。
/// @details
/// 某些序列自身没有 values，而是通过 share_channel_index/share_series_index
/// 共享另一个序列的数组值，例如 B/C 相共享 A 相时间轴。
/// @param obs 当前 observation。
/// @param si 当前序列实例。
/// @return 最终应使用的“真实值序列实例”指针。
const PqdifSeriesInstance* stat_resolve_shared_series(
const PqdifObservationRecord& obs,
const PqdifSeriesInstance& si)
{
const PqdifSeriesInstance* current = &si;
for (int depth = 0; depth < 8; ++depth)
{
if (current->values.count > 0)
return current;
if (current->share_channel_index < 0 || current->share_series_index < 0)
return current;
const size_t ch_idx = static_cast<size_t>(current->share_channel_index);
const size_t ser_idx = static_cast<size_t>(current->share_series_index);
if (ch_idx >= obs.channel_instances.size())
return current;
const auto& shared_ch = obs.channel_instances[ch_idx];
if (ser_idx >= shared_ch.series_instances.size())
return current;
const PqdifSeriesInstance* next = &shared_ch.series_instances[ser_idx];
if (next == current)
return current;
current = next;
}
return current;
}
/// @brief 从数组容器中读取指定下标的原始数值。
/// @details 支持 real/int/uint/bool。
/// @param arr 数组容器。
/// @param idx 样本下标。
/// @param out_raw 返回原始数值。
/// @return 成功读取返回 true，否则返回 false。
bool stat_try_get_raw_numeric_at(const PqdifValueArray& arr, size_t idx, double& out_raw)
{
if (idx < arr.real_values.size())
{
out_raw = arr.real_values[idx];
return true;
}
if (idx < arr.int_values.size())
{
out_raw = static_cast<double>(arr.int_values[idx]);
return true;
}
if (idx < arr.uint_values.size())
{
out_raw = static_cast<double>(arr.uint_values[idx]);
return true;
}
if (idx < arr.bool_values.size())
{
out_raw = arr.bool_values[idx] ? 1.0 : 0.0;
return true;
}
return false;
}
/// @brief 将原始值还原为工程值。
/// @details
/// 当序列存储方式包含 SCALED 且底层值是整型时，使用 raw*scale+offset；
/// 其他情况默认认为原始值即为工程值。
/// @param raw_value 原始数值。
/// @param si 序列实例，用于读取 scale/offset。
/// @param storage_method_id 序列定义层的存储方式。
/// @param physical_type 当前数组的物理类型。
/// @return 工程值。
double stat_decode_engineering_value(
double raw_value,
const PqdifSeriesInstance& si,
unsigned int storage_method_id,
int physical_type)
{
const bool integer_like =
physical_type == ID_PHYS_TYPE_INTEGER1 ||
physical_type == ID_PHYS_TYPE_INTEGER2 ||
physical_type == ID_PHYS_TYPE_INTEGER4 ||
physical_type == ID_PHYS_TYPE_UNS_INTEGER1 ||
physical_type == ID_PHYS_TYPE_UNS_INTEGER2 ||
physical_type == ID_PHYS_TYPE_UNS_INTEGER4;
if ((storage_method_id & ID_SERIES_METHOD_SCALED) && integer_like)
return raw_value * si.scale + si.offset;
return raw_value;
}
/// @brief 解析某一个样本点对应的绝对时刻。
/// @details
/// 优先使用 timestamp_values；若时间序列是数值型，则按
/// observation.time_start + 偏移秒 计算。
/// @param obs 当前 observation。
/// @param time_series 已解析出的时间序列实例。
/// @param idx 样本下标。
/// @param out_ts 返回绝对时刻。
/// @return 成功返回 true，否则返回 false。
bool stat_resolve_timestamp_at(
const PqdifObservationRecord& obs,
const PqdifSeriesInstance& time_series,
size_t idx,
time_t& out_ts)
{
if (idx < time_series.values.timestamp_values.size())
{
out_ts = time_series.values.timestamp_values[idx].unix_time;
return true;
}
double raw_time = 0.0;
if (stat_try_get_raw_numeric_at(time_series.values, idx, raw_time))
{
if (obs.time_start.unix_time != 0)
{
out_ts = obs.time_start.unix_time + static_cast<time_t>(std::llround(raw_time));
return true;
}
out_ts = static_cast<time_t>(std::llround(raw_time));
return true;
}
return false;
}
/// @brief 判断 GUID 是否相等。
/// @param a GUID A。
/// @param b GUID B。
/// @return 相等返回 true。
bool stat_guid_equals(const GUID& a, const GUID& b)
{
return PQDIF_IsEqualGUID(a, b);
}
/// @brief 判断是否为旧式 P95 值类型。
/// @param value_type_id 值类型 GUID。
/// @return 若是旧式 P95 值类型则返回 true。
bool stat_is_p95_value_type(const GUID& value_type_id)
{
return stat_guid_equals(value_type_id, ID_SERIES_VALUE_TYPE_P95);
}
/// @brief 识别序列属于哪一种统计值类型。
/// @details 支持 MIN / MAX / AVG / P95。
/// @param si 序列实例。
/// @param sd 关联的序列定义，可为空。
/// @return 识别出的统计值类型。
StatValueKind stat_identify_value_kind(
const PqdifSeriesInstance& si,
const PqdifSeriesDefinition* sd)
{
if (pqdif_sem::IsValueTypeMin(si.value_type_id.value) ||
stat_guid_equals(si.value_type_id.value, ID_SERIES_VALUE_TYPE_PHASEANGLE_MIN))
return StatValueKind::Min;
if (pqdif_sem::IsValueTypeMax(si.value_type_id.value) ||
stat_guid_equals(si.value_type_id.value, ID_SERIES_VALUE_TYPE_PHASEANGLE_MAX))
return StatValueKind::Max;
if (pqdif_sem::IsValueTypeAvg(si.value_type_id.value) ||
stat_guid_equals(si.value_type_id.value, ID_SERIES_VALUE_TYPE_PHASEANGLE_AVG))
return StatValueKind::Avg;
if (stat_is_p95_value_type(si.value_type_id.value))
return StatValueKind::P95;
if (sd != nullptr && std::fabs(sd->prob_percentile - 95.0) < 1e-6)
return StatValueKind::P95;
return StatValueKind::Unknown;
}
/// @brief 判断是否为可以用“单值序列”兜底填充 Min/Max/Avg/P95 的指标。
/// @details 部分 PQDIF 厂家会把 Pst/Plt/DVC 这类已经是统计窗口结果的量，
/// 存成 Value/Instantaneous 单序列，而不是四条 Min/Max/Avg/P95 序列。
bool stat_metric_can_use_scalar_series_as_all_kinds(StatMetricId id)
{
switch (id)
{
case StatMetricId::UaDvc:
case StatMetricId::UbDvc:
case StatMetricId::UcDvc:
case StatMetricId::UabDvc:
case StatMetricId::UbcDvc:
case StatMetricId::UcaDvc:
case StatMetricId::UaPst:
case StatMetricId::UbPst:
case StatMetricId::UcPst:
case StatMetricId::UabPst:
case StatMetricId::UbcPst:
case StatMetricId::UcaPst:
case StatMetricId::UaPlt:
case StatMetricId::UbPlt:
case StatMetricId::UcPlt:
case StatMetricId::UabPlt:
case StatMetricId::UbcPlt:
case StatMetricId::UcaPlt:
return true;
default:
return false;
}
}
/// @brief 判断未知值类型序列是否可作为 Pst/Plt/DVC 的单值数据序列。
/// @details 排除时间轴、状态、计数、区间等非物理量序列，避免把质量标志误写成指标值。
bool stat_series_can_be_scalar_stat_value(
const PqdifSeriesInstance& si,
const PqdifSeriesDefinition* sd)
{
const GUID& vt = si.value_type_id.value;
if (pqdif_sem::IsValueTypeTime(vt) ||
stat_guid_equals(vt, ID_SERIES_VALUE_TYPE_TIME) ||
stat_guid_equals(vt, ID_SERIES_VALUE_TYPE_STATUS) ||
stat_guid_equals(vt, ID_SERIES_VALUE_TYPE_COUNT) ||
stat_guid_equals(vt, ID_SERIES_VALUE_TYPE_INTERVAL) ||
stat_guid_equals(vt, ID_SERIES_VALUE_TYPE_DURATION))
{
return false;
}
if (sd != nullptr)
{
const GUID& def_vt = sd->value_type_id.value;
if (pqdif_sem::IsValueTypeTime(def_vt) ||
stat_guid_equals(def_vt, ID_SERIES_VALUE_TYPE_TIME) ||
stat_guid_equals(def_vt, ID_SERIES_VALUE_TYPE_STATUS) ||
stat_guid_equals(def_vt, ID_SERIES_VALUE_TYPE_COUNT) ||
stat_guid_equals(def_vt, ID_SERIES_VALUE_TYPE_INTERVAL) ||
stat_guid_equals(def_vt, ID_SERIES_VALUE_TYPE_DURATION))
{
return false;
}
}
return true;
}
/// @brief 指标对象族。
/// @details 先按 C.2 表语义识别对象族，再根据相别拆成最终 metric_id。
enum class StatFamily
{
Unknown = 0,
VoltageRms,
CurrentRms,
VoltageDeviation,
Frequency,
FrequencyDeviation,
VoltageZeroSequence,
VoltageNegativeSequence,
VoltagePositiveSequence,
VoltageNegativeSequenceUnbalance,
CurrentZeroSequence,
CurrentNegativeSequence,
CurrentPositiveSequence,
CurrentNegativeSequenceUnbalance
};
/// @brief 将名称归一化为“仅保留字母数字并转大写”的紧凑形式。
/// @param s 原始名称。
/// @return 归一化后的字符串。
std::string stat_compact_upper(const std::string& s)
{
std::string out;
out.reserve(s.size());
for (unsigned char ch : s)
{
if (std::isalnum(ch))
out.push_back(static_cast<char>(std::toupper(ch)));
}
return out;
}
/// @brief 判断归一化后的文本中是否包含任一别名。
/// @param compact_text 归一化文本。
/// @param aliases 别名集合。
/// @return 命中任一别名则返回 true。
bool stat_contains_any_alias(
const std::string& compact_text,
const std::vector<std::string>& aliases)
{
for (const auto& alias : aliases)
{
if (!alias.empty() && compact_text.find(alias) != std::string::npos)
return true;
}
return false;
}
bool stat_ends_with(const std::string& text, const std::string& suffix)
{
return text.size() >= suffix.size() &&
text.compare(text.size() - suffix.size(), suffix.size(), suffix) == 0;
}
std::string stat_two_digit(int n)
{
char buf[8] = { 0 };
std::snprintf(buf, sizeof(buf), "%02d", n);
return std::string(buf);
}
int stat_round_order_if_valid(double value)
{
const int rounded = static_cast<int>(std::llround(value));
if (rounded < 2 || rounded > 50)
return -1;
if (std::fabs(value - static_cast<double>(rounded)) > 1e-6)
return -1;
return rounded;
}
/// @brief 动态谱类次数解析的特殊返回值：标准 group=1 表示基波，应跳过，不能兜底映射为 2 次。
constexpr int STAT_DYNAMIC_ORDER_SKIP_FUNDAMENTAL = -100000;
bool stat_is_voltage_harmonic_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_HRMS) ||
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SPECTRA) ||
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SPECTRA_HGROUP);
}
bool stat_is_voltage_harmonic_unit(unsigned int unit_id)
{
// UaHarmXX/UbHarmXX/UcHarmXX 表示谐波电压 RMS 值，单位应为 V。
// OBS 中常见的 V HR A/B/C 是谐波含有率/百分比，后续应单独建 HarmRatio 指标，
// 这里不能混入同一个谐波电压指标。
return unit_id == ID_QU_VOLTS;
}
/// @brief C.2 标准字段优先识别：电压谐波 RMS / 按谐波组频谱。
/// @details
/// 这里优先使用三个标准字段，而不是名称：
/// tagQuantityMeasuredID = ID_QM_VOLTAGE
/// tagQuantityCharacteristicID = ID_QC_HRMS / ID_QC_SPECTRA / ID_QC_SPECTRA_HGROUP
/// tagQuantityUnitsID = ID_QU_VOLTS
/// 谐波次数不在这三个 ID 中，当前文件通过 tagChannelGroupID 表达 group=2..50。
bool stat_match_c2_voltage_harmonic_rms(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_is_voltage_harmonic_unit(p.quantity_units_id) &&
stat_is_voltage_harmonic_characteristic(p);
}
int stat_extract_harmonic_order_from_compact_text(const std::string& compact_text)
{
if (compact_text.empty())
return -1;
// 优先匹配带有明确 HARM/HRMS/H 前缀或后缀的写法，避免误把普通数字当作谐波次数。
for (int order = 2; order <= 50; ++order)
{
const std::string n = std::to_string(order);
const std::string nn = stat_two_digit(order);
const std::vector<std::string> aliases = {
"HARMONIC" + n,
"HARMONIC" + nn,
"HARM" + n,
"HARM" + nn,
"HRMS" + n,
"HRMS" + nn,
"HGROUP" + n,
"HGROUP" + nn,
"H" + n,
"H" + nn,
n + "HARMONIC",
nn + "HARMONIC",
n + "HARM",
nn + "HARM"
};
if (stat_contains_any_alias(compact_text, aliases))
return order;
}
return -1;
}
int stat_extract_order_from_standard_fields(const ExpandedStatPoint& p)
{
// 当前厂家文件把谐波次数写在 channel_group_id 中：group=1 为基波，group=2..50 为 2-50 次谐波。
// 修复点：一旦明确出现 group=1，必须视为基波并跳过，不能继续用 order_hint/name 兜底成 2 次。
if (p.channel_group_id == 1)
return STAT_DYNAMIC_ORDER_SKIP_FUNDAMENTAL;
const int order_by_group = stat_round_order_if_valid(static_cast<double>(p.channel_group_id));
if (order_by_group >= 2 && order_by_group <= 50)
return order_by_group;
// 其他厂家可能放在 series_base_quantity 或 nominal_quantity，作为标准字段不足时的补充。
// 仅当 channel_group_id 没有给出明确次数时才使用这些字段。
const int order_by_base = stat_round_order_if_valid(p.series_base_quantity);
if (order_by_base >= 2 && order_by_base <= 50)
return order_by_base;
const int order_by_nominal = stat_round_order_if_valid(p.nominal_quantity);
if (order_by_nominal >= 2 && order_by_nominal <= 50)
return order_by_nominal;
// 有些厂家把谐波/相角谱线拆成多个 channel instance，但每条通道名称完全相同，
// 且没有写 channel_group_id/base/nominal。此时在展开通道时会按同类通道实例顺序
// 生成 order_hint，避免所有通道都被名称里的 “HARM2” 误识别为 2 次。
// 注意：如果上面已检测到 group=1，这里不会执行。
if (p.channel_spectrum_order_hint >= 2 && p.channel_spectrum_order_hint <= 50)
return p.channel_spectrum_order_hint;
return -1;
}
int stat_extract_voltage_harmonic_order(const ExpandedStatPoint& p)
{
if (p.quantity_measured_id != ID_QM_VOLTAGE)
return -1;
if (!stat_is_voltage_harmonic_unit(p.quantity_units_id))
return -1;
// 第一优先级：C.2 标准字段组合。
// 只要 measured + characteristic + unit 命中，就直接从 group/base/nominal 读取次数，
// 不要求通道名包含 HRMS/HARM/HGROUP。
if (stat_match_c2_voltage_harmonic_rms(p))
{
const int order_by_standard = stat_extract_order_from_standard_fields(p);
if (order_by_standard == STAT_DYNAMIC_ORDER_SKIP_FUNDAMENTAL)
return -1;
if (order_by_standard >= 2 && order_by_standard <= 50)
return order_by_standard;
}
// 第二优先级：厂家名称兜底。仅在标准 characteristic 缺失或不规范时使用。
const std::string compact_text =
stat_compact_upper(p.channel_name) + stat_compact_upper(p.quantity_name);
const bool text_has_harmonic_hint = stat_contains_any_alias(compact_text, {
"HARM", "HARMONIC", "HRMS", "HGROUP", "SPECTRA"
});
if (!text_has_harmonic_hint)
return -1;
const int order_by_name = stat_extract_harmonic_order_from_compact_text(compact_text);
if (order_by_name >= 2 && order_by_name <= 50)
return order_by_name;
{
const int order_by_standard = stat_extract_order_from_standard_fields(p);
if (order_by_standard == STAT_DYNAMIC_ORDER_SKIP_FUNDAMENTAL)
return -1;
return order_by_standard;
}
}
int stat_extract_voltage_harmonic_phase_index(const ExpandedStatPoint& p)
{
if (p.phase_id == ID_PHASE_AN) return 0;
if (p.phase_id == ID_PHASE_BN) return 1;
if (p.phase_id == ID_PHASE_CN) return 2;
const std::string compact_text =
stat_compact_upper(p.channel_name) + stat_compact_upper(p.quantity_name);
if (stat_contains_any_alias(compact_text, { "PHASEA", "PHA", "VHA", "UHARMA", "VHARMONICA", "UHARMONICA", "HRMSA" }))
return 0;
if (stat_contains_any_alias(compact_text, { "PHASEB", "PHB", "VHB", "UHARMB", "VHARMONICB", "UHARMONICB", "HRMSB" }))
return 1;
if (stat_contains_any_alias(compact_text, { "PHASEC", "PHC", "VHC", "UHARMC", "VHARMONICC", "UHARMONICC", "HRMSC" }))
return 2;
// 常见格式如 VH02A / V2HA / U50B：优先使用末尾相别，但避免把单独的 HARMONIC 误判成 C 相。
if (stat_ends_with(compact_text, "A") && !stat_ends_with(compact_text, "HARMONICA"))
return 0;
if (stat_ends_with(compact_text, "B") && !stat_ends_with(compact_text, "HARMONICB"))
return 1;
if (stat_ends_with(compact_text, "C") && !stat_ends_with(compact_text, "HARMONIC"))
return 2;
return -1;
}
bool stat_is_harmonic_group_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_HRMS) ||
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SPECTRA) ||
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SPECTRA_HGROUP);
}
bool stat_is_interharmonic_group_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SPECTRA_IGROUP);
}
bool stat_is_phase_angle_value_type(const GUID& value_type_id)
{
return stat_guid_equals(value_type_id, ID_SERIES_VALUE_TYPE_PHASEANGLE) ||
stat_guid_equals(value_type_id, ID_SERIES_VALUE_TYPE_PHASEANGLE_MIN) ||
stat_guid_equals(value_type_id, ID_SERIES_VALUE_TYPE_PHASEANGLE_MAX) ||
stat_guid_equals(value_type_id, ID_SERIES_VALUE_TYPE_PHASEANGLE_AVG);
}
bool stat_is_angle_like_point(const ExpandedStatPoint& p)
{
if (stat_is_phase_angle_value_type(p.value_type_id.value))
return true;
if (p.quantity_units_id == ID_QU_DEGREES)
return true;
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.value_type_id.symbolic_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name);
return stat_contains_any_alias(compact, { "PHASEANGLE", "PHASANGLE", "ANGLE", "PANGLE", "HANGLE" });
}
bool stat_is_magnitude_unit_for_measured(unsigned int measured_id, unsigned int unit_id)
{
if (measured_id == ID_QM_VOLTAGE)
return unit_id == ID_QU_VOLTS;
if (measured_id == ID_QM_CURRENT)
return unit_id == ID_QU_AMPS;
return false;
}
int stat_extract_line_voltage_phase_index(const ExpandedStatPoint& p)
{
if (p.phase_id == ID_PHASE_AB) return 0;
if (p.phase_id == ID_PHASE_BC) return 1;
if (p.phase_id == ID_PHASE_CA) return 2;
const std::string compact = stat_compact_upper(p.channel_name) + stat_compact_upper(p.quantity_name);
if (stat_contains_any_alias(compact, { "PHASEAB", "PHAB", "UAB", "VAB", "HRMSAB", "HARMAB" })) return 0;
if (stat_contains_any_alias(compact, { "PHASEBC", "PHBC", "UBC", "VBC", "HRMSBC", "HARMBC" })) return 1;
if (stat_contains_any_alias(compact, { "PHASECA", "PHCA", "UCA", "VCA", "HRMSCA", "HARMCA" })) return 2;
if (stat_ends_with(compact, "AB")) return 0;
if (stat_ends_with(compact, "BC")) return 1;
if (stat_ends_with(compact, "CA")) return 2;
return -1;
}
int stat_extract_phase_current_phase_index(const ExpandedStatPoint& p)
{
if (p.phase_id == ID_PHASE_AN) return 0;
if (p.phase_id == ID_PHASE_BN) return 1;
if (p.phase_id == ID_PHASE_CN) return 2;
const std::string compact = stat_compact_upper(p.channel_name) + stat_compact_upper(p.quantity_name);
if (stat_contains_any_alias(compact, { "PHASEA", "PHA", "IHA", "IHARMA", "IHARMONICA", "HRMSA" })) return 0;
if (stat_contains_any_alias(compact, { "PHASEB", "PHB", "IHB", "IHARMB", "IHARMONICB", "HRMSB" })) return 1;
if (stat_contains_any_alias(compact, { "PHASEC", "PHC", "IHC", "IHARMC", "IHARMONICC", "HRMSC" })) return 2;
if (stat_ends_with(compact, "A")) return 0;
if (stat_ends_with(compact, "B")) return 1;
if (stat_ends_with(compact, "C")) return 2;
return -1;
}
int stat_round_interharmonic_slot_if_valid(double value)
{
if (value < -1e-6 || value > 49.5 + 1e-6)
return -1;
const double slot_value = value - 0.5;
const int slot = static_cast<int>(std::llround(slot_value));
if (slot < 0 || slot > 49)
return -1;
if (std::fabs(slot_value - static_cast<double>(slot)) > 1e-6)
return -1;
return slot;
}
int stat_extract_interharmonic_slot_from_standard_fields(const ExpandedStatPoint& p)
{
// 间谐波优先按标准 group 解析：group=1..50 -> 0.5..49.5。
// 即 slot=0..49。不要再兼容 group=0..49，否则会把缺失/无效 group 错映射为 0.5。
if (p.channel_group_id >= 1 && p.channel_group_id <= 50)
return p.channel_group_id - 1;
int slot = stat_round_interharmonic_slot_if_valid(p.series_base_quantity);
if (slot >= 0) return slot;
slot = stat_round_interharmonic_slot_if_valid(p.nominal_quantity);
if (slot >= 0) return slot;
// 仅当标准字段没有给出 group/base/nominal 时，才使用展开阶段生成的顺序提示。
if (p.channel_spectrum_order_hint >= 1 && p.channel_spectrum_order_hint <= 50)
return p.channel_spectrum_order_hint - 1;
return -1;
}
bool stat_text_has_harmonic_hint(const std::string& compact)
{
return stat_contains_any_alias(compact, { "HARM", "HARMONIC", "HRMS", "HGROUP", "SPECTRA" });
}
bool stat_text_has_interharmonic_hint(const std::string& compact)
{
return stat_contains_any_alias(compact, { "INTERHARM", "INTERHARMONIC", "IHARM", "IGROUP", "IHGROUP" });
}
int stat_extract_interharmonic_slot_from_text(const std::string& compact)
{
if (!stat_text_has_interharmonic_hint(compact))
return -1;
for (int slot = 0; slot <= 49; ++slot)
{
const int n = slot;
const std::string nn = stat_two_digit(n);
const std::vector<std::string> aliases = {
"IH" + nn + "P5", "IH" + std::to_string(n) + "P5",
"INTERHARM" + nn + "P5", "INTERHARM" + std::to_string(n) + "P5",
"INTERHARMONIC" + nn + "P5", "INTERHARMONIC" + std::to_string(n) + "P5"
};
if (stat_contains_any_alias(compact, aliases))
return slot;
}
return -1;
}
bool stat_guid_in(const GUID& value, const std::vector<const GUID*>& candidates)
{
for (const GUID* g : candidates)
{
if (g != nullptr && stat_guid_equals(value, *g))
return true;
}
return false;
}
bool stat_unit_is_ratio_like(unsigned int unit_id)
{
return unit_id == ID_QU_PERCENT || unit_id == ID_QU_PERUNIT || unit_id == ID_QU_NONE;
}
bool stat_unit_is_power_unit(unsigned int unit_id)
{
return unit_id == ID_QU_WATTS || unit_id == ID_QU_VARS || unit_id == ID_QU_VA;
}
bool stat_text_has_total_hint(const std::string& compact)
{
return stat_contains_any_alias(compact, {
"TOTAL", "TOT", "SUM", "THREEPHASE", "3PHASE", "ALLPHASE", "NET",
"PTOTAL", "QTOTAL", "STOTAL", "PALL", "QALL", "SALL"
});
}
int stat_extract_phase_or_total_index(const ExpandedStatPoint& p)
{
if (p.phase_id == ID_PHASE_AN) return 0;
if (p.phase_id == ID_PHASE_BN) return 1;
if (p.phase_id == ID_PHASE_CN) return 2;
if (p.phase_id == ID_PHASE_TOTAL || p.phase_id == ID_PHASE_NET) return 3;
const std::string compact = stat_compact_upper(p.channel_name) + stat_compact_upper(p.quantity_name);
if (stat_text_has_total_hint(compact)) return 3;
if (stat_contains_any_alias(compact, { "PHASEA", "PHA", " PA", "PA", "A相" }) || stat_ends_with(compact, "A")) return 0;
if (stat_contains_any_alias(compact, { "PHASEB", "PHB", " PB", "PB", "B相" }) || stat_ends_with(compact, "B")) return 1;
if (stat_contains_any_alias(compact, { "PHASEC", "PHC", " PC", "PC", "C相" }) || stat_ends_with(compact, "C")) return 2;
return -1;
}
StatMetricId stat_metric_from_phase4(int phase, StatMetricId a, StatMetricId b, StatMetricId c, StatMetricId total)
{
if (phase == 0) return a;
if (phase == 1) return b;
if (phase == 2) return c;
if (phase == 3) return total;
return StatMetricId::Unknown;
}
StatMetricId stat_metric_from_phase3(int phase, StatMetricId a, StatMetricId b, StatMetricId c)
{
if (phase == 0) return a;
if (phase == 1) return b;
if (phase == 2) return c;
return StatMetricId::Unknown;
}
bool stat_is_power_factor_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_in(p.quantity_characteristic_id.value, {
&ID_QC_PF, &ID_QC_PF_VECTOR, &ID_QC_PF_ARITH
});
}
bool stat_is_fund_power_factor_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_in(p.quantity_characteristic_id.value, {
&ID_QC_DF, &ID_QC_DF_VECTOR, &ID_QC_DF_ARITH
});
}
bool stat_is_active_power_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_P);
}
bool stat_is_reactive_power_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_Q);
}
bool stat_is_apparent_power_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_in(p.quantity_characteristic_id.value, {
&ID_QC_S, &ID_QC_S_VECTOR, &ID_QC_S_ARITH
});
}
bool stat_is_active_fund_power_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_P_FUND);
}
bool stat_is_reactive_fund_power_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_Q_FUND);
}
bool stat_is_apparent_fund_power_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_in(p.quantity_characteristic_id.value, {
&ID_QC_S_FUND, &ID_QC_S_VECTOR_FUND, &ID_QC_S_ARITH_FUND
});
}
bool stat_text_has_fund_hint(const ExpandedStatPoint& p)
{
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name);
return stat_contains_any_alias(compact, {
"FUND", "FUNDAMENTAL", "BASEFREQ", "FREQFUND", "1STHARM", "HARM1"
});
}
bool stat_text_has_dvc_hint(const ExpandedStatPoint& p)
{
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name);
return stat_contains_any_alias(compact, { "DVC", "DVV", "DELTAV", "VOLTAGECHANGE", "VCHANGE", "FLKRMAXDVV" });
}
bool stat_text_has_pst_hint(const ExpandedStatPoint& p)
{
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name);
return stat_contains_any_alias(compact, { "PST", "SHORTTERMFLICKER", "SHORTFLICKER", "FLKRPST" });
}
bool stat_text_has_plt_hint(const ExpandedStatPoint& p)
{
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name);
return stat_contains_any_alias(compact, { "PLT", "LONGTERMFLICKER", "LONGFLICKER", "FLKRPLT" });
}
bool stat_text_has_thd_hint(const ExpandedStatPoint& p)
{
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name);
return stat_contains_any_alias(compact, { "THD", "TOTALHARMONICDISTORTION", "TOTALTHD" }) &&
!stat_contains_any_alias(compact, { "OTHD", "ETHD", "ODDTHD", "EVENTHD" });
}
bool stat_is_total_thd_characteristic(const ExpandedStatPoint& p)
{
return stat_guid_in(p.quantity_characteristic_id.value, {
&ID_QC_TOTAL_THD, &ID_QC_TOTAL_THD_RMS
});
}
StatMetricId stat_identify_scalar_extension_metric(const ExpandedStatPoint& p, bool& matched_by_name_fallback)
{
matched_by_name_fallback = false;
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name);
// 三相/总有功、无功、视在功率；以及基波功率。
if (p.quantity_measured_id == ID_QM_POWER)
{
const int phase = stat_extract_phase_or_total_index(p);
if (phase >= 0)
{
if (stat_is_active_power_characteristic(p) && p.quantity_units_id == ID_QU_WATTS)
return stat_metric_from_phase4(phase, StatMetricId::PaPower, StatMetricId::PbPower, StatMetricId::PcPower, StatMetricId::PTotalPower);
if (stat_is_reactive_power_characteristic(p) && p.quantity_units_id == ID_QU_VARS)
return stat_metric_from_phase4(phase, StatMetricId::QaPower, StatMetricId::QbPower, StatMetricId::QcPower, StatMetricId::QTotalPower);
if (stat_is_apparent_power_characteristic(p) && p.quantity_units_id == ID_QU_VA)
return stat_metric_from_phase4(phase, StatMetricId::SaPower, StatMetricId::SbPower, StatMetricId::ScPower, StatMetricId::STotalPower);
if (stat_is_active_fund_power_characteristic(p) && p.quantity_units_id == ID_QU_WATTS)
return stat_metric_from_phase4(phase, StatMetricId::PaFundPower, StatMetricId::PbFundPower, StatMetricId::PcFundPower, StatMetricId::PTotalFundPower);
if (stat_is_reactive_fund_power_characteristic(p) && p.quantity_units_id == ID_QU_VARS)
return stat_metric_from_phase4(phase, StatMetricId::QaFundPower, StatMetricId::QbFundPower, StatMetricId::QcFundPower, StatMetricId::QTotalFundPower);
if (stat_is_apparent_fund_power_characteristic(p) && p.quantity_units_id == ID_QU_VA)
return stat_metric_from_phase4(phase, StatMetricId::SaFundPower, StatMetricId::SbFundPower, StatMetricId::ScFundPower, StatMetricId::STotalFundPower);
if (stat_is_power_factor_characteristic(p) && stat_unit_is_ratio_like(p.quantity_units_id))
return stat_metric_from_phase4(phase, StatMetricId::PFa, StatMetricId::PFb, StatMetricId::PFc, StatMetricId::PFTotal);
if (stat_is_fund_power_factor_characteristic(p) && stat_unit_is_ratio_like(p.quantity_units_id))
return stat_metric_from_phase4(phase, StatMetricId::FundPFa, StatMetricId::FundPFb, StatMetricId::FundPFc, StatMetricId::FundPFTotal);
}
// 名称兜底：厂家可能只填 NONE/INSTANTANEOUS，但通道名中含 P/Q/S/PF/FUND。
if (phase >= 0)
{
if (p.quantity_units_id == ID_QU_WATTS && stat_contains_any_alias(compact, { "PFUND", "FUNDAMENTALP", "FUNDPOWERP" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::PaFundPower, StatMetricId::PbFundPower, StatMetricId::PcFundPower, StatMetricId::PTotalFundPower);
}
if (p.quantity_units_id == ID_QU_VARS && stat_contains_any_alias(compact, { "QFUND", "FUNDAMENTALQ", "FUNDPOWERQ" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::QaFundPower, StatMetricId::QbFundPower, StatMetricId::QcFundPower, StatMetricId::QTotalFundPower);
}
if (p.quantity_units_id == ID_QU_VA && stat_contains_any_alias(compact, { "SFUND", "FUNDAMENTALS", "FUNDPOWERS" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::SaFundPower, StatMetricId::SbFundPower, StatMetricId::ScFundPower, StatMetricId::STotalFundPower);
}
if (stat_unit_is_ratio_like(p.quantity_units_id) && stat_contains_any_alias(compact, { "FUNDPF", "FUNDAMENTALPF", "DISPLACEMENTFACTOR", "DF" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::FundPFa, StatMetricId::FundPFb, StatMetricId::FundPFc, StatMetricId::FundPFTotal);
}
if (stat_unit_is_ratio_like(p.quantity_units_id) && stat_contains_any_alias(compact, { "POWERFACTOR", "PF" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::PFa, StatMetricId::PFb, StatMetricId::PFc, StatMetricId::PFTotal);
}
if (p.quantity_units_id == ID_QU_WATTS && stat_contains_any_alias(compact, { "ACTIVEPOWER", "REALPOWER", "PW", "PPOWER" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::PaPower, StatMetricId::PbPower, StatMetricId::PcPower, StatMetricId::PTotalPower);
}
if (p.quantity_units_id == ID_QU_VARS && stat_contains_any_alias(compact, { "REACTIVEPOWER", "QPOWER", "VAR" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::QaPower, StatMetricId::QbPower, StatMetricId::QcPower, StatMetricId::QTotalPower);
}
if (p.quantity_units_id == ID_QU_VA && stat_contains_any_alias(compact, { "APPARENTPOWER", "SPOWER", "VA" }))
{
matched_by_name_fallback = true;
return stat_metric_from_phase4(phase, StatMetricId::SaPower, StatMetricId::SbPower, StatMetricId::ScPower, StatMetricId::STotalPower);
}
}
}
// 总谐波畸变率 THD：三相电压/电流/线电压。
if ((p.quantity_measured_id == ID_QM_VOLTAGE || p.quantity_measured_id == ID_QM_CURRENT) &&
stat_unit_is_ratio_like(p.quantity_units_id) &&
(stat_is_total_thd_characteristic(p) || stat_text_has_thd_hint(p)))
{
if (!stat_is_total_thd_characteristic(p))
matched_by_name_fallback = true;
if (p.quantity_measured_id == ID_QM_CURRENT)
{
const int phase = stat_extract_phase_current_phase_index(p);
return stat_metric_from_phase3(phase, StatMetricId::IaThd, StatMetricId::IbThd, StatMetricId::IcThd);
}
int phase = stat_extract_voltage_harmonic_phase_index(p);
if (phase >= 0)
return stat_metric_from_phase3(phase, StatMetricId::UaThd, StatMetricId::UbThd, StatMetricId::UcThd);
phase = stat_extract_line_voltage_phase_index(p);
if (phase >= 0)
return stat_metric_from_phase3(phase, StatMetricId::UabThd, StatMetricId::UbcThd, StatMetricId::UcaThd);
}
// 电压变动幅值 DVC/dV/V。
// 先按 C.2 ID 组合识别；若厂家未规范填写 measured，只要名称明确包含电压变动提示，也允许名称兜底。
const bool measured_is_voltage_or_voltage_name =
p.quantity_measured_id == ID_QM_VOLTAGE ||
stat_contains_any_alias(compact, { "VOLTAGE", "VFLICKER", "VFLKR", "VDVC", "UDVC", "DVV" });
if (measured_is_voltage_or_voltage_name &&
stat_unit_is_ratio_like(p.quantity_units_id) &&
(stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_FLKR_MAX_DVV) || stat_text_has_dvc_hint(p)))
{
if (p.quantity_measured_id != ID_QM_VOLTAGE ||
!stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_FLKR_MAX_DVV))
{
matched_by_name_fallback = true;
}
int phase = stat_extract_voltage_harmonic_phase_index(p);
if (phase >= 0)
return stat_metric_from_phase3(phase, StatMetricId::UaDvc, StatMetricId::UbDvc, StatMetricId::UcDvc);
phase = stat_extract_line_voltage_phase_index(p);
if (phase >= 0)
return stat_metric_from_phase3(phase, StatMetricId::UabDvc, StatMetricId::UbcDvc, StatMetricId::UcaDvc);
}
// 闪变 Pst/Plt。
// 修复点：
// 1) ID_QC_FLKR_PST / ID_QC_FLKR_PLT 仍然是第一优先级；
// 2) 对 V Flicker Plt A/B/C、PLT VA/VB/VC 等厂家名称进行兜底；
// 3) 不强依赖 measured 必须填成 Voltage，避免厂家只靠通道名表达对象。
const bool id_is_pst = stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_FLKR_PST);
const bool id_is_plt = stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_FLKR_PLT);
const bool is_pst = id_is_pst || stat_text_has_pst_hint(p);
const bool is_plt = id_is_plt || stat_text_has_plt_hint(p);
const bool measured_is_voltage_or_flicker_name =
measured_is_voltage_or_voltage_name || is_pst || is_plt;
// Plt/Pst 修复：厂家有时会把 Plt 序列 unit 写成 Unknown/Unrecognized，而不是 None/pu/%。
// 只要 C.2 characteristic ID 或通道名称已经明确是 Pst/Plt，就不再用 unit 作为硬性门槛。
// unit 仅用于辅助判断，不作为清晰 Flicker 通道的排除条件。
if (measured_is_voltage_or_flicker_name && (is_pst || is_plt))
{
if (p.quantity_measured_id != ID_QM_VOLTAGE || !(id_is_pst || id_is_plt))
matched_by_name_fallback = true;
// 若同时命中 Pst 和 Plt，以标准 ID 为准；没有标准 ID 时 Plt 优先，
// 避免 “V Flicker Plt A/B/C” 因 unit 非标准而被跳过。
const bool choose_plt = id_is_plt || (!id_is_pst && is_plt);
int phase = stat_extract_voltage_harmonic_phase_index(p);
if (phase >= 0)
return choose_plt ?
stat_metric_from_phase3(phase, StatMetricId::UaPlt, StatMetricId::UbPlt, StatMetricId::UcPlt) :
stat_metric_from_phase3(phase, StatMetricId::UaPst, StatMetricId::UbPst, StatMetricId::UcPst);
phase = stat_extract_line_voltage_phase_index(p);
if (phase >= 0)
return choose_plt ?
stat_metric_from_phase3(phase, StatMetricId::UabPlt, StatMetricId::UbcPlt, StatMetricId::UcaPlt) :
stat_metric_from_phase3(phase, StatMetricId::UabPst, StatMetricId::UbcPst, StatMetricId::UcaPst);
}
// 基波有效值和基波相角。
if ((p.quantity_measured_id == ID_QM_VOLTAGE || p.quantity_measured_id == ID_QM_CURRENT) && stat_text_has_fund_hint(p))
{
const bool is_angle = stat_is_angle_like_point(p) || stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_ANGLE_FUND);
const bool is_rms = stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_RMS) ||
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_INSTANTANEOUS) ||
stat_contains_any_alias(compact, { "RMS", "FUND" });
if (p.quantity_measured_id == ID_QM_CURRENT)
{
const int phase = stat_extract_phase_current_phase_index(p);
if (is_angle && p.quantity_units_id == ID_QU_DEGREES)
{
matched_by_name_fallback = !stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_ANGLE_FUND);
return stat_metric_from_phase3(phase, StatMetricId::IaFundAngle, StatMetricId::IbFundAngle, StatMetricId::IcFundAngle);
}
if (is_rms && p.quantity_units_id == ID_QU_AMPS)
{
matched_by_name_fallback = !stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_RMS);
return stat_metric_from_phase3(phase, StatMetricId::IaFundRms, StatMetricId::IbFundRms, StatMetricId::IcFundRms);
}
}
else
{
int phase = stat_extract_voltage_harmonic_phase_index(p);
if (phase >= 0)
{
if (is_angle && p.quantity_units_id == ID_QU_DEGREES)
{
matched_by_name_fallback = !stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_ANGLE_FUND);
return stat_metric_from_phase3(phase, StatMetricId::UaFundAngle, StatMetricId::UbFundAngle, StatMetricId::UcFundAngle);
}
if (is_rms && p.quantity_units_id == ID_QU_VOLTS)
{
matched_by_name_fallback = !stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_RMS);
return stat_metric_from_phase3(phase, StatMetricId::UaFundRms, StatMetricId::UbFundRms, StatMetricId::UcFundRms);
}
}
phase = stat_extract_line_voltage_phase_index(p);
if (phase >= 0)
{
if (is_angle && p.quantity_units_id == ID_QU_DEGREES)
{
matched_by_name_fallback = !stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_ANGLE_FUND);
return stat_metric_from_phase3(phase, StatMetricId::UabFundAngle, StatMetricId::UbcFundAngle, StatMetricId::UcaFundAngle);
}
if (is_rms && p.quantity_units_id == ID_QU_VOLTS)
{
matched_by_name_fallback = !stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_RMS);
return stat_metric_from_phase3(phase, StatMetricId::UabFundRms, StatMetricId::UbcFundRms, StatMetricId::UcaFundRms);
}
}
}
}
return StatMetricId::Unknown;
}
StatMetricId stat_identify_dynamic_extension_metric(const ExpandedStatPoint& p, bool& matched_by_name_fallback)
{
matched_by_name_fallback = false;
const std::string compact = stat_compact_upper(p.channel_name) +
stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name) +
stat_compact_upper(p.value_type_id.symbolic_name);
const bool standard_harmonic =
stat_is_harmonic_group_characteristic(p) ||
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_P_HARMONIC) ||
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_P_HARMONIC_UNSIGNED);
const bool fallback_harmonic = !standard_harmonic && stat_text_has_harmonic_hint(compact) && !stat_text_has_interharmonic_hint(compact);
if (!standard_harmonic && !fallback_harmonic)
return StatMetricId::Unknown;
if (stat_is_angle_like_point(p))
return StatMetricId::Unknown;
int order = -1;
if (standard_harmonic)
order = stat_extract_order_from_standard_fields(p);
if (order == STAT_DYNAMIC_ORDER_SKIP_FUNDAMENTAL)
return StatMetricId::Unknown;
// 名称兜底场景下，仍然优先尝试 group/base/nominal/order_hint；
// 这样 P HARM A 这类“通道名不含具体次数，但通道序列成组排列”的文件也能识别 2-50 次。
if (order < 2 || order > 50)
{
const int order_by_standard_or_hint = stat_extract_order_from_standard_fields(p);
if (order_by_standard_or_hint == STAT_DYNAMIC_ORDER_SKIP_FUNDAMENTAL)
return StatMetricId::Unknown;
if (order_by_standard_or_hint >= 2 && order_by_standard_or_hint <= 50)
order = order_by_standard_or_hint;
}
if (order < 2 || order > 50)
order = stat_extract_harmonic_order_from_compact_text(compact);
if (order < 2 || order > 50)
return StatMetricId::Unknown;
// 谐波功率：按 POWER + W/var/VA 识别，支持三相和总。
if (p.quantity_measured_id == ID_QM_POWER && stat_unit_is_power_unit(p.quantity_units_id))
{
const int phase = stat_extract_phase_or_total_index(p);
if (phase < 0)
return StatMetricId::Unknown;
matched_by_name_fallback = !standard_harmonic;
if (p.quantity_units_id == ID_QU_WATTS)
return stat_dynamic_metric_id(StatDynamicMetricGroup::HarmonicActivePower, phase, order);
if (p.quantity_units_id == ID_QU_VARS)
return stat_dynamic_metric_id(StatDynamicMetricGroup::HarmonicReactivePower, phase, order);
if (p.quantity_units_id == ID_QU_VA)
return stat_dynamic_metric_id(StatDynamicMetricGroup::HarmonicApparentPower, phase, order);
}
// 谐波含有率：按 %/pu/无量纲 识别，和 V/A RMS 谐波分离。
if ((p.quantity_measured_id == ID_QM_VOLTAGE || p.quantity_measured_id == ID_QM_CURRENT) &&
stat_unit_is_ratio_like(p.quantity_units_id))
{
matched_by_name_fallback = !standard_harmonic;
if (p.quantity_measured_id == ID_QM_CURRENT)
{
const int phase = stat_extract_phase_current_phase_index(p);
if (phase >= 0)
return stat_dynamic_metric_id(StatDynamicMetricGroup::CurrentHarmonicRatio, phase, order);
}
else
{
int phase = stat_extract_voltage_harmonic_phase_index(p);
if (phase >= 0)
return stat_dynamic_metric_id(StatDynamicMetricGroup::VoltageHarmonicRatio, phase, order);
phase = stat_extract_line_voltage_phase_index(p);
if (phase >= 0)
return stat_dynamic_metric_id(StatDynamicMetricGroup::LineVoltageHarmonicRatio, phase, order);
}
}
return StatMetricId::Unknown;
}
StatMetricId stat_identify_dynamic_spectrum_metric(const ExpandedStatPoint& p, bool& matched_by_name_fallback)
{
matched_by_name_fallback = false;
if (p.quantity_measured_id != ID_QM_VOLTAGE && p.quantity_measured_id != ID_QM_CURRENT)
return StatMetricId::Unknown;
const std::string compact = stat_compact_upper(p.channel_name) + stat_compact_upper(p.quantity_name) +
stat_compact_upper(p.quantity_characteristic_id.symbolic_name) + stat_compact_upper(p.value_type_id.symbolic_name);
const bool standard_harmonic = stat_is_harmonic_group_characteristic(p);
const bool standard_interharmonic = stat_is_interharmonic_group_characteristic(p);
const bool has_interharmonic_text = stat_text_has_interharmonic_hint(compact);
const bool fallback_interharmonic = !standard_interharmonic && has_interharmonic_text;
const bool fallback_harmonic = !standard_harmonic && stat_text_has_harmonic_hint(compact) && !has_interharmonic_text;
const bool is_angle = stat_is_angle_like_point(p);
const bool magnitude_unit_ok = stat_is_magnitude_unit_for_measured(p.quantity_measured_id, p.quantity_units_id);
const bool angle_unit_ok = is_angle || p.quantity_units_id == ID_QU_DEGREES;
if (!is_angle && !magnitude_unit_ok)
return StatMetricId::Unknown;
if (is_angle && !angle_unit_ok)
return StatMetricId::Unknown;
// 间谐波必须优先于普通谐波识别，避免 IHRMS/INTERHARMONIC 被 HRMS/HARMONIC 兜底误吃掉。
if ((standard_interharmonic || fallback_interharmonic) && !is_angle)
{
int slot = -1;
if (standard_interharmonic)
slot = stat_extract_interharmonic_slot_from_standard_fields(p);
if (slot < 0)
slot = stat_extract_interharmonic_slot_from_text(compact);
if (slot < 0 || slot > 49)
return StatMetricId::Unknown;
if (p.quantity_measured_id == ID_QM_VOLTAGE)
{
int phase = stat_extract_voltage_harmonic_phase_index(p);
if (phase >= 0)
{
matched_by_name_fallback = !standard_interharmonic;
return stat_dynamic_metric_id(StatDynamicMetricGroup::VoltageInterharmonic, phase, slot);
}
phase = stat_extract_line_voltage_phase_index(p);
if (phase >= 0)
{
matched_by_name_fallback = !standard_interharmonic;
return stat_dynamic_metric_id(StatDynamicMetricGroup::LineVoltageInterharmonic, phase, slot);
}
}
else if (p.quantity_measured_id == ID_QM_CURRENT)
{
const int phase = stat_extract_phase_current_phase_index(p);
if (phase >= 0)
{
matched_by_name_fallback = !standard_interharmonic;
return stat_dynamic_metric_id(StatDynamicMetricGroup::CurrentInterharmonic, phase, slot);
}
}
}
if (standard_harmonic || fallback_harmonic)
{
int order = -1;
if (standard_harmonic)
order = stat_extract_order_from_standard_fields(p);
// group=1 明确是基波，必须跳过。不能继续通过 order_hint/name fallback 变成 2 次谐波。
if (order == STAT_DYNAMIC_ORDER_SKIP_FUNDAMENTAL)
return StatMetricId::Unknown;
if (order < 2 || order > 50)
order = stat_extract_harmonic_order_from_compact_text(compact);
if (order < 2 || order > 50)
return StatMetricId::Unknown;
if (p.quantity_measured_id == ID_QM_VOLTAGE)
{
int phase = stat_extract_voltage_harmonic_phase_index(p);
if (phase >= 0)
{
matched_by_name_fallback = !standard_harmonic;
return stat_dynamic_metric_id(is_angle ? StatDynamicMetricGroup::VoltageHarmonicAngle : StatDynamicMetricGroup::VoltageHarmonic, phase, order);
}
phase = stat_extract_line_voltage_phase_index(p);
if (phase >= 0)
{
matched_by_name_fallback = !standard_harmonic;
return stat_dynamic_metric_id(is_angle ? StatDynamicMetricGroup::LineVoltageHarmonicAngle : StatDynamicMetricGroup::LineVoltageHarmonic, phase, order);
}
}
else if (p.quantity_measured_id == ID_QM_CURRENT)
{
const int phase = stat_extract_phase_current_phase_index(p);
if (phase >= 0)
{
matched_by_name_fallback = !standard_harmonic;
return stat_dynamic_metric_id(is_angle ? StatDynamicMetricGroup::CurrentHarmonicAngle : StatDynamicMetricGroup::CurrentHarmonic, phase, order);
}
}
}
return StatMetricId::Unknown;
}
/// @brief 判断样本点是否为 C.2 表中的“频率”对象族。
/// @details
/// 根据附录 C 表 C.2：
/// Frequency -> ID_QM_VOLTAGE + ID_QC_FREQUENCY + ID_QU_HERTZ。
/// @param p 样本点。
/// @return 若命中 Frequency 对象族则返回 true。
bool stat_match_c2_frequency(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_FREQUENCY) &&
p.quantity_units_id == ID_QU_HERTZ;
}
/// @brief 判断样本点是否为 C.2 表中的“电压有效值”对象族。
/// @details
/// 根据附录 C 表 C.2：
/// V RMS -> ID_QM_VOLTAGE + ID_QC_RMS + ID_QU_VOLTS。
/// @param p 样本点。
/// @return 若命中 VoltageRms 对象族则返回 true。
bool stat_match_c2_voltage_rms(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_RMS) &&
p.quantity_units_id == ID_QU_VOLTS;
}
/// @brief 判断样本点是否为 C.2 表中的“电流有效值”对象族。
/// @details
/// 根据附录 C 表 C.2：
/// I RMS -> ID_QM_CURRENT + ID_QC_RMS + ID_QU_AMPS。
/// @param p 样本点。
/// @return 若命中 CurrentRms 对象族则返回 true。
bool stat_match_c2_current_rms(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_CURRENT &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_RMS) &&
p.quantity_units_id == ID_QU_AMPS;
}
/// @brief 判断样本点是否为 C.2 表中的“电压偏差”对象族。
/// @details
/// 根据附录 C 表 C.2：
/// V RMS Deviation -> ID_QM_VOLTAGE + ID_QC_RMS + ID_QU_PERCENT。
/// 为兼容部分设备文件，也允许单位为 PU 作为辅助兼容。
/// @param p 样本点。
/// @return 若命中 VoltageDeviation 对象族则返回 true。
bool stat_match_c2_voltage_deviation(const ExpandedStatPoint& p)
{
const bool unit_match =
p.quantity_units_id == ID_QU_PERCENT ||
p.quantity_units_id == ID_QU_PERUNIT;
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_RMS) &&
unit_match;
}
/// @brief 判断样本点是否为 C.2 表中的“电压零序分量”对象族。
/// @details Zero sequence component -> ID_QM_VOLTAGE + ID_QC_SZERO + ID_QU_VOLTS。
bool stat_match_c2_voltage_zero_sequence(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SZERO) &&
p.quantity_units_id == ID_QU_VOLTS;
}
/// @brief 判断样本点是否为 C.2 表中的“电压负序分量”对象族。
/// @details Negative sequence component -> ID_QM_VOLTAGE + ID_QC_SNEG + ID_QU_VOLTS。
bool stat_match_c2_voltage_negative_sequence(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SNEG) &&
p.quantity_units_id == ID_QU_VOLTS;
}
/// @brief 判断样本点是否为 C.2 表中的“电压正序分量”对象族。
/// @details Positive sequence component -> ID_QM_VOLTAGE + ID_QC_SPOS + ID_QU_VOLTS。
bool stat_match_c2_voltage_positive_sequence(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SPOS) &&
p.quantity_units_id == ID_QU_VOLTS;
}
/// @brief 判断样本点是否为 C.2 表中的“电压负序不平衡”对象族。
/// @details Negative sequence component unbalance -> ID_QM_VOLTAGE + ID_QC_S2S1 + ID_QU_PERCENT/ID_QU_PERUNIT。
bool stat_match_c2_voltage_negative_sequence_unbalance(const ExpandedStatPoint& p)
{
const bool unit_match =
p.quantity_units_id == ID_QU_PERCENT ||
p.quantity_units_id == ID_QU_PERUNIT;
return p.quantity_measured_id == ID_QM_VOLTAGE &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_S2S1) &&
unit_match;
}
/// @brief 判断样本点是否为 C.2 表中的“电流零序分量”对象族。
/// @details Zero sequence component -> ID_QM_CURRENT + ID_QC_SZERO + ID_QU_AMPS。
bool stat_match_c2_current_zero_sequence(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_CURRENT &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SZERO) &&
p.quantity_units_id == ID_QU_AMPS;
}
/// @brief 判断样本点是否为 C.2 表中的“电流负序分量”对象族。
/// @details Negative sequence component -> ID_QM_CURRENT + ID_QC_SNEG + ID_QU_AMPS。
bool stat_match_c2_current_negative_sequence(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_CURRENT &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SNEG) &&
p.quantity_units_id == ID_QU_AMPS;
}
/// @brief 判断样本点是否为 C.2 表中的“电流正序分量”对象族。
/// @details Positive sequence component -> ID_QM_CURRENT + ID_QC_SPOS + ID_QU_AMPS。
bool stat_match_c2_current_positive_sequence(const ExpandedStatPoint& p)
{
return p.quantity_measured_id == ID_QM_CURRENT &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_SPOS) &&
p.quantity_units_id == ID_QU_AMPS;
}
/// @brief 判断样本点是否为 C.2 表中的“电流负序不平衡”对象族。
/// @details Negative sequence component unbalance -> ID_QM_CURRENT + ID_QC_S2S1 + ID_QU_PERCENT/ID_QU_PERUNIT。
bool stat_match_c2_current_negative_sequence_unbalance(const ExpandedStatPoint& p)
{
const bool unit_match =
p.quantity_units_id == ID_QU_PERCENT ||
p.quantity_units_id == ID_QU_PERUNIT;
return p.quantity_measured_id == ID_QM_CURRENT &&
stat_guid_equals(p.quantity_characteristic_id.value, ID_QC_S2S1) &&
unit_match;
}
/// @brief 判断样本点是否为“频率偏差”对象族。
/// @details
/// 频率偏差和频率在 C.2 表里共用同一组核心语义：
/// ID_QM_VOLTAGE + ID_QC_FREQUENCY + ID_QU_HERTZ，差别主要体现在对象名称。
/// 因此这里采用“C.2 语义 + 名称辅助”的方式识别。
/// @param p 样本点。
/// @return 若命中 FrequencyDeviation 对象族则返回 true。
bool stat_match_c2_frequency_deviation(const ExpandedStatPoint& p)
{
if (!stat_match_c2_frequency(p))
return false;
const std::string compact_channel = stat_compact_upper(p.channel_name);
const std::string compact_quantity = stat_compact_upper(p.quantity_name);
const std::vector<std::string> aliases = {
"FREQDEV", "FREQUENCYDEV", "DELTAF", "FDEV", "DEVIATION"
};
return stat_contains_any_alias(compact_channel, aliases) ||
stat_contains_any_alias(compact_quantity, aliases);
}
/// @brief 基于 C.2 表的核心语义识别对象族。
/// @param p 已展开样本点。
/// @return 命中的对象族。
StatFamily stat_identify_family_by_c2(const ExpandedStatPoint& p)
{
if (stat_match_c2_frequency_deviation(p))
return StatFamily::FrequencyDeviation;
if (stat_match_c2_frequency(p))
return StatFamily::Frequency;
if (stat_match_c2_voltage_negative_sequence_unbalance(p))
return StatFamily::VoltageNegativeSequenceUnbalance;
if (stat_match_c2_voltage_zero_sequence(p))
return StatFamily::VoltageZeroSequence;
if (stat_match_c2_voltage_negative_sequence(p))
return StatFamily::VoltageNegativeSequence;
if (stat_match_c2_voltage_positive_sequence(p))
return StatFamily::VoltagePositiveSequence;
if (stat_match_c2_current_negative_sequence_unbalance(p))
return StatFamily::CurrentNegativeSequenceUnbalance;
if (stat_match_c2_current_zero_sequence(p))
return StatFamily::CurrentZeroSequence;
if (stat_match_c2_current_negative_sequence(p))
return StatFamily::CurrentNegativeSequence;
if (stat_match_c2_current_positive_sequence(p))
return StatFamily::CurrentPositiveSequence;
if (stat_match_c2_voltage_deviation(p))
return StatFamily::VoltageDeviation;
if (stat_match_c2_voltage_rms(p))
return StatFamily::VoltageRms;
if (stat_match_c2_current_rms(p))
return StatFamily::CurrentRms;
return StatFamily::Unknown;
}
/// @brief 根据接线方式、相别与 C.2 对象族，把样本点映射成最终业务指标。
/// @param connection_kind 当前文件接线方式。
/// @param p 已展开样本点。
/// @param matched_by_name_fallback 返回是否通过名称辅助识别。
/// @return 识别出的业务指标 ID。
StatMetricId stat_identify_metric_id(
ParsedConnectionKind connection_kind,
const ExpandedStatPoint& p,
bool& matched_by_name_fallback)
{
matched_by_name_fallback = false;
// 扩展动态指标入口：谐波功率、谐波含有率。
// 仍然保持“ID 组合优先，名称兜底”策略；名称只在标准字段不足时参与。
{
bool dynamic_name_fallback = false;
const StatMetricId dynamic_metric = stat_identify_dynamic_extension_metric(p, dynamic_name_fallback);
if (dynamic_metric != StatMetricId::Unknown)
{
matched_by_name_fallback = dynamic_name_fallback;
return dynamic_metric;
}
}
// 谐波/间谐波类指标统一入口：
// 先按 C.2 标准 ID 组合识别 measured/characteristic/unit/value_type，再从 group/base/nominal 取次数；
// 标准字段不足时才使用通道名兜底。覆盖电压/电流/线电压、幅值/相角、谐波/间谐波。
{
bool dynamic_name_fallback = false;
const StatMetricId dynamic_metric = stat_identify_dynamic_spectrum_metric(p, dynamic_name_fallback);
if (dynamic_metric != StatMetricId::Unknown)
{
matched_by_name_fallback = dynamic_name_fallback;
return dynamic_metric;
}
}
// 扩展静态指标入口：功率、功率因数、DVC、闪变、THD、基波 RMS/相角。
{
bool scalar_name_fallback = false;
const StatMetricId scalar_metric = stat_identify_scalar_extension_metric(p, scalar_name_fallback);
if (scalar_metric != StatMetricId::Unknown)
{
matched_by_name_fallback = scalar_name_fallback;
return scalar_metric;
}
}
const StatFamily family = stat_identify_family_by_c2(p);
switch (family)
{
case StatFamily::VoltageRms:
if (p.phase_id == ID_PHASE_AN) return StatMetricId::UaRms;
if (p.phase_id == ID_PHASE_BN) return StatMetricId::UbRms;
if (p.phase_id == ID_PHASE_CN) return StatMetricId::UcRms;
if (p.phase_id == ID_PHASE_AB) return StatMetricId::UabRms;
if (p.phase_id == ID_PHASE_BC) return StatMetricId::UbcRms;
if (p.phase_id == ID_PHASE_CA) return StatMetricId::UcaRms;
break;
case StatFamily::CurrentRms:
if (p.phase_id == ID_PHASE_AN) return StatMetricId::IaRms;
if (p.phase_id == ID_PHASE_BN) return StatMetricId::IbRms;
if (p.phase_id == ID_PHASE_CN) return StatMetricId::IcRms;
break;
case StatFamily::VoltageDeviation:
if (connection_kind == ParsedConnectionKind::Wye || connection_kind == ParsedConnectionKind::Unknown)
{
if (p.phase_id == ID_PHASE_AN) return StatMetricId::UaDeviation;
if (p.phase_id == ID_PHASE_BN) return StatMetricId::UbDeviation;
if (p.phase_id == ID_PHASE_CN) return StatMetricId::UcDeviation;
}
if (connection_kind == ParsedConnectionKind::Delta || connection_kind == ParsedConnectionKind::Unknown)
{
if (p.phase_id == ID_PHASE_AB) return StatMetricId::UabDeviation;
if (p.phase_id == ID_PHASE_BC) return StatMetricId::UbcDeviation;
if (p.phase_id == ID_PHASE_CA) return StatMetricId::UcaDeviation;
}
break;
case StatFamily::VoltageZeroSequence:
return StatMetricId::UZeroSeq;
case StatFamily::VoltageNegativeSequence:
return StatMetricId::UNegSeq;
case StatFamily::VoltagePositiveSequence:
return StatMetricId::UPosSeq;
case StatFamily::VoltageNegativeSequenceUnbalance:
return StatMetricId::UNegSeqUnbalance;
case StatFamily::CurrentZeroSequence:
return StatMetricId::IZeroSeq;
case StatFamily::CurrentNegativeSequence:
return StatMetricId::INegSeq;
case StatFamily::CurrentPositiveSequence:
return StatMetricId::IPosSeq;
case StatFamily::CurrentNegativeSequenceUnbalance:
return StatMetricId::INegSeqUnbalance;
case StatFamily::Frequency:
return StatMetricId::Frequency;
case StatFamily::FrequencyDeviation:
matched_by_name_fallback = true;
return StatMetricId::FrequencyDeviation;
default:
break;
}
// 部分厂家文件可能没有正确填写序分量的 QuantityCharacteristicID，
// 但通道名/量名会包含 Pos/Neg/Zero/Sequence/S2S1 等信息；
// 这里只作为补充兜底，优先级低于上面的 C.2 GUID 语义识别。
const std::string compact_text =
stat_compact_upper(p.channel_name) + stat_compact_upper(p.quantity_name);
if (p.quantity_measured_id == ID_QM_VOLTAGE)
{
if (stat_contains_any_alias(compact_text, {
"S2S1", "NEGATIVESEQUENCEUNBALANCE", "NEGSEQUNBALANCE",
"NEGATIVEUNBALANCE", "NEGUNBALANCE", "VOLTAGEUNBALANCE",
"VUNBALANCE", "VOLTAGEIMBALANCE"
}))
{
matched_by_name_fallback = true;
return StatMetricId::UNegSeqUnbalance;
}
if (stat_contains_any_alias(compact_text, {
"ZEROSEQUENCE", "ZEROSEQ", "ZEROSQ", "SZERO",
"VZEROSEQ", "UZEROSEQ", "V0", "U0"
}))
{
matched_by_name_fallback = true;
return StatMetricId::UZeroSeq;
}
if (stat_contains_any_alias(compact_text, {
"NEGATIVESEQUENCE", "NEGSEQ", "NEGSQ", "SNEG",
"VNEGSEQ", "UNEGSEQ", "V2", "U2"
}))
{
matched_by_name_fallback = true;
return StatMetricId::UNegSeq;
}
if (stat_contains_any_alias(compact_text, {
"POSITIVESEQUENCE", "POSSEQ", "POSSQ", "SPOS",
"VPOSSEQ", "UPOSSEQ", "V1", "U1"
}))
{
matched_by_name_fallback = true;
return StatMetricId::UPosSeq;
}
}
// 电流序分量使用同一组序分量 characteristic，但 QuantityMeasured 为 CURRENT；
// 部分厂家仍可能只在通道名里写 I SPos / I SNeg / I SZero / I S2S1，因此也做名称兜底。
if (p.quantity_measured_id == ID_QM_CURRENT)
{
if (stat_contains_any_alias(compact_text, {
"IS2S1", "CURRENTS2S1", "CURRENTNEGATIVESEQUENCEUNBALANCE",
"CURRENTNEGSEQUNBALANCE", "INEGSEQUNBALANCE", "NEGSEQUNBALANCEI",
"CURRENTUNBALANCE", "IUNBALANCE", "CURRENTIMBALANCE", "IIMBALANCE"
}))
{
matched_by_name_fallback = true;
return StatMetricId::INegSeqUnbalance;
}
if (stat_contains_any_alias(compact_text, {
"CURRENTZEROSEQUENCE", "CURRENTZEROSEQ", "IZEROSEQUENCE", "IZEROSEQ",
"ISZERO", "IZEROSQ", "I0"
}))
{
matched_by_name_fallback = true;
return StatMetricId::IZeroSeq;
}
if (stat_contains_any_alias(compact_text, {
"CURRENTNEGATIVESEQUENCE", "CURRENTNEGSEQ", "INEGATIVESEQUENCE", "INEGSEQ",
"ISNEG", "INEGSQ", "I2"
}))
{
matched_by_name_fallback = true;
return StatMetricId::INegSeq;
}
if (stat_contains_any_alias(compact_text, {
"CURRENTPOSITIVESEQUENCE", "CURRENTPOSSEQ", "IPOSITIVESEQUENCE", "IPOSSEQ",
"ISPOS", "IPOSSQ", "I1"
}))
{
matched_by_name_fallback = true;
return StatMetricId::IPosSeq;
}
}
return StatMetricId::Unknown;
}
struct StatMetricSourceKey
{
int observation_index = -1;
int channel_instance_index = -1;
bool operator<(const StatMetricSourceKey& other) const
{
if (observation_index != other.observation_index)
return observation_index < other.observation_index;
return channel_instance_index < other.channel_instance_index;
}
bool operator==(const StatMetricSourceKey& other) const
{
return observation_index == other.observation_index &&
channel_instance_index == other.channel_instance_index;
}
};
struct StatMetricSourceStats
{
StatMetricId metric_id = StatMetricId::Unknown;
StatMetricSourceKey key;
std::string observation_name;
std::string channel_name;
std::string quantity_name;
unsigned int phase_id = 0;
unsigned int quantity_measured_id = 0;
unsigned int quantity_units_id = 0;
PqdifGuidValue quantity_characteristic_id;
int channel_def_index = -1;
size_t point_count = 0;
size_t non_zero_count = 0;
double first_value = 0.0;
double min_value = 0.0;
double max_value = 0.0;
double sum_abs_value = 0.0;
bool has_first = false;
bool has_min_kind = false;
bool has_max_kind = false;
bool has_avg_kind = false;
bool has_p95_kind = false;
void add(const ExpandedStatPoint& p)
{
if (!has_first)
{
has_first = true;
first_value = p.value;
min_value = p.value;
max_value = p.value;
metric_id = p.metric_id;
key.observation_index = p.observation_index;
key.channel_instance_index = p.channel_instance_index;
observation_name = p.observation_name;
channel_name = p.channel_name;
quantity_name = p.quantity_name;
phase_id = p.phase_id;
quantity_measured_id = p.quantity_measured_id;
quantity_units_id = p.quantity_units_id;
quantity_characteristic_id = p.quantity_characteristic_id;
channel_def_index = p.channel_def_index;
}
++point_count;
if (std::fabs(p.value) > 1e-12)
++non_zero_count;
if (p.value < min_value)
min_value = p.value;
if (p.value > max_value)
max_value = p.value;
sum_abs_value += std::fabs(p.value);
switch (p.stat_kind)
{
case StatValueKind::Min: has_min_kind = true; break;
case StatValueKind::Max: has_max_kind = true; break;
case StatValueKind::Avg: has_avg_kind = true; break;
case StatValueKind::P95: has_p95_kind = true; break;
default: break;
}
}
double avg_abs_value() const
{
if (point_count == 0)
return 0.0;
return sum_abs_value / static_cast<double>(point_count);
}
bool all_zero() const
{
return point_count > 0 && non_zero_count == 0;
}
};
struct StatMetricQualityInfo
{
StatMetricQuality quality = StatMetricQuality::Normal;
std::string reason;
StatMetricSourceKey source_key;
std::string source_channel_name;
};
StatMetricSourceKey stat_make_source_key(const ExpandedStatPoint& p)
{
StatMetricSourceKey key;
key.observation_index = p.observation_index;
key.channel_instance_index = p.channel_instance_index;
return key;
}
bool stat_metric_has_alias(StatMetricId metric_id, const std::string& compact_channel)
{
if (stat_is_voltage_harmonic_metric(metric_id))
{
const int order = stat_voltage_harmonic_order(metric_id);
const int phase = stat_voltage_harmonic_phase_index(metric_id);
const std::string n = std::to_string(order);
const std::string nn = stat_two_digit(order);
const char p = phase == 0 ? 'A' : (phase == 1 ? 'B' : 'C');
std::string phase_text(1, p);
std::vector<std::string> aliases = {
"VHARM" + n + phase_text,
"VHARM" + nn + phase_text,
"VHARMONIC" + n + phase_text,
"VHARMONIC" + nn + phase_text,
"VHRMS" + n + phase_text,
"VHRMS" + nn + phase_text,
"UHARM" + n + phase_text,
"UHARM" + nn + phase_text,
"UHARMONIC" + n + phase_text,
"UHARMONIC" + nn + phase_text,
"UHRMS" + n + phase_text,
"UHRMS" + nn + phase_text,
"H" + n + phase_text,
"H" + nn + phase_text,
"HARM" + n + phase_text,
"HARM" + nn + phase_text,
"HARMONIC" + n + phase_text,
"HARMONIC" + nn + phase_text
};
return stat_contains_any_alias(compact_channel, aliases);
}
std::vector<std::string> aliases;
switch (metric_id)
{
case StatMetricId::UaRms:
aliases = { "VRMSA", "VARMS", "VAN", "UA", "URMSA" };
break;
case StatMetricId::UbRms:
aliases = { "VRMSB", "VBRMS", "VBN", "UB", "URMSB" };
break;
case StatMetricId::UcRms:
aliases = { "VRMSC", "VCRMS", "VCN", "UC", "URMSC" };
break;
case StatMetricId::IaRms:
aliases = { "IRMSA", "IARMS", "IA" };
break;
case StatMetricId::IbRms:
aliases = { "IRMSB", "IBRMS", "IB" };
break;
case StatMetricId::IcRms:
aliases = { "IRMSC", "ICRMS", "IC" };
break;
case StatMetricId::UabRms:
aliases = { "VRMSAB", "VABRMS", "VAB", "UAB", "URMSAB" };
break;
case StatMetricId::UbcRms:
aliases = { "VRMSBC", "VBCRMS", "VBC", "UBC", "URMSBC" };
break;
case StatMetricId::UcaRms:
aliases = { "VRMSCA", "VCARMS", "VCA", "UCA", "URMSCA" };
break;
case StatMetricId::UaDeviation:
aliases = { "UADEVIATION", "VADEVIATION", "VDEVA", "DEVA" };
break;
case StatMetricId::UbDeviation:
aliases = { "UBDEVIATION", "VBDEVIATION", "VDEVB", "DEVB" };
break;
case StatMetricId::UcDeviation:
aliases = { "UCDEVIATION", "VCDEVIATION", "VDEVC", "DEVC" };
break;
case StatMetricId::UabDeviation:
aliases = { "UABDEVIATION", "VABDEVIATION", "VDEVAB", "DEVAB" };
break;
case StatMetricId::UbcDeviation:
aliases = { "UBCDEVIATION", "VBCDEVIATION", "VDEVBC", "DEVBC" };
break;
case StatMetricId::UcaDeviation:
aliases = { "UCADEVIATION", "VCADEVIATION", "VDEVCA", "DEVCA" };
break;
case StatMetricId::Frequency:
aliases = { "FREQUENCY", "FREQ", "HZ" };
break;
case StatMetricId::FrequencyDeviation:
aliases = { "FREQDEV", "FREQUENCYDEV", "DELTAF", "FDEV" };
break;
case StatMetricId::UZeroSeq:
aliases = { "ZEROSEQUENCE", "ZEROSEQ", "ZEROSQ", "SZERO", "VZEROSEQ", "UZEROSEQ", "V0", "U0" };
break;
case StatMetricId::UNegSeq:
aliases = { "NEGATIVESEQUENCE", "NEGSEQ", "NEGSQ", "SNEG", "VNEGSEQ", "UNEGSEQ", "V2", "U2" };
break;
case StatMetricId::UPosSeq:
aliases = { "POSITIVESEQUENCE", "POSSEQ", "POSSQ", "SPOS", "VPOSSEQ", "UPOSSEQ", "V1", "U1" };
break;
case StatMetricId::UNegSeqUnbalance:
aliases = { "S2S1", "NEGATIVESEQUENCEUNBALANCE", "NEGSEQUNBALANCE", "NEGATIVEUNBALANCE", "NEGUNBALANCE", "VOLTAGEUNBALANCE", "VUNBALANCE", "VOLTAGEIMBALANCE" };
break;
case StatMetricId::IZeroSeq:
aliases = { "CURRENTZEROSEQUENCE", "CURRENTZEROSEQ", "IZEROSEQUENCE", "IZEROSEQ", "ISZERO", "IZEROSQ", "I0" };
break;
case StatMetricId::INegSeq:
aliases = { "CURRENTNEGATIVESEQUENCE", "CURRENTNEGSEQ", "INEGATIVESEQUENCE", "INEGSEQ", "ISNEG", "INEGSQ", "I2" };
break;
case StatMetricId::IPosSeq:
aliases = { "CURRENTPOSITIVESEQUENCE", "CURRENTPOSSEQ", "IPOSITIVESEQUENCE", "IPOSSEQ", "ISPOS", "IPOSSQ", "I1" };
break;
case StatMetricId::INegSeqUnbalance:
aliases = { "IS2S1", "CURRENTS2S1", "CURRENTNEGATIVESEQUENCEUNBALANCE", "CURRENTNEGSEQUNBALANCE", "INEGSEQUNBALANCE", "NEGSEQUNBALANCEI", "CURRENTUNBALANCE", "IUNBALANCE", "CURRENTIMBALANCE", "IIMBALANCE" };
break;
default:
break;
}
return stat_contains_any_alias(compact_channel, aliases);
}
int stat_metric_source_score(const StatMetricSourceStats& s)
{
int score = 0;
const std::string compact_channel = stat_compact_upper(s.channel_name);
const std::string compact_quantity = stat_compact_upper(s.quantity_name);
if (stat_metric_has_alias(s.metric_id, compact_channel))
score += 300;
if (stat_metric_has_alias(s.metric_id, compact_quantity))
score += 80;
if (s.has_min_kind) score += 10;
if (s.has_max_kind) score += 10;
if (s.has_avg_kind) score += 10;
if (s.has_p95_kind) score += 10;
// 统计点数越完整越优先，但不要让点数压过名称/语义。
if (s.point_count > 0)
score += static_cast<int>(std::min<size_t>(s.point_count / 100, 50));
// 电压/频率一般不应全为 0；但电流、零序/负序分量、负序不平衡为 0 在业务上可能是有效状态，
// 所以这些指标不在来源择优阶段扣分，只在质量状态中显式标记。
if (s.all_zero() && !stat_allow_all_zero_without_score_penalty(s.metric_id))
score -= 200;
// 线电压 RMS 若是毫伏级，极大概率不是线电压有效值，但仍保留为候选并标记质量，
// 这里仅降低其优先级，避免有更可信来源时被选中。
if (stat_is_line_voltage_metric(s.metric_id) && s.avg_abs_value() < 1.0)
score -= 500;
// 频率值通常应在合理范围；异常值降低优先级。
if (stat_is_frequency_metric(s.metric_id))
{
const double avg_abs = s.avg_abs_value();
if (avg_abs > 0.0 && (avg_abs < 1.0 || avg_abs > 1000.0))
score -= 200;
}
return score;
}
void stat_print_stream_stats_line(
const char* prefix,
const StatMetricSourceStats& s,
int score,
const char* extra_text)
{
std::cout << prefix
<< " metric=" << stat_metric_name(s.metric_id)
<< ", ch=" << s.key.channel_instance_index
<< ", ch_def=" << s.channel_def_index
<< ", channel=" << s.channel_name
<< ", phase=" << pqdif_sem::FindPhaseName(s.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(s.quantity_measured_id)
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(s.quantity_units_id)
<< ", characteristic=" << short_guid_name(s.quantity_characteristic_id)
<< ", points=" << s.point_count
<< ", first=" << s.first_value
<< ", min=" << s.min_value
<< ", max=" << s.max_value
<< ", avg_abs=" << s.avg_abs_value()
<< ", kinds="
<< (s.has_min_kind ? "Min" : "-") << "/"
<< (s.has_max_kind ? "Max" : "-") << "/"
<< (s.has_avg_kind ? "Avg" : "-") << "/"
<< (s.has_p95_kind ? "P95" : "-")
<< ", score=" << score;
if (extra_text != nullptr && extra_text[0] != '\0')
std::cout << ", " << extra_text;
std::cout << std::endl;
}
/// @brief 对同一 metric 的多来源候选流进行择优，避免进入聚合层后静默覆盖。
/// @details
/// 保留同一 metric 最可信的一个通道来源；详细模式下打印所有候选来源。
/// 核心模式只打印汇总和必要的重复来源提示，避免谐波指标造成海量日志。
std::vector<ExpandedStatPoint> stat_select_best_metric_sources(
const std::vector<ExpandedStatPoint>& points)
{
typedef std::map<StatMetricSourceKey, StatMetricSourceStats> SourceMap;
std::map<StatMetricId, SourceMap> by_metric;
for (const auto& p : points)
{
StatMetricSourceKey key = stat_make_source_key(p);
StatMetricSourceStats& stats = by_metric[p.metric_id][key];
stats.add(p);
}
std::map<StatMetricId, StatMetricSourceKey> selected_source;
const bool detail_log = pqdif_is_detail_log_enabled();
size_t selected_metric_count = 0;
size_t selected_voltage_harmonic_count = 0;
size_t selected_dynamic_metric_count = 0;
size_t duplicate_metric_count = 0;
std::cout << "========== STAT STREAM SOURCE SUMMARY ==========" << std::endl;
std::cout << "candidate_metric_count=" << by_metric.size()
<< ", candidate_point_count=" << points.size()
<< ", detail_log=" << (detail_log ? "on" : "off")
<< std::endl;
for (auto& metric_pair : by_metric)
{
const StatMetricId metric_id = metric_pair.first;
SourceMap& sources = metric_pair.second;
bool has_selected = false;
StatMetricSourceKey best_key;
int best_score = std::numeric_limits<int>::min();
for (auto& src_pair : sources)
{
const int score = stat_metric_source_score(src_pair.second);
if (!has_selected || score > best_score)
{
has_selected = true;
best_score = score;
best_key = src_pair.first;
}
}
if (has_selected)
{
selected_source[metric_id] = best_key;
++selected_metric_count;
if (stat_is_voltage_harmonic_metric(metric_id))
++selected_voltage_harmonic_count;
if (stat_is_dynamic_metric(metric_id))
++selected_dynamic_metric_count;
}
if (sources.size() > 1)
{
++duplicate_metric_count;
if (pqdif_log_enabled(PqdifLogLevel::Info))
{
std::cout << " [DUPLICATE METRIC SOURCES] metric="
<< stat_metric_name(metric_id)
<< ", source_count=" << sources.size()
<< ", dynamic=" << (stat_is_dynamic_metric(metric_id) ? "true" : "false")
<< ", action=select_best_source_and_drop_others"
<< std::endl;
}
}
// 只有 Debug/Trace 才展开每个 selected/dropped source。Core/Info 保持短日志，
// 避免一个谱类指标重复 50 个来源时刷屏。
if (detail_log)
{
for (auto& src_pair : sources)
{
const int score = stat_metric_source_score(src_pair.second);
const bool selected = has_selected && (src_pair.first == best_key);
stat_print_stream_stats_line(
selected ? " [STREAM SELECTED]" : " [STREAM DROPPED]",
src_pair.second,
score,
selected ? "selected=true" : "reason=duplicate_or_lower_score");
}
}
}
std::cout << " [STAT STREAM CORE] selected_metric_count=" << selected_metric_count
<< ", selected_dynamic_metrics=" << selected_dynamic_metric_count << "/" << stat_all_dynamic_metric_order().size()
<< ", selected_voltage_harmonics=" << selected_voltage_harmonic_count << "/147"
<< ", duplicate_metric_count=" << duplicate_metric_count
<< std::endl;
std::cout << "================================================" << std::endl;
std::vector<ExpandedStatPoint> out;
out.reserve(points.size());
for (const auto& p : points)
{
const auto it = selected_source.find(p.metric_id);
if (it == selected_source.end())
continue;
if (stat_make_source_key(p) == it->second)
out.push_back(p);
}
return out;
}
std::map<StatMetricId, StatMetricSourceStats> stat_collect_metric_stats(
const std::vector<ExpandedStatPoint>& points)
{
std::map<StatMetricId, StatMetricSourceStats> out;
for (const auto& p : points)
{
StatMetricSourceStats& stats = out[p.metric_id];
stats.add(p);
}
return out;
}
std::map<StatMetricId, StatMetricQualityInfo> stat_analyze_metric_quality(
const std::vector<ExpandedStatPoint>& points)
{
std::map<StatMetricId, StatMetricQualityInfo> out;
std::map<StatMetricId, StatMetricSourceStats> stats_by_metric = stat_collect_metric_stats(points);
double phase_voltage_avg_sum = 0.0;
int phase_voltage_avg_count = 0;
const StatMetricId phase_metrics[3] = {
StatMetricId::UaRms,
StatMetricId::UbRms,
StatMetricId::UcRms
};
for (int i = 0; i < 3; ++i)
{
const auto it = stats_by_metric.find(phase_metrics[i]);
if (it != stats_by_metric.end() && it->second.avg_abs_value() > 1.0)
{
phase_voltage_avg_sum += it->second.avg_abs_value();
++phase_voltage_avg_count;
}
}
const double phase_voltage_avg =
phase_voltage_avg_count > 0 ? phase_voltage_avg_sum / static_cast<double>(phase_voltage_avg_count) : 0.0;
for (const auto& metric_pair : stats_by_metric)
{
const StatMetricId metric_id = metric_pair.first;
const StatMetricSourceStats& s = metric_pair.second;
StatMetricQualityInfo qi;
qi.source_key = s.key;
qi.source_channel_name = s.channel_name;
qi.quality = StatMetricQuality::Normal;
qi.reason = "ok";
if (s.all_zero())
{
qi.quality = StatMetricQuality::AllZero;
qi.reason = "all selected values are zero";
}
else if (stat_is_phase_voltage_metric(metric_id) && s.avg_abs_value() < 1.0)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = "phase voltage RMS avg_abs < 1V";
}
else if (stat_is_line_voltage_metric(metric_id))
{
const double line_avg = s.avg_abs_value();
bool suspicious = false;
std::ostringstream reason;
if (line_avg < 1.0)
{
suspicious = true;
reason << "line voltage RMS avg_abs < 1V";
}
if (phase_voltage_avg > 1.0)
{
const double ratio = line_avg / phase_voltage_avg;
if (ratio < 1.25 || ratio > 2.20)
{
if (suspicious)
reason << "; ";
suspicious = true;
reason << "line/phase ratio=" << ratio
<< " outside expected Wye range [1.25,2.20]";
}
}
if (suspicious)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = reason.str();
}
}
else if (stat_is_dynamic_metric(metric_id))
{
// 谐波/间谐波/相角类指标可以为 0 或很小；这里只标记明显量级异常。
const double avg_abs = s.avg_abs_value();
if (avg_abs > 1000000.0)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = "dynamic spectrum metric avg_abs > 1e6";
}
}
else if (stat_is_voltage_sequence_component_metric(metric_id))
{
// 序分量可以很小，尤其是零序/负序；这里只对明显不合理的大幅值做提示，
// 不使用 <1V 判定，避免把健康系统的低负序/低零序误标为异常。
const double avg_abs = s.avg_abs_value();
if (avg_abs > 1000000.0)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = "voltage sequence component avg_abs > 1e6 V";
}
}
else if (stat_is_voltage_sequence_unbalance_metric(metric_id))
{
const double avg_abs = s.avg_abs_value();
if (avg_abs > 1000.0)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = "voltage negative sequence unbalance avg_abs > 1000";
}
}
else if (stat_is_current_sequence_component_metric(metric_id))
{
// 电流序分量可以为 0 或很小；这里只对明显异常的大幅值做提示。
const double avg_abs = s.avg_abs_value();
if (avg_abs > 1000000.0)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = "current sequence component avg_abs > 1e6 A";
}
}
else if (stat_is_current_sequence_unbalance_metric(metric_id))
{
const double avg_abs = s.avg_abs_value();
if (avg_abs > 1000.0)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = "current negative sequence unbalance avg_abs > 1000";
}
}
else if (metric_id == StatMetricId::Frequency)
{
const double avg_abs = s.avg_abs_value();
if (avg_abs < 1.0 || avg_abs > 1000.0)
{
qi.quality = StatMetricQuality::SuspiciousRange;
qi.reason = "frequency avg_abs outside [1,1000] Hz";
}
}
out[metric_id] = qi;
}
return out;
}
const StatMetricQualityInfo* stat_find_quality_info(
const std::map<StatMetricId, StatMetricQualityInfo>& quality_by_metric,
StatMetricId metric_id)
{
const auto it = quality_by_metric.find(metric_id);
if (it == quality_by_metric.end())
return nullptr;
return &it->second;
}
/// @brief 将一个 observation 中的单个通道实例展开为若干统计样本点。
bool stat_channel_has_explicit_harmonic_group_id(const PqdifChannelInstance& ch)
{
return ch.channel_group_id >= 2 && ch.channel_group_id <= 50;
}
bool stat_same_spectrum_channel_family(
const PqdifChannelInstance& a,
const PqdifChannelInstance& b)
{
if (a.channel_def_index != b.channel_def_index)
return false;
if (a.phase_id != b.phase_id)
return false;
if (a.quantity_measured_id != b.quantity_measured_id)
return false;
return stat_compact_upper(a.channel_name) == stat_compact_upper(b.channel_name);
}
int stat_make_channel_spectrum_order_hint(
const PqdifObservationRecord& obs,
const PqdifChannelInstance& ch,
int& block_offset,
int& block_size)
{
block_offset = -1;
block_size = 0;
// 已经有明确 group=2..50 时，必须优先走标准字段，不使用顺序推导。
if (stat_channel_has_explicit_harmonic_group_id(ch))
return -1;
int offset = 0;
for (const auto& other : obs.channel_instances)
{
if (!stat_same_spectrum_channel_family(other, ch))
continue;
// 只在“同一通道族内 group/base/nominal 缺失”的谱线中按顺序补次数。
// 这样不会把已经有标准 group 的通道也混入顺序计算。
if (stat_channel_has_explicit_harmonic_group_id(other))
continue;
if (other.channel_instance_index == ch.channel_instance_index)
block_offset = offset;
++offset;
++block_size;
}
if (block_offset < 0)
return -1;
// 2-50 次谐波通常有 49 条谱线；个别厂家会额外带一个总量或占位，
// 所以允许 >=49，但只映射前 49 条为 2..50。
if (block_size < 49)
return -1;
const int order = block_offset + 2;
return (order >= 2 && order <= 50) ? order : -1;
}
/// @details
/// 处理内容：
/// 1) 自动解析共享时间轴；
/// 2) 自动完成工程值还原；
/// 3) 依据 C.2 表语义 + 相别 + 值类型 识别业务指标。
/// @param lf 完整 PQDIF 逻辑对象。
/// @param connection_kind 当前文件接线方式。
/// @param obs 当前 observation。
/// @param ch 当前通道实例。
/// @return 当前通道展开出的统计样本点集合。
std::vector<ExpandedStatPoint> stat_expand_channel_points(
const PqdifLogicalFile& lf,
ParsedConnectionKind connection_kind,
const PqdifObservationRecord& obs,
const PqdifChannelInstance& ch)
{
std::vector<ExpandedStatPoint> out;
if (!pqdif_sem::IsQuantityTypeValueLog(ch.quantity_type_id.value))
return out;
const PqdifDataSourceRecord* ds = stat_find_related_data_source(lf, obs);
const PqdifChannelDefinition* ch_def = stat_find_channel_definition(ds, ch.channel_def_index);
const PqdifSeriesInstance* time_series = nullptr;
for (const auto& si : ch.series_instances)
{
if (pqdif_sem::IsValueTypeTime(si.value_type_id.value))
{
time_series = stat_resolve_shared_series(obs, si);
break;
}
}
// Pst/Plt/DVC 等窗口统计量在部分设备中只有“一个值序列”，甚至不写独立时间轴。
// 这里不再因为缺失时间轴直接丢弃整个通道；后面仅允许可识别的标量统计指标使用
// observation 的 start/create time 作为兜底时间，避免 Plt 通道存在但被静默忽略。
const bool has_usable_time_series = (time_series != nullptr && time_series->values.count > 0);
std::set<StatValueKind> explicit_stat_value_kinds;
for (const auto& stat_probe_si : ch.series_instances)
{
const PqdifSeriesDefinition* stat_probe_sd = stat_find_series_definition(ch_def, stat_probe_si.series_def_index);
const StatValueKind probe_kind = stat_identify_value_kind(stat_probe_si, stat_probe_sd);
if (probe_kind != StatValueKind::Unknown)
explicit_stat_value_kinds.insert(probe_kind);
}
const bool channel_has_single_or_no_stat_value_kind = explicit_stat_value_kinds.size() <= 1;
for (size_t i = 0; i < ch.series_instances.size(); ++i)
{
const auto& si = ch.series_instances[i];
const PqdifSeriesDefinition* sd = stat_find_series_definition(ch_def, si.series_def_index);
const StatValueKind stat_kind = stat_identify_value_kind(si, sd);
const PqdifSeriesInstance* resolved_value_series = stat_resolve_shared_series(obs, si);
if (resolved_value_series == nullptr || resolved_value_series->values.count <= 0)
continue;
const unsigned int storage_method_id = (sd != nullptr) ? sd->storage_method_id : 0;
const size_t value_count = static_cast<size_t>(std::max<long>(resolved_value_series->values.count, 0));
const size_t time_count = has_usable_time_series ?
static_cast<size_t>(std::max<long>(time_series->values.count, 0)) : value_count;
const size_t point_count = std::min(time_count, value_count);
for (size_t k = 0; k < point_count; ++k)
{
time_t ts = 0;
if (has_usable_time_series)
{
if (!stat_resolve_timestamp_at(obs, *time_series, k, ts))
continue;
}
else
{
// 单值统计通道无时间轴时，使用 observation 起始时间兜底；没有起始时间则用创建时间。
ts = (obs.time_start.unix_time != 0) ? obs.time_start.unix_time : obs.time_create.unix_time;
if (ts == 0)
ts = std::time(nullptr);
if (k > 0)
ts += static_cast<time_t>(k);
}
double raw_value = 0.0;
if (!stat_try_get_raw_numeric_at(resolved_value_series->values, k, raw_value))
continue;
ExpandedStatPoint p;
p.timestamp = ts;
p.timestamp_text = format_time_text(ts);
p.observation_index = obs.observation_index;
p.channel_instance_index = ch.channel_instance_index;
p.channel_def_index = ch.channel_def_index;
p.channel_group_id = ch.channel_group_id;
p.channel_spectrum_order_hint = stat_make_channel_spectrum_order_hint(
obs,
ch,
p.channel_spectrum_block_offset,
p.channel_spectrum_block_size);
p.series_instance_index = static_cast<int>(i);
p.series_def_index = si.series_def_index;
p.sample_index = static_cast<int>(k);
p.observation_name = obs.observation_name;
p.channel_name = ch.channel_name;
p.quantity_name = (ch_def != nullptr) ? ch_def->quantity_name : std::string();
p.phase_id = ch.phase_id;
p.quantity_type_id = ch.quantity_type_id;
p.quantity_measured_id = ch.quantity_measured_id;
p.quantity_units_id = si.quantity_units_id;
p.quantity_characteristic_id = si.quantity_characteristic_id;
p.value_type_id = si.value_type_id;
p.prob_percentile = (sd != nullptr) ? sd->prob_percentile : 0.0;
p.series_base_quantity = si.series_base_quantity;
p.nominal_quantity = si.nominal_quantity;
p.connection_kind = connection_kind;
p.stat_kind = stat_kind;
p.value = stat_decode_engineering_value(
raw_value,
*resolved_value_series,
storage_method_id,
resolved_value_series->values.physical_type);
p.metric_id = stat_identify_metric_id(connection_kind, p, p.matched_by_name_fallback);
if (p.metric_id == StatMetricId::Unknown)
continue;
const bool scalar_stat_metric =
stat_metric_can_use_scalar_series_as_all_kinds(p.metric_id) &&
stat_series_can_be_scalar_stat_value(si, sd);
// 没有时间轴的通道只允许 Pst/Plt/DVC 这类窗口标量指标走兜底，
// 防止其它普通统计通道在无时间轴时被错误展开。
if (!has_usable_time_series && !scalar_stat_metric)
continue;
// 修复 Pst/Plt：很多设备把 Pst/Plt 写成单个 Avg/Value 序列，而不是四条
// Min/Max/Avg/P95 序列。只要该通道只有单个统计序列或无明确统计值类型，就用同一物理值补齐四种
// 统计值，确保最终 bucket 与 METRIC STATUS 都能看到完整 max/min/avg/p95。
if (scalar_stat_metric && channel_has_single_or_no_stat_value_kind)
{
const StatValueKind fallback_kinds[] = {
StatValueKind::Min,
StatValueKind::Max,
StatValueKind::Avg,
StatValueKind::P95
};
for (const StatValueKind fallback_kind : fallback_kinds)
{
ExpandedStatPoint q = p;
q.stat_kind = fallback_kind;
out.push_back(std::move(q));
}
continue;
}
if (stat_kind != StatValueKind::Unknown)
{
out.push_back(std::move(p));
continue;
}
}
}
return out;
}
bool stat_metric_in_primary_targets(StatMetricId id)
{
const std::vector<StatMetricId>& targets = stat_primary_metric_print_order();
return std::find(targets.begin(), targets.end(), id) != targets.end();
}
/// @brief 从全部 observation 中补齐主 observation 缺失的目标指标。
/// @details
/// 统一 fallback 策略：所有指标都先从主统计 observation 解析；如果某个目标指标在主
/// observation 中完全找不到，则遍历其他 observations，直到找到该指标的数据来源。
/// 这样后续新增谐波、间谐波、电流谐波等指标时，不需要为每类指标写一套独立的
/// observation 查找流程。
std::vector<ExpandedStatPoint> stat_expand_missing_metrics_from_all_observations(
const PqdifLogicalFile& lf,
ParsedConnectionKind connection_kind,
const std::vector<ExpandedStatPoint>& primary_points,
int selected_observation_index)
{
std::vector<ExpandedStatPoint> out;
std::set<StatMetricId> present_metrics;
for (const auto& p : primary_points)
{
if (p.metric_id != StatMetricId::Unknown)
present_metrics.insert(p.metric_id);
}
std::set<StatMetricId> missing_targets;
for (const auto metric_id : stat_primary_metric_print_order())
{
if (present_metrics.find(metric_id) == present_metrics.end())
missing_targets.insert(metric_id);
}
if (missing_targets.empty())
return out;
std::map<StatMetricId, std::vector<ExpandedStatPoint>> fallback_by_metric;
for (const auto& obs : lf.observations)
{
if (obs.observation_index == selected_observation_index)
continue;
for (const auto& ch : obs.channel_instances)
{
auto points = stat_expand_channel_points(lf, connection_kind, obs, ch);
for (auto& p : points)
{
if (missing_targets.find(p.metric_id) == missing_targets.end())
continue;
fallback_by_metric[p.metric_id].push_back(std::move(p));
}
}
// 已经为所有缺失指标找到了候选点，可以停止继续扫后续 observation。
bool all_found = true;
for (const auto metric_id : missing_targets)
{
if (fallback_by_metric.find(metric_id) == fallback_by_metric.end())
{
all_found = false;
break;
}
}
if (all_found)
break;
}
for (const auto metric_id : stat_primary_metric_print_order())
{
const auto it = fallback_by_metric.find(metric_id);
if (it == fallback_by_metric.end())
continue;
out.insert(out.end(),
std::make_move_iterator(it->second.begin()),
std::make_move_iterator(it->second.end()));
}
if (!out.empty() && pqdif_log_enabled(PqdifLogLevel::Info))
{
size_t dynamic_metrics = 0;
size_t core_metrics = 0;
std::set<StatMetricId> loaded_metrics;
for (const auto& p : out)
loaded_metrics.insert(p.metric_id);
for (const auto metric_id : loaded_metrics)
{
if (stat_is_dynamic_metric(metric_id))
++dynamic_metrics;
else
++core_metrics;
}
std::cout << "[PQDIF] observation fallback loaded "
<< out.size() << " points for " << loaded_metrics.size()
<< " missing metrics"
<< " (core=" << core_metrics
<< ", dynamic_spectrum=" << dynamic_metrics << ")"
<< std::endl;
}
else if (out.empty() && pqdif_log_enabled(PqdifLogLevel::Debug))
{
std::cout << "[PQDIF] observation fallback: no missing target metric found in other observations"
<< std::endl;
}
return out;
}
bool stat_has_any_voltage_harmonic_points(const std::vector<ExpandedStatPoint>& points)
{
for (const auto& p : points)
{
if (stat_is_voltage_harmonic_metric(p.metric_id))
return true;
}
return false;
}
/// @brief 展开统计样本点，并对缺失指标执行 observation fallback。
/// @details
/// 第一阶段仍以主统计 observation 为基础，避免普通 RMS/频率/序分量在多 observation 之间互相覆盖。
/// 第二阶段针对当前已知会出现在其他 observation 的三相电压谐波 RMS，遍历全部 observations 补充。
/// 后续新增间谐波、电流谐波等指标时，应优先复用这种“主 observation + 指标族 fallback”的模式。
std::vector<ExpandedStatPoint> stat_expand_selected_statistical_observation(
const PqdifLogicalFile& lf,
ParsedConnectionKind connection_kind,
int& selected_observation_index,
std::string& selected_observation_name)
{
selected_observation_index = -1;
selected_observation_name.clear();
std::vector<ExpandedStatPoint> out;
const PqdifObservationRecord* selected = stat_select_primary_statistical_observation(lf);
if (selected != nullptr)
{
selected_observation_index = selected->observation_index;
selected_observation_name = selected->observation_name;
for (const auto& ch : selected->channel_instances)
{
auto points = stat_expand_channel_points(lf, connection_kind, *selected, ch);
out.insert(out.end(),
std::make_move_iterator(points.begin()),
std::make_move_iterator(points.end()));
}
}
// 对主 observation 缺失的目标指标执行统一 observation fallback。
// 例如：普通趋势指标可能在 Trend observation，而 V HRMS A/B/C 2-50 次谐波在另一条 observation。
auto fallback_points = stat_expand_missing_metrics_from_all_observations(
lf,
connection_kind,
out,
selected_observation_index);
if (!fallback_points.empty())
{
out.insert(out.end(),
std::make_move_iterator(fallback_points.begin()),
std::make_move_iterator(fallback_points.end()));
}
// 对同一 metric 的多来源候选流先做择优，避免后续按 timestamp 聚合时静默覆盖。
return stat_select_best_metric_sources(out);
}
bool pqdif_probe_text_looks_like_flicker(const std::string& text)
{
const std::string key = normalize_key(text);
return key.find("FLICKER") != std::string::npos ||
key.find("FLKR") != std::string::npos ||
key.find("PST") != std::string::npos ||
key.find("PLT") != std::string::npos ||
key.find("DVC") != std::string::npos ||
key.find("DELTAV") != std::string::npos;
}
/// @brief DEBUG 级别闪变候选通道诊断。
/// @details 用于核查 Pst/Plt/DVC 通道是否真实有数据；尤其是 Plt 通道存在但 values.count=0 时，
/// 这里能直接看出来，避免误以为是名称匹配失败。
void dump_flicker_candidate_probe(const ParsedPqdifFile& parsed_file)
{
const auto& lf = parsed_file.logical_file;
std::cout << "========== PQDIF FLICKER CANDIDATE PROBE V18 ==========" << std::endl;
std::cout << "file=" << parsed_file.source_file << std::endl;
std::cout << "rule=DEBUG level: print all Pst/Plt/DVC/Flicker candidate channels and series counts" << std::endl;
size_t hit_count = 0;
size_t plt_channel_count = 0;
size_t plt_value_point_count = 0;
for (const auto& obs : lf.observations)
{
const PqdifDataSourceRecord* ds = stat_find_related_data_source(lf, obs);
for (const auto& ch : obs.channel_instances)
{
const PqdifChannelDefinition* ch_def = stat_find_channel_definition(ds, ch.channel_def_index);
bool candidate = pqdif_probe_text_looks_like_flicker(ch.channel_name) ||
pqdif_probe_text_looks_like_flicker(ch.quantity_type_id.symbolic_name);
if (ch_def != nullptr)
{
candidate = candidate ||
pqdif_probe_text_looks_like_flicker(ch_def->channel_name) ||
pqdif_probe_text_looks_like_flicker(ch_def->quantity_name);
}
for (const auto& si : ch.series_instances)
{
candidate = candidate ||
pqdif_probe_text_looks_like_flicker(si.value_type_id.symbolic_name) ||
pqdif_probe_text_looks_like_flicker(si.quantity_characteristic_id.symbolic_name);
}
if (!candidate)
continue;
++hit_count;
const std::string compact_name = normalize_key(ch.channel_name + " " + ((ch_def != nullptr) ? ch_def->channel_name : std::string()));
const bool is_plt_candidate = compact_name.find("PLT") != std::string::npos;
if (is_plt_candidate)
++plt_channel_count;
std::cout << " [FLICKER-CH] obs=" << obs.observation_index
<< ", obs_name=" << obs.observation_name
<< ", obs_start=" << obs.time_start.text
<< ", ch=" << ch.channel_instance_index
<< ", ch_def=" << ch.channel_def_index
<< ", channel=" << ch.channel_name
<< ", def_channel=" << ((ch_def != nullptr) ? ch_def->channel_name : std::string())
<< ", phase=" << pqdif_sem::FindPhaseName(ch.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(ch.quantity_measured_id)
<< ", series_instances=" << ch.series_instances.size()
<< std::endl;
for (size_t si_index = 0; si_index < ch.series_instances.size(); ++si_index)
{
const auto& si = ch.series_instances[si_index];
const PqdifSeriesDefinition* sd = stat_find_series_definition(ch_def, si.series_def_index);
const PqdifSeriesInstance* resolved = stat_resolve_shared_series(obs, si);
const long value_count = (resolved != nullptr) ? resolved->values.count : -1;
if (is_plt_candidate && value_count > 0)
plt_value_point_count += static_cast<size_t>(value_count);
std::cout << " [FLICKER-SER] ser=" << si_index
<< ", ser_def=" << si.series_def_index
<< ", value_type=" << short_guid_name(si.value_type_id)
<< ", characteristic=" << short_guid_name(si.quantity_characteristic_id)
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(si.quantity_units_id)
<< ", resolved_count=" << value_count;
if (resolved != nullptr && value_count > 0)
{
double raw_value = 0.0;
if (stat_try_get_raw_numeric_at(resolved->values, 0, raw_value))
{
const unsigned int storage_method_id = (sd != nullptr) ? sd->storage_method_id : 0;
const double first_value = stat_decode_engineering_value(
raw_value,
*resolved,
storage_method_id,
resolved->values.physical_type);
std::cout << ", first=" << first_value;
}
}
std::cout << std::endl;
}
}
}
std::cout << " [FLICKER SUMMARY] candidate_channels=" << hit_count
<< ", plt_candidate_channels=" << plt_channel_count
<< ", plt_value_points=" << plt_value_point_count
<< std::endl;
std::cout << "===================================================" << std::endl;
}
/// @brief 将单个样本点应用到同一时间桶里的某个指标聚合值上。
/// @details
/// 这里不再允许静默覆盖：同一 timestamp + metric + kind 再次写入时，保留首次写入值，
/// 并把该 metric 标记为 DuplicateSource，同时打印冲突来源。
/// @param bucket 目标时间桶。
/// @param p 已识别统计样本点。
/// @param quality_by_metric 指标级质量状态。
void stat_apply_point_to_bucket(
TimeAggregatedStatBucket& bucket,
const ExpandedStatPoint& p,
const std::map<StatMetricId, StatMetricQualityInfo>& quality_by_metric)
{
auto& agg = bucket.metrics[p.metric_id];
const StatMetricQualityInfo* qi = stat_find_quality_info(quality_by_metric, p.metric_id);
if (qi != nullptr && agg.quality == StatMetricQuality::Normal)
{
agg.quality = qi->quality;
agg.quality_reason = qi->reason;
}
if (agg.source_observation_index < 0)
{
agg.source_observation_index = p.observation_index;
agg.source_channel_instance_index = p.channel_instance_index;
agg.source_channel_name = p.channel_name;
}
if (stat_has_value_kind(agg, p.stat_kind))
{
const double old_value = stat_get_value_by_kind(agg, p.stat_kind);
std::ostringstream reason;
reason << "duplicate write: kind=" << stat_value_kind_name(p.stat_kind)
<< ", old_value=" << old_value
<< ", new_value=" << p.value
<< ", old_ch=" << agg.source_channel_instance_index
<< ", new_ch=" << p.channel_instance_index;
agg.quality = StatMetricQuality::DuplicateSource;
agg.quality_reason = reason.str();
static size_t duplicate_print_count = 0;
if (duplicate_print_count < 80)
{
std::cout << " [DUPLICATE STAT VALUE]"
<< " time=" << p.timestamp_text
<< ", metric=" << stat_metric_name(p.metric_id)
<< ", kind=" << stat_value_kind_name(p.stat_kind)
<< ", old_value=" << old_value
<< ", new_value=" << p.value
<< ", old_ch=" << agg.source_channel_instance_index
<< ", new_ch=" << p.channel_instance_index
<< ", new_ser=" << p.series_instance_index
<< ", new_channel=" << p.channel_name
<< std::endl;
++duplicate_print_count;
if (duplicate_print_count == 80)
{
std::cout << " [DUPLICATE STAT VALUE] print limit reached, further duplicate details suppressed"
<< std::endl;
}
}
// 调试和修复阶段保留首次写入，拒绝覆盖，避免结果继续被污染。
return;
}
agg.source_series_instance_index = p.series_instance_index;
switch (p.stat_kind)
{
case StatValueKind::Min:
agg.has_min = true;
agg.min_value = p.value;
break;
case StatValueKind::Max:
agg.has_max = true;
agg.max_value = p.value;
break;
case StatValueKind::Avg:
agg.has_avg = true;
agg.avg_value = p.value;
break;
case StatValueKind::P95:
agg.has_p95 = true;
agg.p95_value = p.value;
break;
default:
break;
}
}
/// @brief 将统计样本点按 timestamp 聚合成时间桶。
/// @details
/// 当前阶段已经先筛掉非统计 observation，并做过 metric 来源择优；这里仍保留覆盖检测，
/// 用于防止后续新增指标时重新引入静默覆盖。
/// @param points 已识别统计样本点。
/// @return 聚合后的时间桶数组，按时间升序输出。
std::vector<TimeAggregatedStatBucket> stat_group_points_by_timestamp(
const std::vector<ExpandedStatPoint>& points)
{
const std::map<StatMetricId, StatMetricQualityInfo> quality_by_metric =
stat_analyze_metric_quality(points);
std::map<time_t, TimeAggregatedStatBucket> buckets;
for (const auto& p : points)
{
auto& bucket = buckets[p.timestamp];
if (bucket.timestamp == 0)
{
bucket.timestamp = p.timestamp;
bucket.timestamp_text = p.timestamp_text;
}
stat_apply_point_to_bucket(bucket, p, quality_by_metric);
}
std::vector<TimeAggregatedStatBucket> out;
out.reserve(buckets.size());
for (auto& kv : buckets)
out.push_back(std::move(kv.second));
return out;
}
void stat_print_aggregated_metric_line(StatMetricId metric_id, const AggregatedStatValues* agg)
{
std::cout << " metric=" << stat_metric_name(metric_id);
if (agg == nullptr)
{
std::cout << ", quality=" << stat_metric_quality_name(StatMetricQuality::Missing)
<< std::endl;
return;
}
if (agg->has_min) std::cout << ", min=" << agg->min_value;
else std::cout << ", min=N/A";
if (agg->has_max) std::cout << ", max=" << agg->max_value;
else std::cout << ", max=N/A";
if (agg->has_avg) std::cout << ", avg=" << agg->avg_value;
else std::cout << ", avg=N/A";
if (agg->has_p95) std::cout << ", p95=" << agg->p95_value;
else std::cout << ", p95=N/A";
std::cout << ", quality=" << stat_metric_quality_name(agg->quality);
if (!agg->quality_reason.empty())
std::cout << ", reason=" << agg->quality_reason;
if (agg->source_channel_instance_index >= 0)
{
std::cout << ", source_ch=" << agg->source_channel_instance_index;
if (!agg->source_channel_name.empty())
std::cout << ", source_channel=" << agg->source_channel_name;
}
std::cout << std::endl;
}
size_t stat_count_present_metrics(const std::vector<ExpandedStatPoint>& points)
{
std::set<StatMetricId> ids;
for (const auto& p : points)
ids.insert(p.metric_id);
return ids.size();
}
size_t stat_count_present_voltage_harmonic_metrics(const std::vector<ExpandedStatPoint>& points)
{
std::set<StatMetricId> ids;
for (const auto& p : points)
{
if (stat_is_voltage_harmonic_metric(p.metric_id))
ids.insert(p.metric_id);
}
return ids.size();
}
std::vector<StatMetricId> stat_present_voltage_harmonic_metrics(
const std::map<StatMetricId, StatMetricSourceStats>& stats_by_metric)
{
std::vector<StatMetricId> out;
for (const auto& kv : stats_by_metric)
{
if (stat_is_voltage_harmonic_metric(kv.first))
out.push_back(kv.first);
}
std::sort(out.begin(), out.end(), [](StatMetricId a, StatMetricId b) {
return static_cast<int>(a) < static_cast<int>(b);
});
return out;
}
const char* stat_dynamic_group_display_name(StatDynamicMetricGroup group)
{
switch (group)
{
case StatDynamicMetricGroup::VoltageHarmonic: return "VoltageHarmonic";
case StatDynamicMetricGroup::LineVoltageHarmonic: return "LineVoltageHarmonic";
case StatDynamicMetricGroup::CurrentHarmonic: return "CurrentHarmonic";
case StatDynamicMetricGroup::VoltageHarmonicAngle: return "VoltageHarmonicAngle";
case StatDynamicMetricGroup::LineVoltageHarmonicAngle: return "LineVoltageHarmonicAngle";
case StatDynamicMetricGroup::CurrentHarmonicAngle: return "CurrentHarmonicAngle";
case StatDynamicMetricGroup::HarmonicActivePower: return "HarmonicActivePower";
case StatDynamicMetricGroup::HarmonicReactivePower: return "HarmonicReactivePower";
case StatDynamicMetricGroup::HarmonicApparentPower: return "HarmonicApparentPower";
case StatDynamicMetricGroup::VoltageHarmonicRatio: return "VoltageHarmonicRatio";
case StatDynamicMetricGroup::LineVoltageHarmonicRatio: return "LineVoltageHarmonicRatio";
case StatDynamicMetricGroup::CurrentHarmonicRatio: return "CurrentHarmonicRatio";
case StatDynamicMetricGroup::VoltageInterharmonic: return "VoltageInterharmonic";
case StatDynamicMetricGroup::LineVoltageInterharmonic: return "LineVoltageInterharmonic";
case StatDynamicMetricGroup::CurrentInterharmonic: return "CurrentInterharmonic";
default: return "UnknownDynamicGroup";
}
}
size_t stat_dynamic_group_expected_count(StatDynamicMetricGroup group)
{
return stat_dynamic_metric_order_for_group(group).size();
}
std::vector<StatMetricId> stat_present_dynamic_group_metrics(
const std::map<StatMetricId, StatMetricSourceStats>& stats_by_metric,
StatDynamicMetricGroup group)
{
std::vector<StatMetricId> out;
for (const auto& kv : stats_by_metric)
{
if (stat_is_dynamic_metric_group(kv.first, group))
out.push_back(kv.first);
}
std::sort(out.begin(), out.end(), [](StatMetricId a, StatMetricId b) {
return static_cast<int>(a) < static_cast<int>(b);
});
return out;
}
size_t stat_count_present_dynamic_group_metrics(
const std::vector<ExpandedStatPoint>& points,
StatDynamicMetricGroup group)
{
std::set<StatMetricId> ids;
for (const auto& p : points)
{
if (stat_is_dynamic_metric_group(p.metric_id, group))
ids.insert(p.metric_id);
}
return ids.size();
}
size_t stat_count_present_all_dynamic_metrics(const std::vector<ExpandedStatPoint>& points)
{
std::set<StatMetricId> ids;
for (const auto& p : points)
{
if (stat_is_dynamic_metric(p.metric_id))
ids.insert(p.metric_id);
}
return ids.size();
}
const std::vector<StatDynamicMetricGroup>& stat_dynamic_summary_groups()
{
static const std::vector<StatDynamicMetricGroup> groups = {
StatDynamicMetricGroup::VoltageHarmonic,
StatDynamicMetricGroup::LineVoltageHarmonic,
StatDynamicMetricGroup::CurrentHarmonic,
StatDynamicMetricGroup::VoltageHarmonicAngle,
StatDynamicMetricGroup::LineVoltageHarmonicAngle,
StatDynamicMetricGroup::CurrentHarmonicAngle,
StatDynamicMetricGroup::HarmonicActivePower,
StatDynamicMetricGroup::HarmonicReactivePower,
StatDynamicMetricGroup::HarmonicApparentPower,
StatDynamicMetricGroup::VoltageHarmonicRatio,
StatDynamicMetricGroup::LineVoltageHarmonicRatio,
StatDynamicMetricGroup::CurrentHarmonicRatio,
StatDynamicMetricGroup::VoltageInterharmonic,
StatDynamicMetricGroup::LineVoltageInterharmonic,
StatDynamicMetricGroup::CurrentInterharmonic
};
return groups;
}
void stat_print_dynamic_group_compact_summaries(
const std::map<StatMetricId, StatMetricSourceStats>& stats_by_metric)
{
for (auto group : stat_dynamic_summary_groups())
{
const std::vector<StatMetricId> present = stat_present_dynamic_group_metrics(stats_by_metric, group);
std::cout << " [DYNAMIC SPECTRUM SUMMARY] group=" << stat_dynamic_group_display_name(group)
<< ", present=" << present.size() << "/" << stat_dynamic_group_expected_count(group);
if (!present.empty())
{
const double first_order = stat_dynamic_metric_order_value(present.front());
const double last_order = stat_dynamic_metric_order_value(present.back());
std::cout << ", range=" << first_order << "-" << last_order;
}
std::cout << std::endl;
}
}
void stat_print_voltage_harmonic_compact_summary(
const std::map<StatMetricId, StatMetricSourceStats>& stats_by_metric)
{
bool present[3][51] = {};
for (const auto& kv : stats_by_metric)
{
if (!stat_is_voltage_harmonic_metric(kv.first))
continue;
const int phase = stat_voltage_harmonic_phase_index(kv.first);
const int order = stat_voltage_harmonic_order(kv.first);
if (phase >= 0 && phase < 3 && order >= 2 && order <= 50)
present[phase][order] = true;
}
size_t total_present = 0;
for (int phase = 0; phase < 3; ++phase)
{
for (int order = 2; order <= 50; ++order)
{
if (present[phase][order])
++total_present;
}
}
std::cout << " [VOLTAGE HARMONIC SUMMARY] present=" << total_present
<< "/147";
const char* phase_names[3] = { "A", "B", "C" };
for (int phase = 0; phase < 3; ++phase)
{
int first = -1;
int last = -1;
int count = 0;
for (int order = 2; order <= 50; ++order)
{
if (!present[phase][order])
continue;
if (first < 0)
first = order;
last = order;
++count;
}
std::cout << ", " << phase_names[phase] << "=";
if (count == 0)
std::cout << "missing";
else if (count == 49)
std::cout << "2-50";
else
std::cout << "count:" << count << " range:" << first << "-" << last;
}
std::cout << std::endl;
}
/// @brief 打印已展开统计样本点预览。
/// @details
/// 不再只打印前 12 个样本点，而是按“主要指标 × Min/Max/Avg/P95”打印每个流的首样本，
/// 这样后续新增指标时可以直接看出哪个 metric/kind 缺失或来自哪个通道。
/// @param parsed_file 当前已解析文件对象。
void dump_expanded_stat_preview(const ParsedPqdifFile& parsed_file)
{
const auto& points = parsed_file.expanded_stat_points;
if (!pqdif_is_trace_log_enabled())
{
std::cout << "========== EXPANDED STAT SUMMARY ==========" << std::endl;
std::cout << "connection_kind=" << stat_connection_kind_name(parsed_file.connection_kind)
<< ", selected_observation_index=" << parsed_file.selected_observation_index
<< ", selected_observation_name=" << parsed_file.selected_observation_name
<< ", selected_points=" << points.size()
<< ", present_metrics=" << stat_count_present_metrics(points)
<< ", present_dynamic_spectrum=" << stat_count_present_all_dynamic_metrics(points)
<< "/" << stat_all_dynamic_metric_order().size()
<< ", present_voltage_harmonics=" << stat_count_present_voltage_harmonic_metrics(points)
<< "/147"
<< std::endl;
std::cout << "===========================================" << std::endl;
return;
}
std::cout << "========== EXPANDED STAT PREVIEW ==========" << std::endl;
std::cout << "connection_kind=" << stat_connection_kind_name(parsed_file.connection_kind)
<< ", selected_observation_index=" << parsed_file.selected_observation_index
<< ", selected_observation_name=" << parsed_file.selected_observation_name
<< ", selected_points=" << points.size()
<< std::endl;
typedef std::pair<StatMetricId, StatValueKind> StreamKey;
std::map<StreamKey, const ExpandedStatPoint*> first_point_by_stream;
for (const auto& p : points)
{
StreamKey key(p.metric_id, p.stat_kind);
if (first_point_by_stream.find(key) == first_point_by_stream.end())
first_point_by_stream[key] = &p;
}
const StatValueKind kinds[4] = {
StatValueKind::Min,
StatValueKind::Max,
StatValueKind::Avg,
StatValueKind::P95
};
std::cout << " [PRIMARY METRIC STREAMS] metric_slots="
<< stat_primary_metric_print_order().size()
<< ", stream_slots=" << stat_primary_metric_print_order().size() * 4
<< std::endl;
for (const auto metric_id : stat_primary_metric_print_order())
{
for (int i = 0; i < 4; ++i)
{
const StatValueKind kind = kinds[i];
StreamKey key(metric_id, kind);
const auto it = first_point_by_stream.find(key);
std::cout << " [STREAM]"
<< " metric=" << stat_metric_name(metric_id)
<< ", kind=" << stat_value_kind_name(kind);
if (it == first_point_by_stream.end())
{
std::cout << ", status=MISSING" << std::endl;
continue;
}
const ExpandedStatPoint& p = *it->second;
std::cout
<< ", status=OK"
<< ", first_time=" << p.timestamp_text
<< ", first_value=" << p.value
<< ", obs=" << p.observation_index
<< ", ch=" << p.channel_instance_index
<< ", ch_def=" << p.channel_def_index
<< ", group=" << p.channel_group_id
<< ", ser=" << p.series_instance_index
<< ", ser_def=" << p.series_def_index
<< ", channel=" << p.channel_name
<< ", phase=" << pqdif_sem::FindPhaseName(p.phase_id)
<< ", measured=" << pqdif_sem::FindQuantityMeasuredName(p.quantity_measured_id)
<< ", unit=" << pqdif_sem::FindQuantityUnitsName(p.quantity_units_id)
<< (p.matched_by_name_fallback ? ", by_name=true" : "")
<< std::endl;
}
}
// 扩展指标只有命中时才打印，避免干扰当前 14 项核查。
for (const auto metric_id : stat_extra_metric_print_order())
{
bool has_any = false;
for (int i = 0; i < 4; ++i)
{
StreamKey key(metric_id, kinds[i]);
if (first_point_by_stream.find(key) != first_point_by_stream.end())
{
has_any = true;
break;
}
}
if (!has_any)
continue;
for (int i = 0; i < 4; ++i)
{
StreamKey key(metric_id, kinds[i]);
const auto it = first_point_by_stream.find(key);
std::cout << " [EXTRA STREAM]"
<< " metric=" << stat_metric_name(metric_id)
<< ", kind=" << stat_value_kind_name(kinds[i]);
if (it == first_point_by_stream.end())
{
std::cout << ", status=MISSING" << std::endl;
continue;
}
const ExpandedStatPoint& p = *it->second;
std::cout
<< ", status=OK"
<< ", first_time=" << p.timestamp_text
<< ", first_value=" << p.value
<< ", ch=" << p.channel_instance_index
<< ", channel=" << p.channel_name
<< std::endl;
}
}
std::cout << "===========================================" << std::endl;
}
/// @brief 打印时间聚合桶预览。
/// @details
/// 每个预览桶固定打印当前核查的主要指标，不再用 shown>=12 截断。
/// 若某项缺失，会显式打印 quality=MISSING。
/// @param parsed_file 当前已解析文件对象。
void dump_grouped_bucket_preview(const ParsedPqdifFile& parsed_file)
{
if (!pqdif_is_trace_log_enabled())
{
std::cout << "========== GROUPED STAT CORE SUMMARY ==========" << std::endl;
std::cout << "connection_kind=" << stat_connection_kind_name(parsed_file.connection_kind)
<< ", selected_observation_index=" << parsed_file.selected_observation_index
<< ", selected_observation_name=" << parsed_file.selected_observation_name
<< ", expanded_points=" << parsed_file.expanded_stat_points.size()
<< ", buckets=" << parsed_file.aggregated_stat_buckets.size()
<< ", core_metric_slots=" << stat_core_metric_print_order().size()
<< ", dynamic_spectrum_slots=" << stat_all_dynamic_metric_order().size()
<< std::endl;
std::map<StatMetricId, StatMetricSourceStats> stats_by_metric =
stat_collect_metric_stats(parsed_file.expanded_stat_points);
std::map<StatMetricId, StatMetricQualityInfo> quality_by_metric =
stat_analyze_metric_quality(parsed_file.expanded_stat_points);
stat_print_dynamic_group_compact_summaries(stats_by_metric);
const size_t bucket_limit = std::min<size_t>(parsed_file.aggregated_stat_buckets.size(), 3);
for (size_t i = 0; i < bucket_limit; ++i)
{
const auto& b = parsed_file.aggregated_stat_buckets[i];
std::cout << " [BUCKET " << i << "]"
<< " time=" << b.timestamp_text
<< ", metric_count_present=" << b.metrics.size()
<< std::endl;
for (const auto metric_id : stat_core_metric_print_order())
{
const auto it = b.metrics.find(metric_id);
stat_print_aggregated_metric_line(
metric_id,
it == b.metrics.end() ? nullptr : &it->second);
}
// 核心日志仅抽样打印 2/3/5 次谐波，避免每桶输出 147 行。
const int sample_orders[] = { 2, 3, 5 };
bool printed_header = false;
for (int phase = 0; phase < 3; ++phase)
{
for (int oi = 0; oi < 3; ++oi)
{
const StatMetricId hid = stat_voltage_harmonic_metric_id(phase, sample_orders[oi]);
const auto hit = b.metrics.find(hid);
if (hit == b.metrics.end())
continue;
if (!printed_header)
{
std::cout << " [VOLTAGE HARMONIC SAMPLE] orders=2/3/5" << std::endl;
printed_header = true;
}
stat_print_aggregated_metric_line(hid, &hit->second);
}
}
}
std::cout << "========== METRIC STATUS CORE SUMMARY ==========" << std::endl;
for (const auto metric_id : stat_core_metric_print_order())
{
const auto stats_it = stats_by_metric.find(metric_id);
const auto quality_it = quality_by_metric.find(metric_id);
std::cout << " [METRIC STATUS] metric=" << stat_metric_name(metric_id);
if (stats_it == stats_by_metric.end())
{
std::cout << ", quality=" << stat_metric_quality_name(StatMetricQuality::Missing)
<< ", points=0" << std::endl;
continue;
}
const StatMetricSourceStats& st = stats_it->second;
const StatMetricQuality quality =
quality_it == quality_by_metric.end() ? StatMetricQuality::Missing : quality_it->second.quality;
const std::string reason =
quality_it == quality_by_metric.end() ? std::string("missing") : quality_it->second.reason;
std::cout
<< ", quality=" << stat_metric_quality_name(quality)
<< ", reason=" << reason
<< ", points=" << st.point_count
<< ", source_obs=" << st.key.observation_index
<< ", source_ch=" << st.key.channel_instance_index
<< ", source_channel=" << st.channel_name
<< ", min=" << st.min_value
<< ", max=" << st.max_value
<< ", avg_abs=" << st.avg_abs_value()
<< std::endl;
}
for (auto group : stat_dynamic_summary_groups())
{
const std::vector<StatMetricId> present = stat_present_dynamic_group_metrics(stats_by_metric, group);
std::cout << " [DYNAMIC SPECTRUM STATUS] group=" << stat_dynamic_group_display_name(group)
<< ", present_metrics=" << present.size()
<< "/" << stat_dynamic_group_expected_count(group) << std::endl;
size_t sample_count = 0;
for (const auto metric_id : present)
{
if (sample_count >= 6)
break;
const auto stats_it = stats_by_metric.find(metric_id);
if (stats_it == stats_by_metric.end())
continue;
const StatMetricSourceStats& st = stats_it->second;
std::cout << " [DYNAMIC STATUS SAMPLE] metric=" << stat_metric_name(metric_id)
<< ", points=" << st.point_count
<< ", source_obs=" << st.key.observation_index
<< ", source_ch=" << st.key.channel_instance_index
<< ", order=" << stat_dynamic_metric_order_value(metric_id)
<< ", source_channel=" << st.channel_name
<< ", min=" << st.min_value
<< ", max=" << st.max_value
<< ", avg_abs=" << st.avg_abs_value()
<< std::endl;
++sample_count;
}
}
std::cout << "=================================================" << std::endl;
return;
}
std::cout << "========== GROUPED STAT BUCKET PREVIEW ==========" << std::endl;
std::cout << "connection_kind=" << stat_connection_kind_name(parsed_file.connection_kind)
<< ", selected_observation_index=" << parsed_file.selected_observation_index
<< ", selected_observation_name=" << parsed_file.selected_observation_name
<< ", expanded_points=" << parsed_file.expanded_stat_points.size()
<< ", buckets=" << parsed_file.aggregated_stat_buckets.size()
<< ", primary_metric_slots=" << stat_primary_metric_print_order().size()
<< std::endl;
const size_t bucket_limit = std::min<size_t>(parsed_file.aggregated_stat_buckets.size(), 3);
for (size_t i = 0; i < bucket_limit; ++i)
{
const auto& b = parsed_file.aggregated_stat_buckets[i];
std::cout << " [BUCKET " << i << "]"
<< " time=" << b.timestamp_text
<< ", metric_count_present=" << b.metrics.size()
<< std::endl;
for (const auto metric_id : stat_primary_metric_print_order())
{
const auto it = b.metrics.find(metric_id);
stat_print_aggregated_metric_line(
metric_id,
it == b.metrics.end() ? nullptr : &it->second);
}
for (const auto metric_id : stat_extra_metric_print_order())
{
const auto it = b.metrics.find(metric_id);
if (it != b.metrics.end())
stat_print_aggregated_metric_line(metric_id, &it->second);
}
}
std::cout << "========== METRIC STATUS SUMMARY ==========" << std::endl;
std::map<StatMetricId, StatMetricSourceStats> stats_by_metric =
stat_collect_metric_stats(parsed_file.expanded_stat_points);
std::map<StatMetricId, StatMetricQualityInfo> quality_by_metric =
stat_analyze_metric_quality(parsed_file.expanded_stat_points);
for (const auto metric_id : stat_primary_metric_print_order())
{
const auto stats_it = stats_by_metric.find(metric_id);
const auto quality_it = quality_by_metric.find(metric_id);
std::cout << " [METRIC STATUS] metric=" << stat_metric_name(metric_id);
if (stats_it == stats_by_metric.end())
{
std::cout << ", quality=" << stat_metric_quality_name(StatMetricQuality::Missing)
<< ", points=0" << std::endl;
continue;
}
const StatMetricSourceStats& s = stats_it->second;
const StatMetricQuality quality =
quality_it == quality_by_metric.end() ? StatMetricQuality::Missing : quality_it->second.quality;
const std::string reason =
quality_it == quality_by_metric.end() ? std::string("missing") : quality_it->second.reason;
std::cout
<< ", quality=" << stat_metric_quality_name(quality)
<< ", reason=" << reason
<< ", points=" << s.point_count
<< ", source_ch=" << s.key.channel_instance_index
<< ", source_channel=" << s.channel_name
<< ", min=" << s.min_value
<< ", max=" << s.max_value
<< ", avg_abs=" << s.avg_abs_value()
<< std::endl;
}
std::cout << "=================================================" << std::endl;
}
bool parse_container_record(CPQDIF& file_convert,
CPQDIF_R_General* record,
long record_index,
PqdifContainerRecord& out)
{
if (record == nullptr)
return false;
out.header = build_record_header_info(record, record_index);
CPQDIF_E_Collection* main = record->GetMainCollection();
if (main == nullptr)
return true;
out.version_info = read_vector_uint_values(main, tagVersionInfo);
read_string_tag(main, tagFileName, out.file_name);
read_timestamp_tag(main, tagCreation, file_convert, out.creation_time);
read_timestamp_tag(main, tagLastSaved, file_convert, out.last_saved_time);
read_uint_tag(main, tagTimesSaved, out.times_saved);
read_string_tag(main, tagLanguage, out.language);
read_string_tag(main, tagTitle, out.title);
read_string_tag(main, tagSubject, out.subject);
read_string_tag(main, tagAuthor, out.author);
read_string_tag(main, tagKeywords, out.keywords);
read_string_tag(main, tagComments, out.comments);
read_string_tag(main, tagLastSavedBy, out.last_saved_by);
read_string_tag(main, tagApplication, out.application);
read_guid_tag(main, tagCompressionStyleID, out.compression_style_id);
read_uint_tag(main, tagCompressionAlgorithmID, out.compression_algorithm_id);
read_uint_tag(main, tagCompressionChecksum, out.compression_checksum);
read_string_tag(main, tagOwner, out.owner);
read_string_tag(main, tagCopyright, out.copyright);
read_string_tag(main, tagTrademarks, out.trademarks);
read_string_tag(main, tagNotes, out.notes);
read_string_tag(main, tagAddress1, out.address1);
read_string_tag(main, tagAddress2, out.address2);
read_string_tag(main, tagCity, out.city);
read_string_tag(main, tagState, out.state);
read_string_tag(main, tagPostalCode, out.postal_code);
read_string_tag(main, tagCountry, out.country);
read_string_tag(main, tagPhoneVoice, out.phone_voice);
read_string_tag(main, tagPhoneFAX, out.phone_fax);
read_string_tag(main, tagEMail, out.email);
const std::set<std::string> known = {
"tagVersionInfo", "tagFileName", "tagCreation", "tagLastSaved", "tagTimesSaved",
"tagLanguage", "tagTitle", "tagSubject", "tagAuthor", "tagKeywords", "tagComments",
"tagLastSavedBy", "tagApplication", "tagCompressionStyleID", "tagCompressionAlgorithmID",
"tagCompressionChecksum", "tagOwner", "tagCopyright", "tagTrademarks", "tagNotes",
"tagAddress1", "tagAddress2", "tagCity", "tagState", "tagPostalCode", "tagCountry",
"tagPhoneVoice", "tagPhoneFAX", "tagEMail"
};
collect_extra_tags(main, known, file_convert, out.extra_tags);
return true;
}
bool parse_data_source_record(CPQDIF& file_convert,
CPQDIF_R_DataSource* record,
long record_index,
int data_source_index,
PqdifDataSourceRecord& out)
{
if (record == nullptr)
return false;
out.header = build_record_header_info(record, record_index);
out.data_source_index = data_source_index;
out.record_index = record_index;
GUID ds_type{};
GUID vendor{};
GUID equip{};
std::string serial;
std::string version;
std::string name;
std::string owner;
std::string location;
std::string time_zone;
if (record->GetInfo(ds_type, vendor, equip, serial, version, name, owner, location, time_zone))
{
out.data_source_type_id = make_guid_value(ds_type);
out.vendor_id = make_guid_value(vendor);
out.equipment_id = make_guid_value(equip);
out.serial_number = serial;
out.version = version;
out.name = name;
out.owner = owner;
out.location = location;
out.time_zone = time_zone;
}
CPQDIF_E_Collection* main = record->GetMainCollection();
if (main != nullptr)
{
read_string_tag(main, tagCustomSourceInfo, out.custom_source_info);
read_guid_tag(main, tagInstrumentTypeID, out.instrument_type_id);
read_string_tag(main, tagInstrumentModelName, out.instrument_model_name);
read_string_tag(main, tagInstrumentModelNumber, out.instrument_model_number);
read_string_tag(main, tagSerialNumberDS, out.serial_number);
read_string_tag(main, tagVersionDS, out.version);
read_string_tag(main, tagNameDS, out.name);
read_string_tag(main, tagOwnerDS, out.owner);
read_string_tag(main, tagLocationDS, out.location);
read_string_tag(main, tagTimeZoneDS, out.time_zone);
read_string_tag(main, tagCoordinatesDS, out.coordinates);
const std::set<std::string> known = {
"tagDataSourceTypeID", "tagVendorID", "tagEquipmentID", "tagCustomSourceInfo",
"tagInstrumentTypeID", "tagInstrumentModelName", "tagInstrumentModelNumber",
"tagSerialNumberDS", "tagVersionDS", "tagNameDS", "tagOwnerDS", "tagLocationDS",
"tagTimeZoneDS", "tagCoordinatesDS", "tagChannelDefns"
};
collect_extra_tags(main, known, file_convert, out.extra_tags);
}
const long channel_count = record->GetCountChannelDefns();
out.channel_definitions.reserve(static_cast<size_t>(std::max<long>(channel_count, 0)));
for (long i = 0; i < channel_count; ++i)
{
PqdifChannelDefinition channel_def;
channel_def.channel_def_index = static_cast<int>(i);
std::string channel_name;
UINT4 phase_id = 0;
GUID quantity_type{};
UINT4 quantity_measured = 0;
if (record->GetChannelDefnInfo(i, channel_name, phase_id, quantity_type, quantity_measured))
{
channel_def.channel_name = channel_name;
channel_def.phase_id = phase_id;
channel_def.quantity_type_id = make_guid_value(quantity_type);
channel_def.quantity_measured_id = quantity_measured;
}
long primary_series = -1;
if (record->GetChannelPrimarySeries(i, primary_series))
channel_def.primary_series_index = static_cast<int>(primary_series);
CPQDIF_E_Collection* channel_coll = record->GetOneChannelDefn(i);
if (channel_coll != nullptr)
{
read_string_tag(channel_coll, tagOtherChannelIdentifier, channel_def.other_channel_identifier);
read_string_tag(channel_coll, tagGroupName, channel_def.group_name);
read_uint_tag(channel_coll, tagPhysicalChannel, channel_def.physical_channel);
read_string_tag(channel_coll, tagQuantityName, channel_def.quantity_name);
const std::set<std::string> known_channel = {
"tagChannelName", "tagPhaseID", "tagOtherChannelIdentifier", "tagGroupName",
"tagQuantityTypeID", "tagQuantityMeasuredID", "tagPhysicalChannel",
"tagQuantityName", "tagPrimarySeriesIdx", "tagSeriesDefns"
};
collect_extra_tags(channel_coll, known_channel, file_convert, channel_def.extra_tags);
}
const long series_count = record->GetCountSeriesDefns(static_cast<int>(i));
channel_def.series_definitions.reserve(static_cast<size_t>(std::max<long>(series_count, 0)));
for (long j = 0; j < series_count; ++j)
{
PqdifSeriesDefinition series_def;
series_def.series_def_index = static_cast<int>(j);
UINT4 quantity_units = 0;
GUID value_type{};
GUID quantity_characteristic{};
UINT4 storage_method = 0;
if (record->GetSeriesDefnInfo(i, j, quantity_units, value_type, quantity_characteristic, storage_method))
{
series_def.quantity_units_id = quantity_units;
series_def.value_type_id = make_guid_value(value_type);
series_def.quantity_characteristic_id = make_guid_value(quantity_characteristic);
series_def.storage_method_id = storage_method;
}
UINT4 precision = 0;
double resolution = 0.0;
if (record->GetSeriesDefnPrecisionAndResolution(i, j, precision, resolution))
{
series_def.significant_digits_id = precision;
series_def.quantity_resolution = resolution;
}
double nominal = 0.0;
if (record->GetSeriesDefnNominal(i, j, nominal))
series_def.nominal_quantity = nominal;
CPQDIF_E_Collection* series_coll = record->GetOneSeriesDefn(i, j);
if (series_coll != nullptr)
{
read_string_tag(series_coll, tagValueTypeName, series_def.value_type_name);
read_uint_tag(series_coll, tagHintGreekPrefixID, series_def.hint_greek_prefix_id);
read_uint_tag(series_coll, tagHintPreferredUnitsID, series_def.hint_preferred_units_id);
read_uint_tag(series_coll, tagHintDefaultDisplayID, series_def.hint_default_display_id);
read_double_tag(series_coll, tagProbInterval, series_def.prob_interval);
read_double_tag(series_coll, tagProbPercentile, series_def.prob_percentile);
read_double_tag(series_coll, tagSeriesNominalQuantity, series_def.nominal_quantity);
read_timestamp_tag(series_coll, tagEffective, file_convert, series_def.effective_time);
const std::set<std::string> known_series = {
"tagValueTypeID", "tagQuantityUnitsID", "tagQuantityCharacteristicID",
"tagQuantitySignificantDigitsID", "tagQuantityResolutionID", "tagStorageMethodID",
"tagValueTypeName", "tagHintGreekPrefixID", "tagHintPreferredUnitsID",
"tagHintDefaultDisplayID", "tagProbInterval", "tagProbPercentile",
"tagSeriesNominalQuantity", "tagEffective"
};
collect_extra_tags(series_coll, known_series, file_convert, series_def.extra_tags);
}
channel_def.series_definitions.push_back(std::move(series_def));
}
out.channel_definitions.push_back(std::move(channel_def));
}
return true;
}
bool parse_monitor_settings_record(CPQDIF& file_convert,
CPQDIF_R_Settings* record,
long record_index,
int settings_index,
PqdifMonitorSettingsRecord& out)
{
if (record == nullptr)
return false;
out.header = build_record_header_info(record, record_index);
out.settings_index = settings_index;
out.record_index = record_index;
TIMESTAMPPQDIF time_effective{};
TIMESTAMPPQDIF time_installed{};
TIMESTAMPPQDIF time_removed{};
bool use_cal = false;
bool use_trans = false;
if (record->GetInfo(time_effective, time_installed, time_removed, use_cal, use_trans))
{
out.effective_time = make_timestamp_value(file_convert, time_effective);
out.time_installed = make_timestamp_value(file_convert, time_installed);
out.time_removed = make_timestamp_value(file_convert, time_removed);
out.use_calibration = use_cal;
out.use_transducer = use_trans;
}
UINT4 connection_type = 0;
if (record->GetConnectionInfo(connection_type))
out.physical_connection = connection_type;
REAL8 nominal_frequency = 0.0;
if (record->GetNominalFrequency(nominal_frequency))
out.nominal_frequency = nominal_frequency;
CPQDIF_E_Collection* main = record->GetMainCollection();
if (main != nullptr)
{
read_double_tag(main, tagNominalVoltage, out.nominal_voltage);
read_bool_tag(main, tagIsPCC, out.is_pcc);
const std::set<std::string> known = {
"tagEffective", "tagTimeInstalled", "tagTimeRemoved", "tagUseCalibration",
"tagUseTransducer", "tagNominalFrequency", "tagSettingPhysicalConnection",
"tagNominalVoltage", "tagIsPCC", "tagChannelSettings"
};
collect_extra_tags(main, known, file_convert, out.extra_tags);
}
const long channel_count = record->GetCountChannels();
out.channel_settings.reserve(static_cast<size_t>(std::max<long>(channel_count, 0)));
for (long i = 0; i < channel_count; ++i)
{
PqdifChannelSetting channel_setting;
channel_setting.channel_setting_index = static_cast<int>(i);
UINT4 channel_def_index = 0;
if (record->GetChannelInfo(i, channel_def_index))
channel_setting.channel_def_index = static_cast<int>(channel_def_index);
CPQDIF_E_Collection* channel_coll = record->GetOneChannelSetting(i);
if (channel_coll != nullptr)
{
read_uint_tag(channel_coll, tagTriggerTypeID, channel_setting.trigger_type_id);
read_double_tag(channel_coll, tagFullScale, channel_setting.full_scale);
read_double_tag(channel_coll, tagNoiseFloor, channel_setting.noise_floor);
read_uint_tag(channel_coll, tagXDTransformerTypeID, channel_setting.xd_transformer_type_id);
read_double_tag(channel_coll, tagXDSystemSideRatio, channel_setting.xd_system_side_ratio);
read_double_tag(channel_coll, tagXDMonitorSideRatio, channel_setting.xd_monitor_side_ratio);
read_double_tag(channel_coll, tagCalTimeSkew, channel_setting.cal_time_skew);
read_double_tag(channel_coll, tagCalOffset, channel_setting.cal_offset);
read_double_tag(channel_coll, tagCalRatio, channel_setting.cal_ratio);
read_bool_tag(channel_coll, tagCalMustUseARCal, channel_setting.cal_must_use_arcal);
read_double_tag(channel_coll, tagTriggerHighHigh, channel_setting.trigger_high_high);
read_double_tag(channel_coll, tagTriggerHigh, channel_setting.trigger_high);
read_double_tag(channel_coll, tagTriggerLow, channel_setting.trigger_low);
read_double_tag(channel_coll, tagTriggerLowLow, channel_setting.trigger_low_low);
read_double_tag(channel_coll, tagTriggerDeadBand, channel_setting.trigger_deadband);
read_double_tag(channel_coll, tagTriggerRate, channel_setting.trigger_rate);
CPQDIF_Element* trigger_shape = channel_coll->GetElement(tagTriggerShapeParam, ID_ELEMENT_TYPE_VECTOR);
if (trigger_shape != nullptr)
channel_setting.trigger_shape_param = extract_vector_values(static_cast<CPQDIF_E_Vector*>(trigger_shape), file_convert);
CPQDIF_Element* xd_response = channel_coll->GetElement(tagXDFrequencyResponse, ID_ELEMENT_TYPE_VECTOR);
if (xd_response != nullptr)
channel_setting.xd_frequency_response = extract_vector_values(static_cast<CPQDIF_E_Vector*>(xd_response), file_convert);
CPQDIF_Element* cal_applied = channel_coll->GetElement(tagCalApplied, ID_ELEMENT_TYPE_VECTOR);
if (cal_applied != nullptr)
channel_setting.cal_applied = extract_vector_values(static_cast<CPQDIF_E_Vector*>(cal_applied), file_convert);
CPQDIF_Element* cal_recorded = channel_coll->GetElement(tagCalRecorded, ID_ELEMENT_TYPE_VECTOR);
if (cal_recorded != nullptr)
channel_setting.cal_recorded = extract_vector_values(static_cast<CPQDIF_E_Vector*>(cal_recorded), file_convert);
const std::set<std::string> known_channel = {
"tagChannelDefnIdx", "tagTriggerTypeID", "tagFullScale", "tagNoiseFloor",
"tagTriggerShapeParam", "tagXDTransformerTypeID", "tagXDSystemSideRatio",
"tagXDMonitorSideRatio", "tagXDFrequencyResponse", "tagCalTimeSkew",
"tagCalOffset", "tagCalRatio", "tagCalMustUseARCal", "tagCalApplied",
"tagCalRecorded", "tagTriggerHighHigh", "tagTriggerHigh", "tagTriggerLow",
"tagTriggerLowLow", "tagTriggerDeadBand", "tagTriggerRate"
};
collect_extra_tags(channel_coll, known_channel, file_convert, channel_setting.extra_tags);
}
out.channel_settings.push_back(std::move(channel_setting));
}
return true;
}
bool parse_observation_record(CPQDIF& file_convert,
CPQDIF_R_Observation* record,
long record_index,
int observation_index,
int related_data_source_index,
long related_data_source_record_index,
int related_settings_index,
long related_settings_record_index,
PqdifObservationRecord& out)
{
if (record == nullptr)
return false;
out.header = build_record_header_info(record, record_index);
out.observation_index = observation_index;
out.record_index = record_index;
out.related_data_source_index = related_data_source_index;
out.related_data_source_record_index = related_data_source_record_index;
out.related_settings_index = related_settings_index;
out.related_settings_record_index = related_settings_record_index;
TIMESTAMPPQDIF time_start{};
TIMESTAMPPQDIF time_create{};
std::string observation_name;
if (record->GetInfo(time_start, time_create, observation_name))
{
out.observation_name = observation_name;
out.time_start = make_timestamp_value(file_convert, time_start);
out.time_create = make_timestamp_value(file_convert, time_create);
}
UINT4 trigger_method = 0;
CPQDIF_E_Vector* trigger_channels = nullptr;
TIMESTAMPPQDIF time_triggered{};
if (record->GetTriggerInfo(trigger_method, &trigger_channels, time_triggered))
{
out.trigger_method_id = trigger_method;
out.time_triggered = make_timestamp_value(file_convert, time_triggered);
if (trigger_channels != nullptr)
{
PqdifValueArray trigger_indexes = extract_vector_values(trigger_channels, file_convert);
for (size_t i = 0; i < trigger_indexes.int_values.size(); ++i)
out.channel_trigger_indexes.push_back(static_cast<int>(trigger_indexes.int_values[i]));
for (size_t i = 0; i < trigger_indexes.uint_values.size(); ++i)
out.channel_trigger_indexes.push_back(static_cast<int>(trigger_indexes.uint_values[i]));
}
}
CPQDIF_E_Collection* main = record->GetMainCollection();
if (main != nullptr)
{
read_uint_tag(main, tagObservationSerial, out.observation_serial);
read_uint_tag(main, tagObservationAggregationSerial, out.observation_aggregation_serial);
read_guid_tag(main, tagDisturbanceCategoryID, out.disturbance_category_id);
const std::set<std::string> known = {
"tagObservationName", "tagTimeCreate", "tagTimeStart", "tagTriggerMethodID",
"tagTimeTriggered", "tagChannelTriggerIdx", "tagObservationSerial",
"tagObservationAggregationSerial", "tagDisturbanceCategoryID", "tagChannelInstances"
};
collect_extra_tags(main, known, file_convert, out.extra_tags);
}
const long channel_count = record->GetCountChannels();
out.channel_instances.reserve(static_cast<size_t>(std::max<long>(channel_count, 0)));
for (long i = 0; i < channel_count; ++i)
{
PqdifChannelInstance channel_instance;
channel_instance.channel_instance_index = static_cast<int>(i);
long channel_def_index = -1;
if (record->GetChannelDefnIdx(i, channel_def_index))
channel_instance.channel_def_index = static_cast<int>(channel_def_index);
std::string channel_name;
UINT4 phase_id = 0;
GUID quantity_type{};
UINT4 quantity_measured = 0;
if (record->GetChannelInfo(i, channel_name, phase_id, quantity_type, quantity_measured))
{
channel_instance.channel_name = channel_name;
channel_instance.phase_id = phase_id;
channel_instance.quantity_type_id = make_guid_value(quantity_type);
channel_instance.quantity_measured_id = quantity_measured;
}
long primary_series = -1;
if (record->GetChannelPrimarySeries(i, primary_series))
channel_instance.primary_series_index = static_cast<int>(primary_series);
CPQDIF_E_Collection* channel_coll = record->GetOneChannel(i);
if (channel_coll != nullptr)
{
read_double_tag(channel_coll, tagCharactDuration, channel_instance.charact_duration);
read_double_tag(channel_coll, tagCharactMagnitude, channel_instance.charact_magnitude);
read_double_tag(channel_coll, tagCharactFrequency, channel_instance.charact_frequency);
read_double_tag(channel_coll, tagChannelFrequency, channel_instance.channel_frequency);
read_int_tag(channel_coll, tagChannelGroupID, channel_instance.channel_group_id);
const std::set<std::string> known_channel = {
"tagChannelDefnIdx", "tagCharactDuration", "tagCharactMagnitude",
"tagCharactFrequency", "tagChannelFrequency", "tagChannelGroupID",
"tagSeriesInstances"
};
collect_extra_tags(channel_coll, known_channel, file_convert, channel_instance.extra_tags);
}
const long series_count = record->GetCountSeries(static_cast<int>(i));
channel_instance.series_instances.reserve(static_cast<size_t>(std::max<long>(series_count, 0)));
for (long j = 0; j < series_count; ++j)
{
PqdifSeriesInstance series_instance;
series_instance.series_instance_index = static_cast<int>(j);
series_instance.series_def_index = static_cast<int>(j);
UINT4 quantity_units = 0;
GUID quantity_characteristic{};
GUID value_type{};
if (record->GetSeriesInfo(i, j, quantity_units, quantity_characteristic, value_type))
{
series_instance.quantity_units_id = quantity_units;
series_instance.quantity_characteristic_id = make_guid_value(quantity_characteristic);
series_instance.value_type_id = make_guid_value(value_type);
}
long base_type = -1;
if (record->GetSeriesBaseType(i, j, base_type))
series_instance.series_base_type = base_type;
record->GetSeriesBaseQuantity(i, j, series_instance.series_base_quantity);
record->GetSeriesScale(i, j, series_instance.scale, series_instance.offset);
record->GetSeriesDefnNominal(i, j, series_instance.nominal_quantity);
UINT4 precision = 0;
double resolution = 0.0;
if (record->GetSeriesDefnPrecisionAndResolution(i, j, precision, resolution))
{
series_instance.significant_digits_id = precision;
series_instance.quantity_resolution = resolution;
}
CPQDIF_E_Collection* series_coll = record->GetOneSeries(i, j);
if (series_coll != nullptr)
{
read_int_tag(series_coll, tagSeriesShareChannelIdx, series_instance.share_channel_index);
read_int_tag(series_coll, tagSeriesShareSeriesIdx, series_instance.share_series_index);
const std::set<std::string> known_series = {
"tagSeriesBaseQuantity", "tagSeriesScale", "tagSeriesOffset",
"tagSeriesShareChannelIdx", "tagSeriesShareSeriesIdx", "tagSeriesValues"
};
collect_extra_tags(series_coll, known_series, file_convert, series_instance.extra_tags);
}
CPQDIF_E_Vector* series_values = record->GetSeriesValueVector(i, j);
if (series_values != nullptr)
series_instance.values = extract_vector_values(series_values, file_convert);
channel_instance.series_instances.push_back(std::move(series_instance));
}
out.channel_instances.push_back(std::move(channel_instance));
}
return true;
}
bool parse_pqdif_file_full(const std::string& file_path, PqdifLogicalFile& out_file, std::string& err)
{
out_file = PqdifLogicalFile{};
CPQDIF file_convert;
file_convert.put_FlatFileName(file_path);
std::string basic_err;
if (!dump_file_basic_info(file_path, basic_err))
{
err = "precheck failed: " + basic_err;
return false;
}
if (!file_convert.Read())
{
err = "CPQDIF::Read() failed";
return false;
}
const int record_count = static_cast<int>(file_convert.RecordGetCount());
int current_data_source_index = -1;
long current_data_source_record_index = -1;
int current_settings_index = -1;
long current_settings_record_index = -1;
for (int i_record = 0; i_record < record_count; ++i_record)
{
GUID record_guid{};
std::string record_name;
if (!file_convert.RecordGetInfo(i_record, &record_guid, record_name))
continue;
long raw_record_handle = 0;
if (file_convert.RecordRequestRecord(i_record, &raw_record_handle))
{
CPQDIFRecord* raw_record = reinterpret_cast<CPQDIFRecord*>(raw_record_handle);
out_file.record_headers.push_back(build_record_header_info(raw_record, i_record));
}
if (PQDIF_IsEqualGUID(record_guid, tagContainer))
{
CPQDIF_R_General* record = reinterpret_cast<CPQDIF_R_General*>(raw_record_handle);
PqdifContainerRecord container;
if (parse_container_record(file_convert, record, i_record, container))
out_file.containers.push_back(std::move(container));
continue;
}
if (PQDIF_IsEqualGUID(record_guid, tagRecDataSource))
{
CPQDIF_R_DataSource* record = reinterpret_cast<CPQDIF_R_DataSource*>(raw_record_handle);
PqdifDataSourceRecord data_source;
const int data_source_index = static_cast<int>(out_file.data_sources.size());
if (parse_data_source_record(file_convert, record, i_record, data_source_index, data_source))
{
out_file.data_sources.push_back(std::move(data_source));
current_data_source_index = data_source_index;
current_data_source_record_index = i_record;
current_settings_index = -1;
current_settings_record_index = -1;
}
continue;
}
if (PQDIF_IsEqualGUID(record_guid, tagRecMonitorSettings))
{
CPQDIF_R_Settings* record = reinterpret_cast<CPQDIF_R_Settings*>(raw_record_handle);
PqdifMonitorSettingsRecord settings;
const int settings_index = static_cast<int>(out_file.monitor_settings.size());
if (parse_monitor_settings_record(file_convert, record, i_record, settings_index, settings))
{
out_file.monitor_settings.push_back(std::move(settings));
current_settings_index = settings_index;
current_settings_record_index = i_record;
}
continue;
}
if (PQDIF_IsEqualGUID(record_guid, tagRecObservation))
{
long observation_handle = 0;
if (!file_convert.RecordRequestObservation(i_record, &observation_handle))
continue;
CPQDIF_R_Observation* observation = reinterpret_cast<CPQDIF_R_Observation*>(observation_handle);
PqdifObservationRecord record;
const int observation_index = static_cast<int>(out_file.observations.size());
parse_observation_record(
file_convert,
observation,
i_record,
observation_index,
current_data_source_index,
current_data_source_record_index,
current_settings_index,
current_settings_record_index,
record);
out_file.observations.push_back(std::move(record));
file_convert.RecordReleaseObservation(observation_handle);
}
}
file_convert.Close();
return true;
}
constexpr float kPqdifBase64MissingFloat = 3.14159f;
int stat_value_kind_code_for_base64(StatValueKind kind)
{
switch (kind)
{
case StatValueKind::Max: return 1;
case StatValueKind::Min: return 2;
case StatValueKind::Avg: return 3;
case StatValueKind::P95: return 4;
default: return 0;
}
}
std::string pqdif_base64_encode_bytes(const unsigned char* bytes_to_encode, size_t in_len)
{
static const char base64_chars[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
std::string ret;
ret.reserve(((in_len + 2) / 3) * 4);
int i = 0;
unsigned char char_array_3[3] = { 0, 0, 0 };
unsigned char char_array_4[4] = { 0, 0, 0, 0 };
while (in_len--)
{
char_array_3[i++] = *(bytes_to_encode++);
if (i == 3)
{
char_array_4[0] = static_cast<unsigned char>((char_array_3[0] & 0xfc) >> 2);
char_array_4[1] = static_cast<unsigned char>(((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4));
char_array_4[2] = static_cast<unsigned char>(((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6));
char_array_4[3] = static_cast<unsigned char>(char_array_3[2] & 0x3f);
for (i = 0; i < 4; ++i)
ret += base64_chars[char_array_4[i]];
i = 0;
}
}
if (i != 0)
{
int j = 0;
for (j = i; j < 3; ++j)
char_array_3[j] = '\0';
char_array_4[0] = static_cast<unsigned char>((char_array_3[0] & 0xfc) >> 2);
char_array_4[1] = static_cast<unsigned char>(((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4));
char_array_4[2] = static_cast<unsigned char>(((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6));
char_array_4[3] = static_cast<unsigned char>(char_array_3[2] & 0x3f);
for (j = 0; j < i + 1; ++j)
ret += base64_chars[char_array_4[j]];
while (i++ < 3)
ret += '=';
}
return ret;
}
std::string pqdif_base64_encode_float_vector(const std::vector<float>& values)
{
if (values.empty())
return std::string();
const unsigned char* byte_data = reinterpret_cast<const unsigned char*>(values.data());
const size_t byte_size = values.size() * sizeof(float);
return pqdif_base64_encode_bytes(byte_data, byte_size);
}
size_t pqdif_stat_base64_count_records_in_batch(const PqdifStatBase64FileBatch& batch)
{
size_t n = 0;
for (const auto& tp : batch.time_points)
n += tp.records.size();
return n;
}
// 统计任意 Base64 文件级批次队列内部包含的子记录总数。
// 对象用途：既可以统计“生成队列”，也可以统计“待后续处理队列”。
// 调用约定：调用方必须已经持有对应队列的互斥锁。
size_t pqdif_stat_base64_count_records_in_queue_unlocked(const std::deque<PqdifStatBase64FileBatch>& queue)
{
size_t n = 0;
for (const auto& batch : queue)
n += pqdif_stat_base64_count_records_in_batch(batch);
return n;
}
// 统计“生成队列”内部的子记录总数。
// 对象用途：保留旧函数名，供已有 GetPqdifStatBase64RecordCountInQueue() 复用。
// 调用约定：调用方必须已经持有 g_pqdif_stat_base64_mutex。
size_t pqdif_stat_base64_count_records_in_queue_unlocked()
{
return pqdif_stat_base64_count_records_in_queue_unlocked(g_pqdif_stat_base64_queue);
}
void pqdif_dump_stat_base64_file_batch_full(const PqdifStatBase64FileBatch& batch)
{
std::cout << "========== PQDIF BASE64 SAVED OBJECT FULL DUMP ==========" << std::endl;
std::cout << "[FILE BATCH] file=" << batch.pqdif_file_path
<< ", source_file=" << batch.source_file
<< ", mac=" << batch.mac
<< ", parsed_at=" << batch.parsed_at_text
<< ", connection_kind=" << stat_connection_kind_name(batch.connection_kind)
<< ", time_point_count=" << batch.time_point_count
<< ", total_record_count=" << batch.total_record_count
<< ", total_float_count=" << batch.total_float_count
<< ", total_placeholder_count=" << batch.total_placeholder_count
<< ", total_base64_chars=" << batch.total_base64_chars
<< std::endl;
for (size_t i = 0; i < batch.time_points.size(); ++i)
{
const PqdifStatBase64TimePointPacket& tp = batch.time_points[i];
std::cout << " [TIME POINT " << i << "] time=" << tp.timestamp_text
<< ", timestamp=" << static_cast<long long>(tp.timestamp)
<< ", record_count=" << tp.record_count
<< ", total_float_count=" << tp.total_float_count
<< ", total_placeholder_count=" << tp.total_placeholder_count
<< ", total_base64_chars=" << tp.total_base64_chars
<< std::endl;
for (size_t j = 0; j < tp.records.size(); ++j)
{
const PqdifStatBase64Record& rec = tp.records[j];
std::cout << " [BASE64 SUB RECORD " << j << "] file=" << rec.pqdif_file_path
<< ", time=" << rec.timestamp_text
<< ", timestamp=" << static_cast<long long>(rec.timestamp)
<< ", kind=" << rec.value_kind_name
<< ", kind_code=" << rec.value_kind_code
<< ", connection_kind=" << stat_connection_kind_name(rec.connection_kind)
<< ", float_count=" << rec.float_count
<< ", placeholder_count=" << rec.placeholder_count
<< ", base64_len=" << rec.base64_payload.size()
<< std::endl;
std::cout << " base64_payload=" << rec.base64_payload << std::endl;
}
}
std::cout << "==========================================================" << std::endl;
}
bool push_pqdif_stat_base64_file_batch(PqdifStatBase64FileBatch&& batch)
{
// 对象用途：把“一个 PQDIF 文件解析完成后的 Base64 文件级批次”放入生成队列。
// 这里不直接做入库/上传，避免解析线程被后续业务阻塞。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
if (g_pqdif_stat_base64_queue.size() >= kPqdifStatBase64QueueLimit)
{
std::cout << "[PQDIF BASE64] file-batch queue full, drop oldest file batch: file="
<< g_pqdif_stat_base64_queue.front().pqdif_file_path
<< ", time_points=" << g_pqdif_stat_base64_queue.front().time_point_count
<< ", records=" << g_pqdif_stat_base64_queue.front().total_record_count
<< std::endl;
g_pqdif_stat_base64_queue.pop_front();
}
g_pqdif_stat_base64_queue.emplace_back(std::move(batch));
return true;
}
bool pqdif_move_one_generated_base64_batch_to_ready_queue()
{
// 对象用途：RunPqdifScanLoop() 每轮循环末尾调用。
// 从“生成队列”取出最多一个 PQDIF 文件级批次，移动到“待后续处理队列”。
// 注意：这里只做快速移动和核心摘要打印，不在锁内执行耗时业务逻辑。
PqdifStatBase64FileBatch batch;
{
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
if (g_pqdif_stat_base64_queue.empty())
return false;
batch = std::move(g_pqdif_stat_base64_queue.front());
g_pqdif_stat_base64_queue.pop_front();
}
const std::string moved_file = batch.pqdif_file_path;
const size_t moved_time_points = batch.time_point_count;
const size_t moved_records = batch.total_record_count;
const size_t moved_float_count = batch.total_float_count;
const size_t moved_placeholder_count = batch.total_placeholder_count;
{
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_ready_mutex);
if (g_pqdif_stat_base64_ready_queue.size() >= kPqdifStatBase64QueueLimit)
{
std::cout << "[PQDIF BASE64 READY] ready queue full, drop oldest file batch: file="
<< g_pqdif_stat_base64_ready_queue.front().pqdif_file_path
<< ", time_points=" << g_pqdif_stat_base64_ready_queue.front().time_point_count
<< ", records=" << g_pqdif_stat_base64_ready_queue.front().total_record_count
<< std::endl;
g_pqdif_stat_base64_ready_queue.pop_front();
}
g_pqdif_stat_base64_ready_queue.emplace_back(std::move(batch));
}
std::cout << "[PQDIF BASE64 READY] moved one file batch for next step"
<< ", file=" << moved_file
<< ", time_points=" << moved_time_points
<< ", records=" << moved_records
<< ", float_count=" << moved_float_count
<< ", placeholders=" << moved_placeholder_count
<< std::endl;
return true;
}
std::string pqdif_absolute_path_text(const std::string& path)
{
try
{
return fs::absolute(fs::path(path)).string();
}
catch (...)
{
return path;
}
}
bool bucket_has_metric_value_for_kind(const AggregatedStatValues& values, StatValueKind kind, float& out)
{
switch (kind)
{
case StatValueKind::Min:
if (!values.has_min) return false;
out = static_cast<float>(values.min_value);
return true;
case StatValueKind::Max:
if (!values.has_max) return false;
out = static_cast<float>(values.max_value);
return true;
case StatValueKind::Avg:
if (!values.has_avg) return false;
out = static_cast<float>(values.avg_value);
return true;
case StatValueKind::P95:
if (!values.has_p95) return false;
out = static_cast<float>(values.p95_value);
return true;
default:
return false;
}
}
struct PqdifBase64BuildContext
{
PqdifBase64BuildContext(
const ParsedPqdifFile& file_ref,
const TimeAggregatedStatBucket& bucket_ref,
StatValueKind value_kind,
std::vector<float>& value_buffer)
: parsed_file(file_ref),
bucket(bucket_ref),
kind(value_kind),
values(value_buffer),
placeholder_count(0),
missing_metric_count(0)
{
}
const ParsedPqdifFile& parsed_file;
const TimeAggregatedStatBucket& bucket;
StatValueKind kind;
std::vector<float>& values;
size_t placeholder_count;
size_t missing_metric_count;
size_t delta_line_phase_fallback_count = 0;
std::vector<std::string> missing_metric_names;
};
bool pqdif_base64_try_get_metric_value(
const TimeAggregatedStatBucket& bucket,
StatMetricId metric_id,
StatValueKind kind,
float& out_value)
{
auto it = bucket.metrics.find(metric_id);
if (it == bucket.metrics.end())
return false;
return bucket_has_metric_value_for_kind(it->second, kind, out_value);
}
StatMetricId pqdif_base64_delta_line_to_phase_metric_id(StatMetricId metric_id)
{
switch (metric_id)
{
case StatMetricId::UabRms: return StatMetricId::UaRms;
case StatMetricId::UbcRms: return StatMetricId::UbRms;
case StatMetricId::UcaRms: return StatMetricId::UcRms;
case StatMetricId::UabDeviation: return StatMetricId::UaDeviation;
case StatMetricId::UbcDeviation: return StatMetricId::UbDeviation;
case StatMetricId::UcaDeviation: return StatMetricId::UcDeviation;
case StatMetricId::UabThd: return StatMetricId::UaThd;
case StatMetricId::UbcThd: return StatMetricId::UbThd;
case StatMetricId::UcaThd: return StatMetricId::UcThd;
case StatMetricId::UabDvc: return StatMetricId::UaDvc;
case StatMetricId::UbcDvc: return StatMetricId::UbDvc;
case StatMetricId::UcaDvc: return StatMetricId::UcDvc;
case StatMetricId::UabPst: return StatMetricId::UaPst;
case StatMetricId::UbcPst: return StatMetricId::UbPst;
case StatMetricId::UcaPst: return StatMetricId::UcPst;
case StatMetricId::UabPlt: return StatMetricId::UaPlt;
case StatMetricId::UbcPlt: return StatMetricId::UbPlt;
case StatMetricId::UcaPlt: return StatMetricId::UcPlt;
case StatMetricId::UabFundRms: return StatMetricId::UaFundRms;
case StatMetricId::UbcFundRms: return StatMetricId::UbFundRms;
case StatMetricId::UcaFundRms: return StatMetricId::UcFundRms;
case StatMetricId::UabFundAngle: return StatMetricId::UaFundAngle;
case StatMetricId::UbcFundAngle: return StatMetricId::UbFundAngle;
case StatMetricId::UcaFundAngle: return StatMetricId::UcFundAngle;
default: break;
}
const StatDynamicMetricRange* r = stat_find_dynamic_metric_range(metric_id);
if (r == nullptr)
return StatMetricId::Unknown;
const int offset = stat_dynamic_metric_order_or_slot(metric_id);
if (r->group == StatDynamicMetricGroup::LineVoltageHarmonic)
return stat_dynamic_metric_id(StatDynamicMetricGroup::VoltageHarmonic, r->phase_index, offset);
if (r->group == StatDynamicMetricGroup::LineVoltageHarmonicAngle)
return stat_dynamic_metric_id(StatDynamicMetricGroup::VoltageHarmonicAngle, r->phase_index, offset);
if (r->group == StatDynamicMetricGroup::LineVoltageInterharmonic)
return stat_dynamic_metric_id(StatDynamicMetricGroup::VoltageInterharmonic, r->phase_index, offset);
if (r->group == StatDynamicMetricGroup::LineVoltageHarmonicRatio)
return stat_dynamic_metric_id(StatDynamicMetricGroup::VoltageHarmonicRatio, r->phase_index, offset);
return StatMetricId::Unknown;
}
void pqdif_base64_push_metric(PqdifBase64BuildContext& ctx, StatMetricId metric_id)
{
float value = kPqdifBase64MissingFloat;
bool ok = false;
ok = pqdif_base64_try_get_metric_value(ctx.bucket, metric_id, ctx.kind, value);
if (!ok)
{
value = kPqdifBase64MissingFloat;
++ctx.placeholder_count;
++ctx.missing_metric_count;
const std::string name = stat_metric_name(metric_id);
ctx.missing_metric_names.push_back(name);
if (pqdif_log_enabled(PqdifLogLevel::Debug))
{
std::cout << " [BASE64 MISSING METRIC] time=" << ctx.bucket.timestamp_text
<< ", kind=" << stat_value_kind_name(ctx.kind)
<< ", metric=" << name
<< ", placeholder=" << kPqdifBase64MissingFloat
<< std::endl;
}
}
ctx.values.push_back(value);
}
void pqdif_base64_push_delta_line_metric_with_phase_fallback(PqdifBase64BuildContext& ctx, StatMetricId line_metric_id)
{
float value = kPqdifBase64MissingFloat;
if (pqdif_base64_try_get_metric_value(ctx.bucket, line_metric_id, ctx.kind, value))
{
ctx.values.push_back(value);
return;
}
const StatMetricId phase_metric_id = pqdif_base64_delta_line_to_phase_metric_id(line_metric_id);
if (phase_metric_id != StatMetricId::Unknown &&
pqdif_base64_try_get_metric_value(ctx.bucket, phase_metric_id, ctx.kind, value))
{
ctx.values.push_back(value);
++ctx.delta_line_phase_fallback_count;
if (pqdif_log_enabled(PqdifLogLevel::Info))
{
std::cout << " [BASE64 DELTA LINE FALLBACK] time=" << ctx.bucket.timestamp_text
<< ", kind=" << stat_value_kind_name(ctx.kind)
<< ", line_metric=" << stat_metric_name(line_metric_id)
<< ", fallback_phase_metric=" << stat_metric_name(phase_metric_id)
<< ", value=" << value
<< std::endl;
}
return;
}
ctx.values.push_back(kPqdifBase64MissingFloat);
++ctx.placeholder_count;
++ctx.missing_metric_count;
const std::string line_name = stat_metric_name(line_metric_id);
ctx.missing_metric_names.push_back(line_name);
if (pqdif_log_enabled(PqdifLogLevel::Debug))
{
std::cout << " [BASE64 MISSING METRIC] time=" << ctx.bucket.timestamp_text
<< ", kind=" << stat_value_kind_name(ctx.kind)
<< ", metric=" << line_name
<< ", placeholder=" << kPqdifBase64MissingFloat
<< ", reason=delta_line_metric_and_phase_fallback_missing";
if (phase_metric_id != StatMetricId::Unknown)
std::cout << ", fallback_phase_metric=" << stat_metric_name(phase_metric_id);
std::cout << std::endl;
}
}
void pqdif_base64_push_placeholder(PqdifBase64BuildContext& ctx, const std::string& label)
{
ctx.values.push_back(kPqdifBase64MissingFloat);
++ctx.placeholder_count;
if (pqdif_log_enabled(PqdifLogLevel::Trace))
{
std::cout << " [BASE64 PLACEHOLDER] time=" << ctx.bucket.timestamp_text
<< ", kind=" << stat_value_kind_name(ctx.kind)
<< ", label=" << label
<< ", value=" << kPqdifBase64MissingFloat
<< std::endl;
}
}
void pqdif_base64_push_placeholder_block(PqdifBase64BuildContext& ctx, const std::string& label, size_t count)
{
for (size_t i = 0; i < count; ++i)
{
ctx.values.push_back(kPqdifBase64MissingFloat);
++ctx.placeholder_count;
}
if (pqdif_log_enabled(PqdifLogLevel::Info))
{
std::cout << " [BASE64 PLACEHOLDER BLOCK] time=" << ctx.bucket.timestamp_text
<< ", kind=" << stat_value_kind_name(ctx.kind)
<< ", label=" << label
<< ", count=" << count
<< ", value=" << kPqdifBase64MissingFloat
<< std::endl;
}
}
void pqdif_base64_push_dynamic_order_range(
PqdifBase64BuildContext& ctx,
StatDynamicMetricGroup group,
int phase_index,
int first_offset,
int last_offset)
{
for (int offset = first_offset; offset <= last_offset; ++offset)
{
pqdif_base64_push_metric(ctx, stat_dynamic_metric_id(group, phase_index, offset));
}
}
void pqdif_base64_push_dynamic_three_phases(
PqdifBase64BuildContext& ctx,
StatDynamicMetricGroup group,
int first_offset,
int last_offset)
{
for (int phase = 0; phase < 3; ++phase)
pqdif_base64_push_dynamic_order_range(ctx, group, phase, first_offset, last_offset);
}
void pqdif_base64_push_dynamic_order_range_delta_line_fallback(
PqdifBase64BuildContext& ctx,
StatDynamicMetricGroup line_group,
int phase_index,
int first_offset,
int last_offset)
{
for (int offset = first_offset; offset <= last_offset; ++offset)
{
pqdif_base64_push_delta_line_metric_with_phase_fallback(
ctx,
stat_dynamic_metric_id(line_group, phase_index, offset));
}
}
void pqdif_base64_push_dynamic_three_line_phases_with_delta_fallback(
PqdifBase64BuildContext& ctx,
StatDynamicMetricGroup line_group,
int first_offset,
int last_offset)
{
for (int phase = 0; phase < 3; ++phase)
{
pqdif_base64_push_dynamic_order_range_delta_line_fallback(
ctx,
line_group,
phase,
first_offset,
last_offset);
}
}
void pqdif_base64_push_harmonic_power_phase(
PqdifBase64BuildContext& ctx,
int phase_index)
{
pqdif_base64_push_dynamic_order_range(ctx, StatDynamicMetricGroup::HarmonicActivePower, phase_index, 2, 50);
pqdif_base64_push_dynamic_order_range(ctx, StatDynamicMetricGroup::HarmonicReactivePower, phase_index, 2, 50);
pqdif_base64_push_dynamic_order_range(ctx, StatDynamicMetricGroup::HarmonicApparentPower, phase_index, 2, 50);
}
std::vector<float> pqdif_build_star_float_buffer_for_bucket(
const ParsedPqdifFile& parsed_file,
const TimeAggregatedStatBucket& bucket,
StatValueKind kind,
size_t& placeholder_count,
size_t& missing_metric_count,
std::vector<std::string>& missing_metric_names)
{
std::vector<float> float_buffer;
float_buffer.reserve(2463);
PqdifBase64BuildContext ctx{ parsed_file, bucket, kind, float_buffer };
// 1) 三相电压有效值、三相电流有效值、三线电压有效值
pqdif_base64_push_metric(ctx, StatMetricId::UaRms);
pqdif_base64_push_metric(ctx, StatMetricId::UbRms);
pqdif_base64_push_metric(ctx, StatMetricId::UcRms);
pqdif_base64_push_metric(ctx, StatMetricId::IaRms);
pqdif_base64_push_metric(ctx, StatMetricId::IbRms);
pqdif_base64_push_metric(ctx, StatMetricId::IcRms);
pqdif_base64_push_metric(ctx, StatMetricId::UabRms);
pqdif_base64_push_metric(ctx, StatMetricId::UbcRms);
pqdif_base64_push_metric(ctx, StatMetricId::UcaRms);
// 2) 三相电压偏差 + 三线电压偏差占位
pqdif_base64_push_metric(ctx, StatMetricId::UaDeviation);
pqdif_base64_push_metric(ctx, StatMetricId::UbDeviation);
pqdif_base64_push_metric(ctx, StatMetricId::UcDeviation);
pqdif_base64_push_placeholder_block(ctx, "line voltage deviation placeholder(Uab/Ubc/Uca)", 3);
// 3) 频率偏差 + 频率
pqdif_base64_push_metric(ctx, StatMetricId::FrequencyDeviation);
pqdif_base64_push_metric(ctx, StatMetricId::Frequency);
// 4) 电压零/负/正序和负序不平衡
pqdif_base64_push_metric(ctx, StatMetricId::UZeroSeq);
pqdif_base64_push_metric(ctx, StatMetricId::UNegSeq);
pqdif_base64_push_metric(ctx, StatMetricId::UPosSeq);
pqdif_base64_push_metric(ctx, StatMetricId::UNegSeqUnbalance);
// 5) 电流零/负/正序和负序不平衡
pqdif_base64_push_metric(ctx, StatMetricId::IZeroSeq);
pqdif_base64_push_metric(ctx, StatMetricId::INegSeq);
pqdif_base64_push_metric(ctx, StatMetricId::IPosSeq);
pqdif_base64_push_metric(ctx, StatMetricId::INegSeqUnbalance);
// 6) 三相电压谐波 2-50 次指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::VoltageHarmonic, 2, 50);
// 7) 三相电流谐波 2-50 次指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentHarmonic, 2, 50);
// 8) 三线电压谐波占位
pqdif_base64_push_placeholder_block(ctx, "line voltage harmonic placeholder(Uab/Ubc/Uca,2-50)", 49 * 3);
// 9) 三相电压谐波 2-50 次相角指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::VoltageHarmonicAngle, 2, 50);
// 10) 三相电流谐波 2-50 次相角指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentHarmonicAngle, 2, 50);
// 11) 三线电压谐波相角占位
pqdif_base64_push_placeholder_block(ctx, "line voltage harmonic angle placeholder(Uab/Ubc/Uca,2-50)", 49 * 3);
// 12) 三相电压间谐波 0.5-49.5 次指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::VoltageInterharmonic, 0, 49);
// 13) 三相电流间谐波 0.5-49.5 次指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentInterharmonic, 0, 49);
// 14) 三线电压间谐波占位
pqdif_base64_push_placeholder_block(ctx, "line voltage interharmonic placeholder(Uab/Ubc/Uca,0.5-49.5)", 50 * 3);
// 15) A/B/C/总 有功/无功/视在功率
pqdif_base64_push_metric(ctx, StatMetricId::PaPower);
pqdif_base64_push_metric(ctx, StatMetricId::QaPower);
pqdif_base64_push_metric(ctx, StatMetricId::SaPower);
pqdif_base64_push_metric(ctx, StatMetricId::PbPower);
pqdif_base64_push_metric(ctx, StatMetricId::QbPower);
pqdif_base64_push_metric(ctx, StatMetricId::SbPower);
pqdif_base64_push_metric(ctx, StatMetricId::PcPower);
pqdif_base64_push_metric(ctx, StatMetricId::QcPower);
pqdif_base64_push_metric(ctx, StatMetricId::ScPower);
pqdif_base64_push_metric(ctx, StatMetricId::PTotalPower);
pqdif_base64_push_metric(ctx, StatMetricId::QTotalPower);
pqdif_base64_push_metric(ctx, StatMetricId::STotalPower);
// 16) A/B/C/总 谐波 2-50 次 有功/无功/视在功率
pqdif_base64_push_harmonic_power_phase(ctx, 0);
pqdif_base64_push_harmonic_power_phase(ctx, 1);
pqdif_base64_push_harmonic_power_phase(ctx, 2);
pqdif_base64_push_harmonic_power_phase(ctx, 3);
// 17) 谐波含有率：三相电压、三相电流、三线电压占位
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::VoltageHarmonicRatio, 2, 50);
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentHarmonicRatio, 2, 50);
pqdif_base64_push_placeholder_block(ctx, "line voltage harmonic ratio placeholder(Uab/Ubc/Uca,2-50)", 49 * 3);
// 18) 谐波总畸变率：三相电压、三相电流、三线电压占位
pqdif_base64_push_metric(ctx, StatMetricId::UaThd);
pqdif_base64_push_metric(ctx, StatMetricId::UbThd);
pqdif_base64_push_metric(ctx, StatMetricId::UcThd);
pqdif_base64_push_metric(ctx, StatMetricId::IaThd);
pqdif_base64_push_metric(ctx, StatMetricId::IbThd);
pqdif_base64_push_metric(ctx, StatMetricId::IcThd);
pqdif_base64_push_placeholder_block(ctx, "line voltage THD placeholder(Uab/Ubc/Uca)", 3);
// 19) 三相功率因数和总功率因数
pqdif_base64_push_metric(ctx, StatMetricId::PFa);
pqdif_base64_push_metric(ctx, StatMetricId::PFb);
pqdif_base64_push_metric(ctx, StatMetricId::PFc);
pqdif_base64_push_metric(ctx, StatMetricId::PFTotal);
// 20) 三相基波功率因数和总基波功率因数
pqdif_base64_push_metric(ctx, StatMetricId::FundPFa);
pqdif_base64_push_metric(ctx, StatMetricId::FundPFb);
pqdif_base64_push_metric(ctx, StatMetricId::FundPFc);
pqdif_base64_push_metric(ctx, StatMetricId::FundPFTotal);
// 21) 三相电压变动幅值 + 三线占位
pqdif_base64_push_metric(ctx, StatMetricId::UaDvc);
pqdif_base64_push_metric(ctx, StatMetricId::UbDvc);
pqdif_base64_push_metric(ctx, StatMetricId::UcDvc);
pqdif_base64_push_placeholder_block(ctx, "line voltage DVC placeholder(Uab/Ubc/Uca)", 3);
// 22) 三相短闪 + 三线占位
pqdif_base64_push_metric(ctx, StatMetricId::UaPst);
pqdif_base64_push_metric(ctx, StatMetricId::UbPst);
pqdif_base64_push_metric(ctx, StatMetricId::UcPst);
pqdif_base64_push_placeholder_block(ctx, "line voltage Pst placeholder(Uab/Ubc/Uca)", 3);
// 23) 三相长闪 + 三线占位
pqdif_base64_push_metric(ctx, StatMetricId::UaPlt);
pqdif_base64_push_metric(ctx, StatMetricId::UbPlt);
pqdif_base64_push_metric(ctx, StatMetricId::UcPlt);
pqdif_base64_push_placeholder_block(ctx, "line voltage Plt placeholder(Uab/Ubc/Uca)", 3);
// 24) A/B/C/总 基波有功/无功/视在功率
pqdif_base64_push_metric(ctx, StatMetricId::PaFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QaFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::SaFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::PbFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QbFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::SbFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::PcFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QcFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::ScFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::PTotalFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QTotalFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::STotalFundPower);
// 25) 基波有效值：三相电压、三相电流、三线电压占位
pqdif_base64_push_metric(ctx, StatMetricId::UaFundRms);
pqdif_base64_push_metric(ctx, StatMetricId::UbFundRms);
pqdif_base64_push_metric(ctx, StatMetricId::UcFundRms);
pqdif_base64_push_metric(ctx, StatMetricId::IaFundRms);
pqdif_base64_push_metric(ctx, StatMetricId::IbFundRms);
pqdif_base64_push_metric(ctx, StatMetricId::IcFundRms);
pqdif_base64_push_placeholder_block(ctx, "line voltage fundamental RMS placeholder(Uab/Ubc/Uca)", 3);
// 26) 基波相角：三相电压、三相电流、三线电压相角占位
pqdif_base64_push_metric(ctx, StatMetricId::UaFundAngle);
pqdif_base64_push_metric(ctx, StatMetricId::UbFundAngle);
pqdif_base64_push_metric(ctx, StatMetricId::UcFundAngle);
pqdif_base64_push_metric(ctx, StatMetricId::IaFundAngle);
pqdif_base64_push_metric(ctx, StatMetricId::IbFundAngle);
pqdif_base64_push_metric(ctx, StatMetricId::IcFundAngle);
pqdif_base64_push_placeholder_block(ctx, "line voltage fundamental angle placeholder(Uab/Ubc/Uca)", 3);
placeholder_count = ctx.placeholder_count;
missing_metric_count = ctx.missing_metric_count;
missing_metric_names = ctx.missing_metric_names;
return float_buffer;
}
std::vector<float> pqdif_build_delta_float_buffer_for_bucket(
const ParsedPqdifFile& parsed_file,
const TimeAggregatedStatBucket& bucket,
StatValueKind kind,
size_t& placeholder_count,
size_t& missing_metric_count,
std::vector<std::string>& missing_metric_names)
{
std::vector<float> float_buffer;
// Delta 角型与 Wye 星型必须保持完全相同的 float 数量，便于后续统一解码。
float_buffer.reserve(2463);
PqdifBase64BuildContext ctx(parsed_file, bucket, kind, float_buffer);
// 1) 三相电压有效值、三相电流有效值、三线电压有效值
pqdif_base64_push_metric(ctx, StatMetricId::UaRms);
pqdif_base64_push_metric(ctx, StatMetricId::UbRms);
pqdif_base64_push_metric(ctx, StatMetricId::UcRms);
pqdif_base64_push_metric(ctx, StatMetricId::IaRms);
pqdif_base64_push_metric(ctx, StatMetricId::IbRms);
pqdif_base64_push_metric(ctx, StatMetricId::IcRms);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabRms);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcRms);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaRms);
// 2) 三相电压偏差占位 + 三线电压偏差
pqdif_base64_push_placeholder_block(ctx, "phase voltage deviation placeholder(Ua/Ub/Uc)", 3);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabDeviation);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcDeviation);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaDeviation);
// 3) 频率偏差 + 频率
pqdif_base64_push_metric(ctx, StatMetricId::FrequencyDeviation);
pqdif_base64_push_metric(ctx, StatMetricId::Frequency);
// 4) 电压零/负/正序和负序不平衡
pqdif_base64_push_metric(ctx, StatMetricId::UZeroSeq);
pqdif_base64_push_metric(ctx, StatMetricId::UNegSeq);
pqdif_base64_push_metric(ctx, StatMetricId::UPosSeq);
pqdif_base64_push_metric(ctx, StatMetricId::UNegSeqUnbalance);
// 5) 电流零/负/正序和负序不平衡
pqdif_base64_push_metric(ctx, StatMetricId::IZeroSeq);
pqdif_base64_push_metric(ctx, StatMetricId::INegSeq);
pqdif_base64_push_metric(ctx, StatMetricId::IPosSeq);
pqdif_base64_push_metric(ctx, StatMetricId::INegSeqUnbalance);
// 6) 三相电压谐波 2-50 次指标占位
pqdif_base64_push_placeholder_block(ctx, "phase voltage harmonic placeholder(Ua/Ub/Uc,2-50)", 49 * 3);
// 7) 三相电流谐波 2-50 次指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentHarmonic, 2, 50);
// 8) 三线电压谐波 2-50 次指标
pqdif_base64_push_dynamic_three_line_phases_with_delta_fallback(ctx, StatDynamicMetricGroup::LineVoltageHarmonic, 2, 50);
// 9) 三相电压谐波 2-50 次相角指标占位
pqdif_base64_push_placeholder_block(ctx, "phase voltage harmonic angle placeholder(Ua/Ub/Uc,2-50)", 49 * 3);
// 10) 三相电流谐波 2-50 次相角指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentHarmonicAngle, 2, 50);
// 11) 三线电压谐波 2-50 次相角指标
pqdif_base64_push_dynamic_three_line_phases_with_delta_fallback(ctx, StatDynamicMetricGroup::LineVoltageHarmonicAngle, 2, 50);
// 12) 三相电压间谐波 0.5-49.5 次指标占位
pqdif_base64_push_placeholder_block(ctx, "phase voltage interharmonic placeholder(Ua/Ub/Uc,0.5-49.5)", 50 * 3);
// 13) 三相电流间谐波 0.5-49.5 次指标
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentInterharmonic, 0, 49);
// 14) 三线电压间谐波 0.5-49.5 次指标
pqdif_base64_push_dynamic_three_line_phases_with_delta_fallback(ctx, StatDynamicMetricGroup::LineVoltageInterharmonic, 0, 49);
// 15) A/B/C/总 有功/无功/视在功率
pqdif_base64_push_metric(ctx, StatMetricId::PaPower);
pqdif_base64_push_metric(ctx, StatMetricId::QaPower);
pqdif_base64_push_metric(ctx, StatMetricId::SaPower);
pqdif_base64_push_metric(ctx, StatMetricId::PbPower);
pqdif_base64_push_metric(ctx, StatMetricId::QbPower);
pqdif_base64_push_metric(ctx, StatMetricId::SbPower);
pqdif_base64_push_metric(ctx, StatMetricId::PcPower);
pqdif_base64_push_metric(ctx, StatMetricId::QcPower);
pqdif_base64_push_metric(ctx, StatMetricId::ScPower);
pqdif_base64_push_metric(ctx, StatMetricId::PTotalPower);
pqdif_base64_push_metric(ctx, StatMetricId::QTotalPower);
pqdif_base64_push_metric(ctx, StatMetricId::STotalPower);
// 16) A/B/C/总 谐波 2-50 次 有功/无功/视在功率
pqdif_base64_push_harmonic_power_phase(ctx, 0);
pqdif_base64_push_harmonic_power_phase(ctx, 1);
pqdif_base64_push_harmonic_power_phase(ctx, 2);
pqdif_base64_push_harmonic_power_phase(ctx, 3);
// 17) 谐波含有率：三相电压占位、三相电流、三线电压
pqdif_base64_push_placeholder_block(ctx, "phase voltage harmonic ratio placeholder(Ua/Ub/Uc,2-50)", 49 * 3);
pqdif_base64_push_dynamic_three_phases(ctx, StatDynamicMetricGroup::CurrentHarmonicRatio, 2, 50);
pqdif_base64_push_dynamic_three_line_phases_with_delta_fallback(ctx, StatDynamicMetricGroup::LineVoltageHarmonicRatio, 2, 50);
// 18) 谐波总畸变率：三相电压占位、三相电流、三线电压
pqdif_base64_push_placeholder_block(ctx, "phase voltage THD placeholder(Ua/Ub/Uc)", 3);
pqdif_base64_push_metric(ctx, StatMetricId::IaThd);
pqdif_base64_push_metric(ctx, StatMetricId::IbThd);
pqdif_base64_push_metric(ctx, StatMetricId::IcThd);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabThd);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcThd);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaThd);
// 19) 三相功率因数和总功率因数
pqdif_base64_push_metric(ctx, StatMetricId::PFa);
pqdif_base64_push_metric(ctx, StatMetricId::PFb);
pqdif_base64_push_metric(ctx, StatMetricId::PFc);
pqdif_base64_push_metric(ctx, StatMetricId::PFTotal);
// 20) 三相基波功率因数和总基波功率因数
pqdif_base64_push_metric(ctx, StatMetricId::FundPFa);
pqdif_base64_push_metric(ctx, StatMetricId::FundPFb);
pqdif_base64_push_metric(ctx, StatMetricId::FundPFc);
pqdif_base64_push_metric(ctx, StatMetricId::FundPFTotal);
// 21) 三相电压变动幅值占位 + 三线电压变动幅值
pqdif_base64_push_placeholder_block(ctx, "phase voltage DVC placeholder(Ua/Ub/Uc)", 3);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabDvc);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcDvc);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaDvc);
// 22) 三相短闪占位 + 三线短闪
pqdif_base64_push_placeholder_block(ctx, "phase voltage Pst placeholder(Ua/Ub/Uc)", 3);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabPst);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcPst);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaPst);
// 23) 三相长闪占位 + 三线长闪
pqdif_base64_push_placeholder_block(ctx, "phase voltage Plt placeholder(Ua/Ub/Uc)", 3);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabPlt);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcPlt);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaPlt);
// 24) A/B/C/总 基波有功/无功/视在功率
pqdif_base64_push_metric(ctx, StatMetricId::PaFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QaFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::SaFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::PbFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QbFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::SbFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::PcFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QcFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::ScFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::PTotalFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::QTotalFundPower);
pqdif_base64_push_metric(ctx, StatMetricId::STotalFundPower);
// 25) 基波有效值：三相基波电压占位、三相基波电流、三线基波电压
pqdif_base64_push_placeholder_block(ctx, "phase voltage fundamental RMS placeholder(Ua/Ub/Uc)", 3);
pqdif_base64_push_metric(ctx, StatMetricId::IaFundRms);
pqdif_base64_push_metric(ctx, StatMetricId::IbFundRms);
pqdif_base64_push_metric(ctx, StatMetricId::IcFundRms);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabFundRms);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcFundRms);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaFundRms);
// 26) 基波相角：三相基波电压相角占位、三相基波电流相角、三线基波电压相角
pqdif_base64_push_placeholder_block(ctx, "phase voltage fundamental angle placeholder(Ua/Ub/Uc)", 3);
pqdif_base64_push_metric(ctx, StatMetricId::IaFundAngle);
pqdif_base64_push_metric(ctx, StatMetricId::IbFundAngle);
pqdif_base64_push_metric(ctx, StatMetricId::IcFundAngle);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UabFundAngle);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UbcFundAngle);
pqdif_base64_push_delta_line_metric_with_phase_fallback(ctx, StatMetricId::UcaFundAngle);
if (ctx.delta_line_phase_fallback_count > 0 && pqdif_log_enabled(PqdifLogLevel::Core))
{
std::cout << " [BASE64 DELTA LINE FALLBACK SUMMARY] time=" << ctx.bucket.timestamp_text
<< ", kind=" << stat_value_kind_name(ctx.kind)
<< ", fallback_count=" << ctx.delta_line_phase_fallback_count
<< std::endl;
}
placeholder_count = ctx.placeholder_count;
missing_metric_count = ctx.missing_metric_count;
missing_metric_names = ctx.missing_metric_names;
return float_buffer;
}
void pqdif_build_and_queue_base64_records(ParsedPqdifFile& parsed_file)
{
if (parsed_file.aggregated_stat_buckets.empty())
{
std::cout << "[PQDIF BASE64] skip: no aggregated buckets, file="
<< parsed_file.source_file << std::endl;
return;
}
// Wye 星型按星型顺序组装；Delta 角型按角型顺序组装。
// Unknown 暂按星型顺序组装，避免因为接线方式缺失直接丢弃数据。
const bool use_delta_assembly = (parsed_file.connection_kind == ParsedConnectionKind::Delta);
const char* assembly_name = use_delta_assembly ? "DELTA" : "STAR";
const std::string full_path = pqdif_absolute_path_text(parsed_file.source_file);
const std::vector<StatValueKind> kind_order = {
StatValueKind::Max,
StatValueKind::Min,
StatValueKind::Avg,
StatValueKind::P95
};
PqdifStatBase64FileBatch file_batch;
file_batch.pqdif_file_path = full_path;
file_batch.source_file = parsed_file.source_file;
file_batch.mac = parsed_file.mac;
file_batch.parsed_at = parsed_file.parsed_at;
file_batch.parsed_at_text = format_time_text(parsed_file.parsed_at);
file_batch.connection_kind = parsed_file.connection_kind;
file_batch.time_points.reserve(parsed_file.aggregated_stat_buckets.size());
size_t generated = 0;
size_t total_placeholders = 0;
size_t total_missing_metrics = 0;
size_t expected_float_count = 0;
std::cout << "========== PQDIF BASE64 ASSEMBLY ==========" << std::endl;
std::cout << "file=" << full_path
<< ", buckets=" << parsed_file.aggregated_stat_buckets.size()
<< ", connection_kind=" << stat_connection_kind_name(parsed_file.connection_kind)
<< ", assembly=" << assembly_name
<< ", kind_order=Max/Min/Avg/P95"
<< ", queue_mode=file_batch/time_point/records"
<< std::endl;
for (const auto& bucket : parsed_file.aggregated_stat_buckets)
{
PqdifStatBase64TimePointPacket time_packet;
time_packet.timestamp = bucket.timestamp;
time_packet.timestamp_text = bucket.timestamp_text;
time_packet.records.reserve(kind_order.size());
for (StatValueKind kind : kind_order)
{
size_t placeholder_count = 0;
size_t missing_metric_count = 0;
std::vector<std::string> missing_metric_names;
std::vector<float> floats = use_delta_assembly ?
pqdif_build_delta_float_buffer_for_bucket(
parsed_file,
bucket,
kind,
placeholder_count,
missing_metric_count,
missing_metric_names) :
pqdif_build_star_float_buffer_for_bucket(
parsed_file,
bucket,
kind,
placeholder_count,
missing_metric_count,
missing_metric_names);
if (expected_float_count == 0)
expected_float_count = floats.size();
PqdifStatBase64Record rec;
rec.pqdif_file_path = full_path;
rec.value_kind = kind;
rec.value_kind_name = stat_value_kind_name(kind);
rec.value_kind_code = stat_value_kind_code_for_base64(kind);
rec.timestamp = bucket.timestamp;
rec.timestamp_text = bucket.timestamp_text;
rec.float_count = floats.size();
rec.placeholder_count = placeholder_count;
rec.connection_kind = parsed_file.connection_kind;
rec.base64_payload = pqdif_base64_encode_float_vector(floats);
time_packet.total_float_count += rec.float_count;
time_packet.total_placeholder_count += rec.placeholder_count;
time_packet.total_base64_chars += rec.base64_payload.size();
time_packet.records.emplace_back(std::move(rec));
++generated;
total_placeholders += placeholder_count;
total_missing_metrics += missing_metric_count;
if (pqdif_log_enabled(PqdifLogLevel::Info) || generated <= 4)
{
const PqdifStatBase64Record& log_rec = time_packet.records.back();
std::cout << " [BASE64 SUB RECORD] time=" << bucket.timestamp_text
<< ", kind=" << log_rec.value_kind_name
<< ", kind_code=" << log_rec.value_kind_code
<< ", floats=" << log_rec.float_count
<< ", placeholders=" << log_rec.placeholder_count
<< ", missing_metrics=" << missing_metric_count
<< ", base64_len=" << log_rec.base64_payload.size()
<< std::endl;
}
if (pqdif_log_enabled(PqdifLogLevel::Info) && !missing_metric_names.empty())
{
std::cout << " [BASE64 MISSING SUMMARY] time=" << bucket.timestamp_text
<< ", kind=" << stat_value_kind_name(kind)
<< ", count=" << missing_metric_names.size()
<< ", first_metrics=";
const size_t limit = std::min<size_t>(missing_metric_names.size(), 12);
for (size_t i = 0; i < limit; ++i)
{
if (i != 0) std::cout << "/";
std::cout << missing_metric_names[i];
}
if (missing_metric_names.size() > limit)
std::cout << "/...";
std::cout << std::endl;
}
}
time_packet.record_count = time_packet.records.size();
file_batch.total_record_count += time_packet.record_count;
file_batch.total_float_count += time_packet.total_float_count;
file_batch.total_placeholder_count += time_packet.total_placeholder_count;
file_batch.total_base64_chars += time_packet.total_base64_chars;
file_batch.time_points.emplace_back(std::move(time_packet));
}
file_batch.time_point_count = file_batch.time_points.size();
std::cout << " [BASE64 FILE BATCH SUMMARY] generated_records=" << generated
<< ", time_points=" << file_batch.time_point_count
<< ", expected_float_count_per_record=" << expected_float_count
<< ", total_placeholders=" << total_placeholders
<< ", total_missing_metrics=" << total_missing_metrics
<< ", total_base64_chars=" << file_batch.total_base64_chars
<< std::endl;
// 按你的要求，入队前完整打印保存对象内部结构：文件批次 -> 时间点 -> Max/Min/Avg/P95 子记录 -> Base64 内容。
// 日志会很长；确认完成后可以临时注释掉这一行，或改成 if (pqdif_log_enabled(PqdifLogLevel::Info)) 包裹。
//pqdif_dump_stat_base64_file_batch_full(file_batch);
push_pqdif_stat_base64_file_batch(std::move(file_batch));
std::cout << " [BASE64 QUEUE SUMMARY] file_batch_queue_size=" << GetPqdifStatBase64QueueSize()
<< ", total_sub_records_in_queue=" << GetPqdifStatBase64RecordCountInQueue()
<< std::endl;
std::cout << "================================================" << std::endl;
}
bool process_single_pqdif_file(const fs::path& file_path, const std::string& mac)
{
ParsedPqdifFile parsed_file;
parsed_file.mac = mac;
parsed_file.source_file = file_path.string();
parsed_file.parsed_at = std::time(nullptr);
std::string err;
if (!parse_pqdif_file_full(file_path.string(), parsed_file.logical_file, err))
{
std::cout << "[PQDIF] parse failed: " << file_path.string()
<< " reason=" << err << std::endl;
return false;
}
dump_logical_summary(parsed_file);
dump_monitor_settings_probe(parsed_file);
if (pqdif_log_enabled(PqdifLogLevel::Debug))
{
// Debug 级别：打印全部 observation 概览，帮助确认指标是否位于非 Trend observation 中。
dump_observation_list(parsed_file);
// Debug 级别：打印动态谱类候选通道，用于确认线电压谐波、相角、间谐波是否存在。
dump_dynamic_spectrum_candidate_probe(parsed_file);
// Debug 级别：打印闪变候选通道，用于确认 Plt 通道是否存在数据点。
dump_flicker_candidate_probe(parsed_file);
}
if (pqdif_is_trace_log_enabled())
{
// Trace 级别：保留旧的疑似谐波全量探针；日志量更大，仅排查复杂问题时打开。
dump_harmonic_channel_probe(parsed_file);
}
// 1) 识别接线方式。
// 后续指标判断需要先区分星型 / 角型两套规则。
parsed_file.connection_kind = stat_classify_connection_kind(parsed_file.logical_file);
// 2) 只筛选“统计类 observation”，并对其展开目标统计指标。
// 当前阶段不处理全部 observation，避免不同 observation 混入同一时间聚合结果。
parsed_file.expanded_stat_points = stat_expand_selected_statistical_observation(
parsed_file.logical_file,
parsed_file.connection_kind,
parsed_file.selected_observation_index,
parsed_file.selected_observation_name);
// 3) 对已筛选出的统计 observation，按 timestamp 聚合。
parsed_file.aggregated_stat_buckets =
stat_group_points_by_timestamp(parsed_file.expanded_stat_points);
if (pqdif_is_trace_log_enabled())
dump_semantic_probe(parsed_file);
dump_expanded_stat_preview(parsed_file);
// 分组结果平时也要打印核心摘要；开启详细日志时才会打印完整明细。
dump_grouped_bucket_preview(parsed_file);
// 4) 将每个时间桶按接线方式组装为 Max/Min/Avg/P95 四条 Base64 暂存记录。
// Wye 使用星型顺序，Delta 使用角型顺序；两者 float 数量保持一致。
pqdif_build_and_queue_base64_records(parsed_file);
if (!push_parsed_result_to_cache(std::move(parsed_file)))
{
std::cout << "[PQDIF] push cache failed: " << file_path.string() << std::endl;
return false;
}
std::cout << "[PQDIF] processed ok: " << file_path.string()
<< ", cache_size=" << GetParsedPqdifCacheSize()
<< std::endl;
return true;
}
struct PendingPqdifFile
{
fs::path path;
std::string mac;
};
void scan_once()
{
ensure_dir(kPqdRootDir);
ensure_dir(kDoneRootDir);
ensure_dir(kFailRootDir);
std::error_code ec;
if (!fs::exists(kPqdRootDir, ec) || !fs::is_directory(kPqdRootDir, ec))
return;
std::vector<PendingPqdifFile> pending_files;
// 先收集所有 MAC 目录下的 PQDIF 文件，但本轮不会全部处理。
// 后面会按文件修改时间排序，并最多处理 kMaxPqdifFilesPerScan 个文件。
for (fs::directory_iterator mac_it(kPqdRootDir, ec), mac_end; !ec && mac_it != mac_end; mac_it.increment(ec))
{
if (ec || !fs::is_directory(mac_it->path()))
continue;
const std::string mac = mac_it->path().filename().string();
std::error_code file_ec;
for (fs::directory_iterator file_it(mac_it->path(), file_ec), file_end; !file_ec && file_it != file_end; file_it.increment(file_ec))
{
if (file_ec || !is_pqdif_file(file_it->path()))
continue;
PendingPqdifFile item;
item.path = file_it->path();
item.mac = mac;
pending_files.push_back(item);
}
}
if (pending_files.empty())
return;
// 旧文件优先处理，避免目录中长期积压的旧 PQDIF 一直排在后面。
std::sort(pending_files.begin(), pending_files.end(), [](const PendingPqdifFile& a, const PendingPqdifFile& b) {
std::error_code ea, eb;
const auto ta = fs::last_write_time(a.path, ea);
const auto tb = fs::last_write_time(b.path, eb);
if (ea && !eb)
return false;
if (!ea && eb)
return true;
if (!ea && !eb && ta != tb)
return ta < tb;
return a.path.string() < b.path.string();
});
int processed_count = 0;
for (const auto& item : pending_files)
{
if (processed_count >= kMaxPqdifFilesPerScan)
break;
std::cout << "[PQDIF] scan selected file: " << item.path.string()
<< ", pending_count=" << pending_files.size()
<< ", max_per_scan=" << kMaxPqdifFilesPerScan
<< std::endl;
const bool ok = process_single_pqdif_file(item.path, item.mac);
const fs::path target_root = ok ? fs::path(kDoneRootDir) : fs::path(kFailRootDir);
const fs::path dst = target_root / item.mac / item.path.filename();
// 处理完成后移动文件，避免下一轮 scan_once() 重复解析同一个 PQDIF。
// 解析成功：download/<mac>/<file>.pqd -> download_done/<mac>/<file>.pqd
// 解析失败：download/<mac>/<file>.pqd -> download_fail/<mac>/<file>.pqd
//
// 调试时如果想让文件保留在 download 目录中、方便反复解析同一个文件，
// 可以临时注释掉下面这个 if 块；调试结束后建议恢复，否则每一轮都会重复解析。
if (!move_file_with_fallback(item.path, dst))
{
std::cout << "[PQDIF] move failed: "
<< item.path.string() << " -> " << dst.string()
<< std::endl;
}
cleanup_backup_dir(fs::path(kDoneRootDir) / item.mac, kBackupLimit);
cleanup_backup_dir(fs::path(kFailRootDir) / item.mac, kBackupLimit);
++processed_count;
}
}
} // namespace
bool PopOldestParsedPqdifFile(ParsedPqdifFile& out)
{
std::lock_guard<std::mutex> guard(g_parsed_cache_mutex);
if (g_parsed_cache.empty())
return false;
out = std::move(g_parsed_cache.front());
g_parsed_cache.pop_front();
return true;
}
bool PeekOldestParsedPqdifFile(ParsedPqdifFile& out)
{
std::lock_guard<std::mutex> guard(g_parsed_cache_mutex);
if (g_parsed_cache.empty())
return false;
out = g_parsed_cache.front();
return true;
}
size_t GetParsedPqdifCacheSize()
{
std::lock_guard<std::mutex> guard(g_parsed_cache_mutex);
return g_parsed_cache.size();
}
void ClearParsedPqdifCache()
{
std::lock_guard<std::mutex> guard(g_parsed_cache_mutex);
g_parsed_cache.clear();
}
bool PopOldestPqdifStatBase64FileBatch(PqdifStatBase64FileBatch& out)
{
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
if (g_pqdif_stat_base64_queue.empty())
return false;
out = std::move(g_pqdif_stat_base64_queue.front());
g_pqdif_stat_base64_queue.pop_front();
return true;
}
bool PeekOldestPqdifStatBase64FileBatch(PqdifStatBase64FileBatch& out)
{
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
if (g_pqdif_stat_base64_queue.empty())
return false;
out = g_pqdif_stat_base64_queue.front();
return true;
}
bool PopOldestPqdifStatBase64Record(PqdifStatBase64Record& out)
{
// 兼容旧接口：从“文件级批次队列”的最早文件、最早时间点中拆出一条子记录。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
while (!g_pqdif_stat_base64_queue.empty())
{
PqdifStatBase64FileBatch& batch = g_pqdif_stat_base64_queue.front();
while (!batch.time_points.empty() && batch.time_points.front().records.empty())
batch.time_points.erase(batch.time_points.begin());
if (batch.time_points.empty())
{
g_pqdif_stat_base64_queue.pop_front();
continue;
}
PqdifStatBase64TimePointPacket& tp = batch.time_points.front();
out = std::move(tp.records.front());
const size_t out_base64_len = out.base64_payload.size();
if (tp.record_count > 0) --tp.record_count;
if (tp.total_float_count >= out.float_count) tp.total_float_count -= out.float_count;
if (tp.total_placeholder_count >= out.placeholder_count) tp.total_placeholder_count -= out.placeholder_count;
if (tp.total_base64_chars >= out_base64_len) tp.total_base64_chars -= out_base64_len;
if (batch.total_record_count > 0) --batch.total_record_count;
if (batch.total_float_count >= out.float_count) batch.total_float_count -= out.float_count;
if (batch.total_placeholder_count >= out.placeholder_count) batch.total_placeholder_count -= out.placeholder_count;
if (batch.total_base64_chars >= out_base64_len) batch.total_base64_chars -= out_base64_len;
tp.records.erase(tp.records.begin());
if (tp.records.empty())
{
batch.time_points.erase(batch.time_points.begin());
if (batch.time_point_count > 0) --batch.time_point_count;
}
if (batch.time_points.empty())
g_pqdif_stat_base64_queue.pop_front();
return true;
}
return false;
}
bool PeekOldestPqdifStatBase64Record(PqdifStatBase64Record& out)
{
// 兼容旧接口：只查看“文件级批次队列”的最早文件、最早时间点中的第一条子记录。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
for (const auto& batch : g_pqdif_stat_base64_queue)
{
for (const auto& tp : batch.time_points)
{
if (!tp.records.empty())
{
out = tp.records.front();
return true;
}
}
}
return false;
}
size_t GetPqdifStatBase64QueueSize()
{
// v20 起返回文件级批次数量，不再是子记录数量。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
return g_pqdif_stat_base64_queue.size();
}
size_t GetPqdifStatBase64RecordCountInQueue()
{
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
return pqdif_stat_base64_count_records_in_queue_unlocked();
}
void ClearPqdifStatBase64Queue()
{
// 清空 Base64 生成队列。
// 对象用途：调试或重置解析状态时使用；不会清空待后续处理队列。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_mutex);
g_pqdif_stat_base64_queue.clear();
}
bool PopReadyPqdifStatBase64FileBatch(PqdifStatBase64FileBatch& out)
{
// 从“待后续处理队列”取出一个完整 PQDIF 文件批次。
// 对象用途：后续入库/上传/推送逻辑应优先调用这个接口，而不是直接访问全局 deque。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_ready_mutex);
if (g_pqdif_stat_base64_ready_queue.empty())
return false;
out = std::move(g_pqdif_stat_base64_ready_queue.front());
g_pqdif_stat_base64_ready_queue.pop_front();
return true;
}
bool PeekReadyPqdifStatBase64FileBatch(PqdifStatBase64FileBatch& out)
{
// 查看“待后续处理队列”最早的 PQDIF 文件批次，但不移除。
// 对象用途：仅检查当前准备处理的数据内容，适合调试或状态展示。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_ready_mutex);
if (g_pqdif_stat_base64_ready_queue.empty())
return false;
out = g_pqdif_stat_base64_ready_queue.front();
return true;
}
size_t GetReadyPqdifStatBase64QueueSize()
{
// 返回待后续处理队列中的文件级批次数量。
// 注意：返回的是文件数量，不是 Max/Min/Avg/P95 子记录数量。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_ready_mutex);
return g_pqdif_stat_base64_ready_queue.size();
}
size_t GetReadyPqdifStatBase64RecordCountInQueue()
{
// 返回待后续处理队列中全部文件批次包含的 Base64 子记录数量。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_ready_mutex);
return pqdif_stat_base64_count_records_in_queue_unlocked(g_pqdif_stat_base64_ready_queue);
}
void ClearReadyPqdifStatBase64Queue()
{
// 清空待后续处理队列。
// 对象用途：调试或重置后续处理状态时使用；不会清空解析生成队列。
std::lock_guard<std::mutex> guard(g_pqdif_stat_base64_ready_mutex);
g_pqdif_stat_base64_ready_queue.clear();
}
void RunPqdifScanLoop()
{
std::cout << "[PQDIF] scan loop started, root=" << kPqdRootDir
<< ", interval=" << kScanIntervalSec << "s"
<< std::endl;
while (true)
{
try
{
scan_once();
}
catch (const std::exception& ex)
{
std::cout << "[PQDIF] scan exception: " << ex.what() << std::endl;
}
catch (...)
{
std::cout << "[PQDIF] scan exception: unknown" << std::endl;
}
try
{
// 循环最后，检查 Base64 生成队列中是否已经存在一个完整 PQDIF 文件批次。
// 如果存在，则取出最多一个并移动到“待后续处理队列”。
// 后续业务处理请调用 PopReadyPqdifStatBase64FileBatch() 从待处理队列取数据。
pqdif_move_one_generated_base64_batch_to_ready_queue();
PqdifStatBase64FileBatch batch;
if (PopReadyPqdifStatBase64FileBatch(batch)) {
// batch 就是一个 PQDIF 文件完整的 Base64 组装结果
// 在此处处理上送逻辑
}
}
catch (const std::exception& ex)
{
std::cout << "[PQDIF BASE64 READY] move exception: " << ex.what() << std::endl;
}
catch (...)
{
std::cout << "[PQDIF BASE64 READY] move exception: unknown" << std::endl;
}
std::this_thread::sleep_for(std::chrono::seconds(kScanIntervalSec));
}
}
Reference in New Issue View Git Blame Copy Permalink