存储权重值

QFD/common/DataEvaluator.cpp

@@ -13,6 +13,7 @@
 #include <dbService/CNodeDataService.h>
 #include <dbService/SchemeProcessService.h>
 #include <dbService/UserConfigService.h>
+#include <dbService/MindWeightService.h>
 
 #include <QMap>
 #include <QDebug>
@@ -86,9 +87,84 @@ bool DataEvaluator::evaluateWeightFromExpert()
         return false;
     }
 
-    QMap<QString, QMap<QString, double>> allWeights;
+    QMap<QString, double> indexWeights;
 
-    for (QString expertId : nodeData.keys()) {
+    // 结果集结, 先计算各个专家的数据, 再取均值
+    if (m_gatherType == Result) {
+        QMap<QString, QMap<QString, double>> mWeights;
+
+        for (QString expertId : nodeData.keys()) {
+            for (int i = 1; i < mind->levels(); i++) {
+                for (CNodeData node : mind->nodesInLevel(i)) {
+                    QList<CNodeData> subNodes = mind->subNodes(node);
+                    QVector<qreal> nxnValus;  // n x n矩阵
+                    for (int j = 0; j < subNodes.size(); j++) {
+                        QString abs = subNodes[j].name;
+                        for (int k = 0; k < subNodes.size(); k++) {
+                            QString ord = subNodes[k].name;
+                            QString key = abs + "-" + ord;
+                            double v;
+                            QStringList nodeValue = nodeData[expertId][key]->nodeValue.split("/");
+                            if (nodeValue.size() == 1) {
+                                v = nodeValue[0].toDouble();
+                            } else {
+                                v = nodeValue[0].toDouble() / nodeValue[1].toDouble();
+                            }
+                            nxnValus.append(v);
+                        }
+                    }
+
+                    // 计算权重并存储
+                    QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(subNodes.size(), nxnValus));
+                    QVector<qreal> weights = ha->getWeights();
+
+                    for (int l = 0; l < weights.size(); ++l) {
+                        if (mWeights.keys().contains(expertId) == false) {
+                            mWeights[expertId] = QMap<QString, double>();
+                        }
+                        CNodeData pNode = mind->node(subNodes[l].pNumber);
+                        if (mWeights[expertId].keys().contains(pNode.name)) {
+                            mWeights[expertId][subNodes[l].name] = mWeights[expertId][pNode.name] * weights[l];
+                        } else {
+                            mWeights[expertId][subNodes[l].name] = weights[l];
+                        }
+                    }
+                }
+            }
+        }
+
+        // 求平均权重
+        for (int i = 1; i < mind->levels(); i++) {
+            for (CNodeData node : mind->nodesInLevel(i)) {
+                QList<CNodeData> subNodes = mind->subNodes(node);
+                for (int j = 0; j < subNodes.size(); j++) {
+                    double sum = 0;
+                    for (QString expertId : nodeData.keys()) {
+                        sum += mWeights[expertId][subNodes[j].name];
+                    }
+                    indexWeights[subNodes[j].name] = sum / nodeData.keys().size();
+                }
+            }
+        }
+    } else {  // 矩阵集结, 先计算各个专家数据的均值, 在求权重
+        // 求专家数据均值
+        QMap<QString, double> avgNodeValue;
+        for (QString key : nodeData.values().first().keys()) {
+            double sum = 0;
+            for (QString expertId : nodeData.keys()) {
+                double v;
+                QStringList nodeValue = nodeData[expertId][key]->nodeValue.split("/");
+                if (nodeValue.size() == 1) {
+                    v = nodeValue[0].toDouble();
+                } else {
+                    v = nodeValue[0].toDouble() / nodeValue[1].toDouble();
+                }
+                sum += v;
+            }
+            avgNodeValue[key] = sum / nodeData.keys().size();
+        }
+
+        // 求权重
         for (int i = 1; i < mind->levels(); i++) {
             for (CNodeData node : mind->nodesInLevel(i)) {
                 QList<CNodeData> subNodes = mind->subNodes(node);
@@ -98,24 +174,37 @@ bool DataEvaluator::evaluateWeightFromExpert()
                     for (int k = 0; k < subNodes.size(); k++) {
                         QString ord = subNodes[k].name;
                         QString key = abs + "-" + ord;
-                        double v;
-                        QStringList nodeValue = nodeData[expertId][key]->nodeValue.split("/");
-                        if (nodeValue.size() == 1) {
-                            v = nodeValue[0].toDouble();
-                        } else {
-                            v = nodeValue[0].toDouble() / nodeValue[1].toDouble();
-                        }
-                        nxnValus.append(v);
+                        nxnValus.append(avgNodeValue[key]);
                     }
                 }
+
+                // 计算权重并存储
                 QScopedPointer<HierarchicalAnalysis> ha(new HierarchicalAnalysis(subNodes.size(), nxnValus));
                 QVector<qreal> weights = ha->getWeights();
-                qDebug() << __FUNCTION__ << __LINE__ << expertId << nxnValus << weights << endl;
+
+                for (int l = 0; l < weights.size(); ++l) {
+                    CNodeData pNode = mind->node(subNodes[l].pNumber);
+                    if (indexWeights.keys().contains(pNode.name)) {
+                        indexWeights[subNodes[l].name] = indexWeights[pNode.name] * weights[l];
+                    } else {
+                        indexWeights[subNodes[l].name] = weights[l];
+                    }
+                }
             }
         }
     }
 
