huamonarch/eis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
e21b2af2a6
eis/RICS/RICS_alg.cc

759 lines
27 KiB
C++
Raw Normal View History

Initial commit: EIS C++ project with multi-process code
2026-05-09 11:23:45 +08:00
#include <RICS/RICS_alg.h>
#include <RICS/table_struct/t_rule_cfg.h>
#include <RICS/utility.h>
#include <mix_cc/sql.h>
#include <mix_cc/sql/database/db2_t.h>
RICSAlg::RICSAlg() {
logger_ = std::make_unique<LOG>("RICSAlg");
SingletonTemplate<Item2Chines>::GetInstance()("test");
}
RICSAlg::~RICSAlg() {}
void RICSAlg::alg_handle(int algid) {
try {
// 载入T_RULE_CFG表，从其中读取算法
T_RULE_CFG t_rule_cfg;
auto sql_statement =
select(t_rule_cfg.algId(), t_rule_cfg.ruleId(), t_rule_cfg.ruleName(),
t_rule_cfg.remark(), t_rule_cfg.ruleGroup(), t_rule_cfg.eqpid(),
t_rule_cfg.flag(), t_rule_cfg.ruleParam())
.from(t_rule_cfg)
.where(t_rule_cfg.algId() == algid);
auto rule_list_maybe = mix_cc::sql::exec<db2_t, T_RULE_CFG>(sql_statement);
if (rule_list_maybe.is_just()) {
int tagMax = 0;
auto rule_list = rule_list_maybe.unsafe_get_just();
logger_->Info() << "rules in DB:" << rule_list.size() << endl;
CfgRuleInfo cfg_rule_info;
for (auto x : rule_list) {
RuleInfo rule_info;
// logger_->Debug() << "ID:" << x.ruleId << " AlgID:" << x.algId
// << " Name:" << x.ruleName << " Flag:" << x.flag
// << endl;
rule_info.rule_name = x.ruleName;
rule_info.remark = x.remark;
rule_info.eqpid = x.eqpid;
rule_info.rule_group = x.ruleGroup;
auto param_info = mix_cc::json::parse(x.ruleParam);
if (param_info.contains("output")) {
rule_info.alarm_reason =
param_info.at("output").at("reason").at("value").get<string>();
rule_info.alarm_content =
param_info.at("output").at("error").at("value").get<string>();
}
rule_info.pre_condition = param_info.at("before_exec").get<string>();
rule_info.pre_result = param_info.at("function")
.at("pre_result")
.at("value")
.get<string>();
const auto tag_dict = param_info["tags"];
const int tag_size = tag_dict.size();
tagMax = std::max(tagMax, tag_size);
rule_info.tags_item.resize(tag_size);
rule_info.tags_chinese.resize(tag_size);
for (auto y : tag_dict.items()) {
int item_index = stoi(y.key().substr(3));
if (item_index > tag_size) {
logger_->Error()
<< "ruleid:" << x.ruleId << ",rulename:" << x.ruleName
<< ",tag max:" << tag_size << ",now tag index:" << item_index
<< std::endl;
continue;
}
auto itemi = y.value().at("value").get<std::string>();
rule_info.tags_item[item_index - 1] = itemi;
rule_info.tags_chinese[item_index - 1] =
SingletonTemplate<Item2Chines>::GetInstance()(itemi);
}
auto fun_json = param_info.at("function");
exp_handle(fun_json, rule_info, algid);
cfg_rule_info[x.ruleId] = rule_info;
}
alg_rule_info_[algid] = cfg_rule_info;
alg_2_tagMax[algid] = tagMax;
logger_->Debug() << "alg_2_tagMax[algid]：" << alg_2_tagMax[algid]
<< std::endl;
} else {
logger_->Debug() << "algid:" << algid << " 无规则" << std::endl;
}
} catch (const std::exception &e) {
logger_->Error() << e.what() << std::endl;
}
}
void RICSAlg::timed_task() {
logger_->Debug() << "test" << std::endl;
for (auto item : AlgId) {
logger_->Debug() << "item:" << item << std::endl;
alg_handle(item);
string jvalue = get_json_by_algid(item);
string jkey = unitNo_ + "_Alg_" + std::to_string(item);
write_memcaced(jkey, jvalue);
logger_->Debug() << "jkey:" << jkey
<< ",jvalue size:" << alg_rule_info_[item].size()
<< std::endl;
// logger_->Debug() << "jkey:" << jkey << ",jvalue:" << jvalue << std::endl;
}
}
void RICSAlg::dispose(int event_no, const ::Ice::ByteSeq &seq) {
string str(seq.begin(), seq.end());
logger_->Debug() << "seq:" << str << std::endl;
}
void RICSAlg::exp_handle(json &funciton_param, RuleInfo &ruleInfo, int algid) {
switch (algid) {
case 1: {
ruleInfo.exp_str.resize(1);
ruleInfo.exp_str[0] = funciton_param.at("result").at("value").get<string>();
} break;
case 2: {
ruleInfo.exp_str.resize(2);
ruleInfo.exp_str[0] =
funciton_param.at("filter_exp").at("value").get<string>();
ruleInfo.exp_str[1] = funciton_param.at("result").at("value").get<string>();
ruleInfo.limit_down = funciton_param.at("result")
.at("param")
.at("limit_down")
.at("value")
.get<string>();
ruleInfo.limit_up = funciton_param.at("result")
.at("param")
.at("limit_up")
.at("value")
.get<string>();
if (funciton_param.at("result").at("param").contains("unit")) {
ruleInfo.unit = funciton_param.at("result")
.at("param")
.at("unit")
.at("value")
.get<string>();
}
} break;
case 3: {
ruleInfo.exp_str.resize(3);
ruleInfo.exp_str[0] =
funciton_param.at("action_start").at("value").get<string>();
ruleInfo.exp_str[1] =
funciton_param.at("action_end").at("value").get<string>();
ruleInfo.exp_str[2] = funciton_param.at("result").at("value").get<string>();
ruleInfo.params.resize(2);
ruleInfo.params[0] = funciton_param.at("action_start")
.at("param")
.at("hold")
.at("value")
.get<string>();
ruleInfo.params[1] = funciton_param.at("action_end")
.at("param")
.at("timeout")
.at("value")
.get<string>();
} break;
case 4: {
ruleInfo.exp_str.resize(3);
ruleInfo.exp_str[0] =
funciton_param.at("action_start").at("value").get<string>();
ruleInfo.exp_str[1] =
funciton_param.at("action_end").at("value").get<string>();
ruleInfo.exp_str[2] = funciton_param.at("result").at("value").get<string>();
ruleInfo.params.resize(2);
ruleInfo.params[0] = funciton_param.at("action_start")
.at("param")
.at("hold")
.at("value")
.get<string>();
ruleInfo.params[1] = funciton_param.at("action_end")
.at("param")
.at("timeout")
.at("value")
.get<string>();
ruleInfo.limit_down = funciton_param.at("result")
.at("param")
.at("limit_down")
.at("value")
.get<string>();
ruleInfo.limit_up = funciton_param.at("result")
.at("param")
.at("limit_up")
.at("value")
.get<string>();
if (funciton_param.at("result").at("param").contains("unit")) {
ruleInfo.unit = funciton_param.at("result")
.at("param")
.at("unit")
.at("value")
.get<string>();
}
} break;
case 5: {
ruleInfo.exp_str.resize(2);
ruleInfo.exp_str[0] =
funciton_param.at("filter_exp").at("value").get<string>();
ruleInfo.exp_str[1] = funciton_param.at("result").at("value").get<string>();
ruleInfo.params.resize(1);
ruleInfo.params[0] = funciton_param.at("result")
.at("param")
.at("hold_time")
.at("value")
.get<string>();
ruleInfo.limit_down = funciton_param.at("result")
.at("param")
.at("limit_down")
.at("value")
.get<string>();
ruleInfo.limit_up = funciton_param.at("result")
.at("param")
.at("limit_up")
.at("value")
.get<string>();
if (funciton_param.at("result").at("param").contains("unit")) {
ruleInfo.unit = funciton_param.at("result")
.at("param")
.at("unit")
.at("value")
.get<string>();
}
} break;
case 6: {
ruleInfo.exp_str.resize(1);
ruleInfo.exp_str[0] = funciton_param.at("result").at("value").get<string>();
ruleInfo.params.resize(1);
ruleInfo.params[0] = funciton_param.at("result")
.at("param")
.at("limit_time")
.at("value")
.get<string>();
} break;
case 7: {
ruleInfo.exp_str.resize(1);
ruleInfo.exp_str[0] = funciton_param.at("result").at("value").get<string>();
ruleInfo.params.resize(1);
ruleInfo.params[0] = funciton_param.at("result")
.at("param")
.at("limit_times")
.at("value")
.get<string>();
} break;
case 8: {
ruleInfo.exp_str.resize(1);
ruleInfo.exp_str[0] =
funciton_param.at("limit_error").at("value").get<string>();
ruleInfo.params.resize(4);
ruleInfo.params[0] = funciton_param.at("limit_error")
.at("param")
.at("interval_time")
.at("value")
.get<string>();
ruleInfo.params[1] = funciton_param.at("limit_error")
.at("param")
.at("deltaX")
.at("value")
.get<string>();
ruleInfo.params[2] = funciton_param.at("limit_error")
.at("param")
.at("diff")
.at("value")
.get<string>();
ruleInfo.params[3] = funciton_param.at("limit_error")
.at("param")
.at("CS_AVG_SIZE")
.at("value")
.get<string>();
} break;
case 12: {
ruleInfo.exp_str.resize(3);
ruleInfo.exp_str[0] = funciton_param.at("result").at("value").get<string>();
ruleInfo.exp_str[1] =
funciton_param.at("sample_X").at("value").get<string>();
ruleInfo.exp_str[2] =
funciton_param.at("sample_Y").at("value").get<string>();
ruleInfo.params.resize(1);
ruleInfo.params[0] = funciton_param.at("sample_Y")
.at("param")
.at("scale")
.at("value")
.get<string>();
} break;
case 13: {
ruleInfo.exp_str.resize(3);
ruleInfo.exp_str[0] = funciton_param.at("result").at("value").get<string>();
ruleInfo.exp_str[1] =
funciton_param.at("sample_X").at("value").get<string>();
ruleInfo.exp_str[2] =
funciton_param.at("sample_Y").at("value").get<string>();
ruleInfo.params.resize(2);
ruleInfo.params[0] = funciton_param.at("sample_Y")
.at("param")
.at("scale")
.at("value")
.get<string>();
ruleInfo.params[1] = funciton_param.at("sample_Y")
.at("param")
.at("min_len")
.at("value")
.get<string>();
} break;
case 14: {
ruleInfo.exp_str.resize(1);
ruleInfo.exp_str[0] =
funciton_param.at("limit_error").at("value").get<string>();
ruleInfo.params.resize(4);
ruleInfo.params[0] = funciton_param.at("limit_error")
.at("param")
.at("interval_time")
.at("value")
.get<string>();
ruleInfo.params[1] = funciton_param.at("limit_error")
.at("param")
.at("deltaX")
.at("value")
.get<string>();
ruleInfo.params[2] = funciton_param.at("limit_error")
.at("param")
.at("diff")
.at("value")
.get<string>();
ruleInfo.params[3] = funciton_param.at("limit_error")
.at("param")
.at("CS_AVG_SIZE")
.at("value")
.get<string>();
} break;
case 15: {
ruleInfo.exp_str.resize(1);
ruleInfo.exp_str[0] = funciton_param.at("dataX").at("value").get<string>();
ruleInfo.params.resize(1);
ruleInfo.params[0] = funciton_param.at("dataX")
.at("param")
.at("lenth")
.at("value")
.get<string>();
} break;
case 16:
case 18: {
ruleInfo.exp_str.resize(2);
ruleInfo.exp_str[0] =
funciton_param.at("pre_exp").at("value").get<string>();
ruleInfo.exp_str[1] = funciton_param.at("input").at("value").get<string>();
ruleInfo.params.resize(4);
if (funciton_param.at("input").at("param").contains("unit")) {
ruleInfo.unit = funciton_param.at("input")
.at("param")
.at("unit")
.at("value")
.get<string>();
}
ruleInfo.params[0] = funciton_param.at("input")
.at("param")
.at("detect_mode")
.at("value")
.get<string>();
ruleInfo.params[1] = funciton_param.at("input")
.at("param")
.at("limit_warn")
.at("value")
.get<string>();
ruleInfo.params[2] = funciton_param.at("input")
.at("param")
.at("limit_error")
.at("value")
.get<string>();
if (funciton_param.at("input").at("param").contains("hold_time")) {
ruleInfo.params[3] = funciton_param.at("input")
.at("param")
.at("hold_time")
.at("value")
.get<string>();
} else {
ruleInfo.params[3] = "0";
}
} break;
case 17: {
ruleInfo.exp_str.resize(2);
ruleInfo.exp_str[0] =
funciton_param.at("filter_exp").at("value").get<string>();
ruleInfo.exp_str[1] = funciton_param.at("result").at("value").get<string>();
ruleInfo.params.resize(3);
if (funciton_param.at("result").at("param").contains("unit")) {
ruleInfo.unit = funciton_param.at("result")
.at("param")
.at("unit")
.at("value")
.get<string>();
}
ruleInfo.params[0] = funciton_param.at("result")
.at("param")
.at("limit_warn")
.at("value")
.get<string>();
ruleInfo.params[1] = funciton_param.at("result")
.at("param")
.at("limit_error")
.at("value")
.get<string>();
} break;
default:
logger_->Debug() << "algid:" << algid << " error!" << std::endl;
break;
}
}
string RICSAlg::get_json_by_algid(int algid) {
nlohmann::json js1;
vector<string> columns_name{
"规则名称", "设备id", "规则分组", "规则描述",
"报警原因", "报警内容", "前置条件", "执行前置条件表达式",
};
vector<vector<string>> data;
const auto &algRuleIfo = alg_rule_info_[algid];
for (int i = 0; i < 8; i++) {
vector<string> coli_data;
for (auto &item : algRuleIfo) {
coli_data.push_back(item.second.get_value(i));
}
data.push_back(coli_data);
}
switch (algid) {
case 1: {
columns_name.push_back("报警条件表达式");
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
coli_data.push_back(item.second.exp_str[0]);
}
data.push_back(coli_data);
} break;
case 2: {
columns_name.push_back("数据筛选表达式");
columns_name.push_back("监控变量表达式");
columns_name.push_back("单位");
columns_name.push_back("下限");
columns_name.push_back("上限");
for (int i = 0; i < 5; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 2) {
coli_data.push_back(item.second.exp_str[i]);
} else if (i == 2) {
coli_data.push_back(item.second.unit);
} else if (i == 3) {
coli_data.push_back(item.second.limit_down);
} else {
coli_data.push_back(item.second.limit_up);
}
}
data.push_back(coli_data);
}
} break;
case 3: {
columns_name.push_back("动作表达式");
columns_name.push_back("反馈表达式");
columns_name.push_back("监控变量表达式");
columns_name.push_back("是否保持");
columns_name.push_back("超时时间");
for (int i = 0; i < 5; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 3) {
coli_data.push_back(item.second.exp_str[i]);
} else {
coli_data.push_back(item.second.params[i - 3]);
}
}
data.push_back(coli_data);
}
} break;
case 4: {
columns_name.push_back("动作表达式");
columns_name.push_back("反馈表达式");
columns_name.push_back("监控变量条件表达式");
columns_name.push_back("是否保持");
columns_name.push_back("超时时间");
columns_name.push_back("单位");
columns_name.push_back("下限");
columns_name.push_back("上限");
for (int i = 0; i < 8; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 3) {
coli_data.push_back(item.second.exp_str[i]);
} else if (i == 3) {
coli_data.push_back(item.second.params[0]);
} else if (i == 4) {
coli_data.push_back(item.second.params[1]);
} else if (i == 5) {
coli_data.push_back(item.second.unit);
} else if (i == 6) {
coli_data.push_back(item.second.limit_down);
} else {
coli_data.push_back(item.second.limit_up);
}
}
data.push_back(coli_data);
}
} break;
case 5: {
columns_name.push_back("数据筛选表达式");
columns_name.push_back("监控变量表达式");
columns_name.push_back("单位");
columns_name.push_back("下限");
columns_name.push_back("上限");
columns_name.push_back("持续时间[ms]");
for (int i = 0; i < 6; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 2) {
coli_data.push_back(item.second.exp_str[i]);
} else if (i == 2) {
coli_data.push_back(item.second.unit);
} else if (i == 3) {
coli_data.push_back(item.second.limit_down);
} else if (i == 4) {
coli_data.push_back(item.second.limit_up);
} else {
coli_data.push_back(item.second.params[0]);
}
}
data.push_back(coli_data);
}
} break;
case 6: {
columns_name.push_back("检测条件表达式");
columns_name.push_back("最大保持时间[小时]");
for (int i = 0; i < 2; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i == 0) {
coli_data.push_back(item.second.exp_str[0]);
} else {
coli_data.push_back(item.second.params[0]);
}
}
data.push_back(coli_data);
}
} break;
case 7: {
columns_name.push_back("检测条件表达式");
columns_name.push_back("最大出现次数");
for (int i = 0; i < 2; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i == 0) {
coli_data.push_back(item.second.exp_str[0]);
} else {
coli_data.push_back(item.second.params[0]);
}
}
data.push_back(coli_data);
}
} break;
case 8: {
columns_name.push_back("报警条件表达式");
columns_name.push_back("查询均值时间[s]");
columns_name.push_back("单位时间间隔[min]");
columns_name.push_back("监控量斜率（减少为用负值）");
columns_name.push_back("连续出现的次数");
for (int i = 0; i < 5; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i == 0) {
coli_data.push_back(item.second.exp_str[0]);
} else {
coli_data.push_back(item.second.params[i - 1]);
}
}
data.push_back(coli_data);
}
} break;
case 12: {
columns_name.push_back("筛选条件表达式");
columns_name.push_back("X表达式");
columns_name.push_back("Y表达式");
columns_name.push_back("数据误差比(0~1)");
for (int i = 0; i < 4; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 3) {
coli_data.push_back(item.second.exp_str[i]);
} else {
coli_data.push_back(item.second.params[0]);
}
}
data.push_back(coli_data);
}
} break;
case 13: {
columns_name.push_back("筛选条件表达式");
columns_name.push_back("X表达式");
columns_name.push_back("Y表达式");
columns_name.push_back("数据误差比(0~1)");
columns_name.push_back("相关性计算数据最小长度");
for (int i = 0; i < 5; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 3) {
coli_data.push_back(item.second.exp_str[i]);
} else {
coli_data.push_back(item.second.params[i - 3]);
}
}
data.push_back(coli_data);
}
} break;
case 14: {
columns_name.push_back("报警条件表达式");
columns_name.push_back("查询均值时间[s]");
columns_name.push_back("单位时间间隔[min]");
columns_name.push_back("监控量变化率[%]（减少为用负值）");
columns_name.push_back("连续出现的次数");
for (int i = 0; i < 5; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i == 0) {
coli_data.push_back(item.second.exp_str[0]);
} else {
coli_data.push_back(item.second.params[i - 1]);
}
}
data.push_back(coli_data);
}
} break;
case 15: {
columns_name.push_back("监控变量表达式");
columns_name.push_back("监测窗数据量[100,1000]");
for (int i = 0; i < 2; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i == 0) {
coli_data.push_back(item.second.exp_str[0]);
} else {
coli_data.push_back(item.second.params[0]);
}
}
data.push_back(coli_data);
}
} break;
case 16: {
columns_name.push_back("前提条件表达式");
columns_name.push_back("多变量求和表达式");
columns_name.push_back("单位");
columns_name.push_back("检测模式");
columns_name.push_back("超时警告：离群变量超均值百分比");
columns_name.push_back("报警：离群变量超均值百分比");
columns_name.push_back("持续时间[ms]");
for (int i = 0; i < 7; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 2) {
coli_data.push_back(item.second.exp_str[i]);
} else if (i == 2) {
coli_data.push_back(item.second.unit);
} else {
coli_data.push_back(item.second.params[i - 3]);
}
}
data.push_back(coli_data);
}
} break;
case 17: {
columns_name.push_back("数据筛选表达式");
columns_name.push_back("超限结果表达式");
columns_name.push_back("单位");
columns_name.push_back("警告:限幅");
columns_name.push_back("报警:限幅");
for (int i = 0; i < 5; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 2) {
coli_data.push_back(item.second.exp_str[i]);
} else if (i == 2) {
coli_data.push_back(item.second.unit);
} else {
coli_data.push_back(item.second.params[i - 3]);
}
}
data.push_back(coli_data);
}
} break;
case 18: {
columns_name.push_back("前提条件表达式");
columns_name.push_back("多变量求和表达式");
columns_name.push_back("单位");
columns_name.push_back("检测模式");
columns_name.push_back("超时警告：离群变量超均值");
columns_name.push_back("报警：离群变量超均值");
columns_name.push_back("持续时间[ms]");
for (int i = 0; i < 7; i++) {
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
if (i < 2) {
coli_data.push_back(item.second.exp_str[i]);
} else if (i == 2) {
coli_data.push_back(item.second.unit);
} else {
coli_data.push_back(item.second.params[i - 3]);
}
}
data.push_back(coli_data);
}
} break;
default:
logger_->Debug() << "algid:" << algid << " error!" << std::endl;
break;
}
const int tagMaxNum = alg_2_tagMax[algid];
for (int i = 0; i < tagMaxNum; i++) {
string tagi = "tag" + std::to_string(i + 1);
columns_name.push_back(tagi);
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
coli_data.push_back(item.second.tags_item_get(i));
}
data.push_back(coli_data);
}
for (int i = 0; i < tagMaxNum; i++) {
string tagi = "tag" + std::to_string(i + 1) + "中文";
columns_name.push_back(tagi);
vector<string> coli_data;
for (const auto &item : algRuleIfo) {
coli_data.push_back(item.second.tags_chinese_get(i));
}
data.push_back(coli_data);
}
js1["columns"] = columns_name;
js1["data"] = data;
return js1.dump();
}
bool RICSAlg::write_memcaced(string jkey, string jvalue) {
auto reSult = m_memclient.Insert(jkey.c_str(), jvalue.c_str());
if (1 != reSult) {
this->logger_->Debug()
<< "update_eqp_status()"
<< "m_memclient.Insert异常[0,set data fail;-1,key=null or value=null]："
<< reSult << std::endl;
return false;
}
return true;
}
Reference in New Issue Copy Permalink