使用层次分析法处理专家数据

QFD/common/DataEvaluator.cpp

@@ -6,11 +6,13 @@
 
 #include "algorithm/EntropyWeights.h"
 #include "algorithm/PCA.h"
+#include "algorithm/HierarchicalAnalysis.h"
 
 #include <dbService/ClassSet.h>
 #include <dbService/NodeMatrixService.h>
 #include <dbService/CNodeDataService.h>
 #include <dbService/SchemeProcessService.h>
+#include <dbService/UserConfigService.h>
 
 #include <QMap>
 #include <QDebug>
@@ -64,14 +66,62 @@ bool DataEvaluator::evaluate()
 
 bool DataEvaluator::evaluateWeightFromExpert()
 {
-    return false;
+    QMap<QString, QMap<QString, NodeMatrixInfo *>> nodeData;
+    bool dataRet = getNodeData(nodeData);
+
+    /// 权重分析专家导入数据, 使用层次分析法
+    SchemePlanManager::Algorithm algorithm = SchemePlanManager::AHP;
+
+    /// 获取指标体系
+    QList<CNodeData> nodeList;
+    bool mindRet = CNodeDataService().QueryAll(nodeList, m_process.projectId, m_process.indexType);
+    CMind *mind  = new CMind(this);
+    mind->setNodeList(nodeList);
+
+    /// 获取专家配置
+    QMap<QString, double> config;
+    bool cfgRet = getUserConfig(config);
+
+    if (!(dataRet && mindRet && cfgRet)) {
+        return false;
+    }
+
+    QMap<QString, QMap<QString, double>> allWeights;
+
+    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);
+                QStringList matrixStr;
+                QVector<qreal> nxnValus(subNodes.size(), 0.0001);  // n x n矩阵
+                for (int j = 0; j < subNodes.size(); j++) {
+                    QString abs = subNodes[j].name;
+                    matrixStr.append(abs);
+                    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(matrixStr, nxnValus));
+                QVector<qreal> weights = ha->getWeights();
+                qDebug() << __FUNCTION__ << __LINE__ << expertId << matrixStr << weights << endl;
+            }
+        }
+    }
+
+    return true;
 }
 
 bool DataEvaluator::evaluateWeightFromMeasure()
 {
-    /// 获取权重分析数据
-    /// 整理数据, 使用 uuid 将数据分组, 使用指标名称索引
-
     QMap<QString, QMap<QString, NodeMatrixInfo *>> nodeData;
     bool dataRet = getNodeData(nodeData);
 
@@ -81,8 +131,7 @@ bool DataEvaluator::evaluateWeightFromMeasure()
     /// 获取指标体系
     QList<CNodeData> nodeList;
     bool mindRet = CNodeDataService().QueryAll(nodeList, m_process.projectId, m_process.indexType);
-
-    CMind *mind = new CMind(this);
+    CMind *mind  = new CMind(this);
     mind->setNodeList(nodeList);
 
     if (!(dataRet && algRet && mindRet)) {
@@ -100,7 +149,6 @@ bool DataEvaluator::evaluateWeightFromMeasure()
                 QList<CNodeData> subNodes = mind->subNodes(node);
                 EntropyMat mat;
                 for (int j = 0; j < subNodes.size(); j++) {
-
                     QVector<double> values;
                     for (QString uuid : nodeData.keys()) {
                         NodeMatrixInfo *info = nodeData[uuid][subNodes[j].name];
@@ -222,10 +270,15 @@ bool DataEvaluator::getNodeData(QMap<QString, QMap<QString, NodeMatrixInfo *>> &
         return false;
     }
     for (NodeMatrixInfo *info : dataList) {
-        if (nodeData.keys().contains(info->strUuid) == false) {
-            nodeData[info->strUuid] = QMap<QString, NodeMatrixInfo *>();
+        QString key = info->strUuid;  // 实测数据的 key
+        if (m_process.dSource == SchemePlanManager::FromExpert) {
+            key = info->expertId;  // 专家数据的 key
         }
-        nodeData[info->strUuid][nodeDataKey(info)] = info;
+
+        if (nodeData.keys().contains(key) == false) {
+            nodeData[key] = QMap<QString, NodeMatrixInfo *>();
+        }
+        nodeData[key][nodeDataKey(info)] = info;
     }
     return true;
 }
@@ -244,6 +297,30 @@ bool DataEvaluator::getAlgorithm(SchemePlanManager::Algorithm &algorithm) const
             break;
         }
     }
+
+    if (m_process.type == SchemePlanManager::ImportWeightData) {
+        if (m_process.dSource == SchemePlanManager::FromMeasurement && algorithm == SchemePlanManager::AHP) {
+            algorithm == SchemePlanManager::Entropy;
+        }
+        if (m_process.dSource == SchemePlanManager::FromExpert) {
+            algorithm == SchemePlanManager::AHP;
+        }
+    }
+
+    return true;
+}
+
+bool DataEvaluator::getUserConfig(QMap<QString, double> &cfg) const
+{
+    QList<UserConfig *> userCfgList;
+    bool ret = UserConfigService().QueryUserConfigListInfoByEngineerId(&userCfgList, m_process.projectId);
+    if (ret == false) {
+        return false;
+    }
+
+    for (UserConfig *config : userCfgList) {
+        cfg[QString("%1").arg(config->userId)] = config->weight;
+    }
     return true;
 }
 

QFD/common/DataEvaluator.h

@@ -49,6 +49,9 @@ private:
     /// 获取算法
     bool getAlgorithm(SchemePlanManager::Algorithm &algorithm) const;
 
+    /// 获取专家配置
+    bool getUserConfig(QMap<QString, double> &cfg) const;
+
     /// 使用横坐标和纵坐标构造索引
     QString nodeDataKey(NodeMatrixInfo *data) const;