-    return true;
+    QStringList valueList;
+    for (QString key : indexWeights.keys()) {
+        valueList.append(QString("%1:%2").arg(key).arg(indexWeights[key]));
+    }
+    QString valueStr = valueList.join(";");
+
+    bool ret = MindWeightService().saveUniqueWeightData(m_process.projectId, m_process.indexType, m_process.dSource,
+                                                        algorithm, valueStr);
+
+    qDebug() << __FUNCTION__ << __LINE__ << ret << valueStr << endl;
+    return ret;
 }
 
 bool DataEvaluator::evaluateWeightFromMeasure()

QFD/dbService/MindWeightService.cpp

@@ -46,8 +46,8 @@ bool MindWeightService::queryWeightData(MindWeightInfo *info, int projId, int in
             info->id         = queryResult.value(0).toInt();
             info->projectId  = queryResult.value(1).toInt();
             info->indexType  = queryResult.value(2).toInt();
-            info->dataSource = queryResult.value(3).toDouble();
-            info->algorithm  = queryResult.value(4).toString();
+            info->dataSource = queryResult.value(3).toInt();
+            info->algorithm  = queryResult.value(4).toInt();
             info->weight     = queryResult.value(5).toString();
         }
         ret = true;

QFD/dbService/MindWeightService.h

@@ -33,6 +33,8 @@ public:
     /// \return 成功 or 失败
     bool updateWeightData(int id, const QString &weight);
 
+    bool deleteWeightData(int id);
+
 private:
     /// 保存权重数据
     bool saveWeightData(MindWeightInfo *info);

QFD/widgets/DataCollectionWidget.cpp

@@ -215,45 +215,10 @@ void DataCollectionWidget::slotCalc()
         QString dataSource  = SchemePlanManager::stringFromDataSource(table->process().dSource);
         qDebug() << __FUNCTION__ << __LINE__ << indexName << processName << dataSource << endl;
 
+        /// 运行评估算法
         m_evaluator->setProcess(table->process());
         m_evaluator->setGatherType((DataEvaluator::GatherType)m_comboBox->currentIndex());
         m_evaluator->evaluate();
-
-        QTableView *tableView     = (QTableView *)table->tabWidget()->currentWidget();
-        DataTableItemModel *model = (DataTableItemModel *)tableView->model();
-
-        int schemeStart = -1;  // 表中方案数据开始列
-        if (table->process().indexType == ProjectManager::OptimalIndex) {
-            schemeStart = 2;
-        } else if (table->process().indexType == ProjectManager::EfficiencyIndex) {
-            schemeStart = 1;
-        }
-        qDebug() << schemeStart;
-        /// 存储方案数据
-        /// @attention 缺少数据库更新接口
-        if (model->columnCount() > schemeStart && schemeStart > 0) {
-            QList<SchemaEval *> schemeList = m_configScheme->schemeList();
-            for (SchemaEval *scheme : schemeList) {
-                for (int i = schemeStart; i < model->columnCount(); i++) {
-                    QStandardItem *hHeader = model->horizontalHeaderItem(i);
-                    if (hHeader->text() != scheme->name) {
-                        continue;
-                    }
-                    QStringList list;
-                    for (int j = 0; j < model->rowCount(); j++) {
-                        QStandardItem *vHeader = model->verticalHeaderItem(j);
-                        QStandardItem *item    = model->item(j, i);
-                        if (item != nullptr && item->text().trimmed().length() > 0) {
-                            QString value = QString("%1:%2").arg(vHeader->text()).arg(item->text());
-                            list.append(value);
-                        }
-                    }
-                    QString str      = list.join(";");
-                    scheme->valueStr = str;
-                    qDebug() << scheme->id << scheme->name << str;
-                }
-            }
-        }
     }
 
     GreyClusteringSampleTable *gcSample = dynamic_cast<GreyClusteringSampleTable *>(m_tab->currentWidget());