Exemple #1
0
        /// <summary>
        /// 对数据进行评分加权赋值等操作
        /// </summary>
        /// <param name="list_AvBlk"></param>
        /// <returns></returns>
        #region
        public List <SortedBlocksParas> BlockGrade(List <AverageValuesBlockEntity> list_AvBlk)
        {
            //定义模糊隶属函数的实例
            FuzzyMembershipFunction  fMf      = new FuzzyMembershipFunction();
            SubjectiveGrading        sG       = new SubjectiveGrading();
            List <SortedBlocksParas> list_Sbp = new List <SortedBlocksParas>();

            //定义赋值分数变量
            double gradeScore;

            //定义SortedBlocksParas Entity类变量

            SortedBlocksParas[] tmpSBP = new SortedBlocksParas[list_AvBlk.Count];
            //定义数值变量
            double values;

            for (int i = 0; i < list_AvBlk.Count; i++)
            {
                tmpSBP[i] = new SortedBlocksParas();
                tmpSBP[i].para_TotalScores = 0;
                //区块名称 没有分值
                tmpSBP[i].para_Tgt = list_AvBlk[i].tgt_Att_Name;

                //盆地/区域名称 没有分值
                tmpSBP[i].para_Bsn = list_AvBlk[i].bsn_Att_Name;

                //主力层系 分值
                tmpSBP[i].para_Ps = list_AvBlk[i].blk_Att_Ps;
                //tmpSBP[i].para_PsScores = sG.Grade(list_AvBlk[i].blk_Att_Ps);
                //tmpSBP[i].para_TotalScores += tmpSBP[i].para_PsScores;

                //保存条件 分值
                tmpSBP[i].para_Sc = list_AvBlk[i].blk_Att_Para_Sc;
                //tmpSBP[i].para_ScScores = fMf.FuzzyRankScore(list_AvBlk[i].blk_Att_Para_Sc);
                //tmpSBP[i].para_TotalScores += tmpSBP[i].para_ScScores;

                //地质资源量 (赋值标准没有制定)
                tmpSBP[i].para_Gr = list_AvBlk[i].blk_Att_Para_Gr;
                //tmpSBP[i].para_GrScores = 0;
                //tmpSBP[i].para_TotalScores += tmpSBP[i].para_GrScores;

                //地质条件

                #region
                //对富含有机质页岩厚度的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Geo_Para_TrRoms.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("页岩厚度(m)"))
                {
                    values                       = Convert.ToDouble(list_AvBlk[i].blk_Geo_Para_TrRoms);
                    gradeScore                   = fMf.FuzzyLarge(1.6, 15, values);
                    tmpSBP[i].para_StromAt       = list_AvBlk[i].blk_Geo_Para_TrRoms;
                    tmpSBP[i].para_StromAtScores = gradeScore;
                    tmpSBP[i].para_StromAtWeight = wgt_StromAt;
                    tmpSBP[i].para_TotalScores  += tmpSBP[i].para_StromAtScores * tmpSBP[i].para_StromAtWeight;
                }
                else
                {
                    tmpSBP[i].para_StromAt       = list_AvBlk[i].blk_Geo_Para_TrRoms;
                    tmpSBP[i].para_StromAtScores = 0;
                    tmpSBP[i].para_StromAtWeight = wgt_StromAt;
                    tmpSBP[i].para_TotalScores  += 0;
                }

                //对Toc 的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Geo_Para_Toc.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("含量TOC(%)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Geo_Para_Toc);
                    gradeScore                  = fMf.FuzzyLarge(1.6, 2, values);
                    tmpSBP[i].para_Toc          = list_AvBlk[i].blk_Geo_Para_Toc;
                    tmpSBP[i].para_TocScores    = gradeScore;
                    tmpSBP[i].para_TocWeight    = wgt_Toc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_TocScores * tmpSBP[i].para_TocWeight;
                }
                else
                {
                    tmpSBP[i].para_Toc          = list_AvBlk[i].blk_Geo_Para_Toc;
                    tmpSBP[i].para_TocScores    = 0;
                    tmpSBP[i].para_TocWeight    = wgt_Toc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对干酪根类型求值 干酪根类型没有赋值函数,没有完成该函数的条件
                if (list_AvBlk[i].blk_Geo_Para_Kt.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("干酪根类型"))
                {
                    string val = list_AvBlk[i].blk_Geo_Para_Kt;
                    gradeScore                  = fMf.ToAssignForKerogenType(val);
                    tmpSBP[i].para_Kt           = list_AvBlk[i].blk_Geo_Para_Kt;
                    tmpSBP[i].para_KtScores     = gradeScore;
                    tmpSBP[i].para_KtWeight     = wgt_Kt;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_KtScores * tmpSBP[i].para_KtWeight;
                }
                else
                {
                    tmpSBP[i].para_Kt           = list_AvBlk[i].blk_Geo_Para_Kt;
                    tmpSBP[i].para_KtScores     = 0;
                    tmpSBP[i].para_KtWeight     = wgt_Kt;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Ro 的平均值进行高斯型隶属函数求值
                if (list_AvBlk[i].blk_Geo_Para_Ro.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("成熟度Ro(%)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Geo_Para_Ro);
                    gradeScore                  = fMf.FuzzyGussian(values);
                    tmpSBP[i].para_Ro           = list_AvBlk[i].blk_Geo_Para_Ro;
                    tmpSBP[i].para_RoScores     = gradeScore;
                    tmpSBP[i].para_RoWeight     = wgt_Ro;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_RoScores * tmpSBP[i].para_RoWeight;
                }
                else
                {
                    tmpSBP[i].para_Ro           = list_AvBlk[i].blk_Geo_Para_Ro;
                    tmpSBP[i].para_RoScores     = 0;
                    tmpSBP[i].para_RoWeight     = wgt_Ro;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Ea 的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Geo_Para_Ea.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("圈定面积(km^2)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Geo_Para_Ea);
                    gradeScore                  = fMf.FuzzyLarge(1.2, 200, values);
                    tmpSBP[i].para_Ea           = list_AvBlk[i].blk_Geo_Para_Ea;
                    tmpSBP[i].para_EaScores     = gradeScore;
                    tmpSBP[i].para_EaWeight     = wgt_Ea;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_EaScores * tmpSBP[i].para_EaWeight;
                }
                else
                {
                    tmpSBP[i].para_Ea           = list_AvBlk[i].blk_Geo_Para_Ea;
                    tmpSBP[i].para_EaScores     = 0;
                    tmpSBP[i].para_EaWeight     = wgt_Ea;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Gc 的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Geo_Para_Gc.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("含气量(m^3/t)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Geo_Para_Gc.Trim());
                    gradeScore                  = fMf.FuzzyLarge(1.6, 2, values);
                    tmpSBP[i].para_Gc           = list_AvBlk[i].blk_Geo_Para_Gc.Trim();
                    tmpSBP[i].para_GcScores     = gradeScore;
                    tmpSBP[i].para_GcWeight     = wgt_Gc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_GcScores * tmpSBP[i].para_GcWeight;
                }
                else
                {
                    tmpSBP[i].para_Gc           = list_AvBlk[i].blk_Geo_Para_Gc.Trim();
                    tmpSBP[i].para_GcScores     = 0;
                    tmpSBP[i].para_GcWeight     = wgt_Gc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Rr 的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Geo_Para_Rr.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("丰度(亿方/km^2)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Geo_Para_Rr.Trim());
                    gradeScore                  = fMf.FuzzyLarge(1, 0.5, values);
                    tmpSBP[i].para_Rr           = list_AvBlk[i].blk_Geo_Para_Rr.Trim();
                    tmpSBP[i].para_RrScores     = gradeScore;
                    tmpSBP[i].para_RrWeight     = wgt_Rr;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_RrScores * tmpSBP[i].para_RrWeight;
                }
                else
                {
                    tmpSBP[i].para_Rr           = list_AvBlk[i].blk_Geo_Para_Rr.Trim();
                    tmpSBP[i].para_RrScores     = 0;
                    tmpSBP[i].para_RrWeight     = wgt_Rr;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Por 的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Geo_Para_Por.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("孔隙度(%)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Geo_Para_Por.Trim());
                    gradeScore                  = fMf.FuzzyLarge(1.2, 2, values);
                    tmpSBP[i].para_Por          = list_AvBlk[i].blk_Geo_Para_Por.Trim();
                    tmpSBP[i].para_PorScores    = gradeScore;
                    tmpSBP[i].para_PorWeight    = wgt_Por;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_PorScores * tmpSBP[i].para_PorWeight;
                }
                else
                {
                    tmpSBP[i].para_Por          = list_AvBlk[i].blk_Geo_Para_Por.Trim();
                    tmpSBP[i].para_PorScores    = 0;
                    tmpSBP[i].para_PorWeight    = wgt_Por;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对构造复杂度Scd 求值
                if (list_AvBlk[i].blk_Geo_Para_Scd.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("构造复杂度"))
                {
                    string val = list_AvBlk[i].blk_Geo_Para_Scd.Trim();
                    gradeScore                  = fMf.FuzzyRankScore(val);
                    tmpSBP[i].para_Scd          = list_AvBlk[i].blk_Geo_Para_Scd;
                    tmpSBP[i].para_ScdScores    = gradeScore;
                    tmpSBP[i].para_ScdWeight    = wgt_Scd;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_ScdScores * tmpSBP[i].para_ScdWeight;
                }
                else
                {
                    tmpSBP[i].para_Scd          = list_AvBlk[i].blk_Geo_Para_Scd;
                    tmpSBP[i].para_ScdScores    = 0;
                    tmpSBP[i].para_ScdWeight    = wgt_Scd;
                    tmpSBP[i].para_TotalScores += 0;
                }

                #endregion

                //工程条件
                #region
                //埋深 Dr Depth Range先计算平均值,然后利用高斯型隶属函数赋分
                if (list_AvBlk[i].blk_Eng_Para_Dr.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("埋深(m)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Eng_Para_Dr.Trim());
                    gradeScore                  = fMf.FuzzyGussian(values);
                    tmpSBP[i].para_Dr           = list_AvBlk[i].blk_Eng_Para_Dr.Trim();
                    tmpSBP[i].para_DrScores     = gradeScore;
                    tmpSBP[i].para_DrWeight     = wgt_Dr;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_DrScores * tmpSBP[i].para_DrWeight;
                }
                else
                {
                    tmpSBP[i].para_Dr           = list_AvBlk[i].blk_Eng_Para_Dr.Trim();
                    tmpSBP[i].para_DrScores     = 0;
                    tmpSBP[i].para_DrWeight     = wgt_Dr;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Pc 压力系数 的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Eng_Para_Pc.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("压力系数"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Eng_Para_Pc.Trim());
                    gradeScore                  = fMf.FuzzyLarge(6, 1, values);
                    tmpSBP[i].para_Pc           = list_AvBlk[i].blk_Eng_Para_Pc.Trim();
                    tmpSBP[i].para_PcScores     = gradeScore;
                    tmpSBP[i].para_PcWeight     = wgt_Pc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_PcScores * tmpSBP[i].para_PcWeight;
                }
                else
                {
                    tmpSBP[i].para_Pc           = list_AvBlk[i].blk_Eng_Para_Pc.Trim();
                    tmpSBP[i].para_PcScores     = 0;
                    tmpSBP[i].para_PcWeight     = wgt_Pc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对脆矿 Bmc  的平均值进行增大型隶属函数求值
                if (list_AvBlk[i].blk_Eng_Para_Bmc.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("脆性矿物含量(%)"))
                {
                    values                      = Convert.ToDouble(list_AvBlk[i].blk_Eng_Para_Bmc.Trim());
                    gradeScore                  = fMf.FuzzyLarge(2.15, 30, values);
                    tmpSBP[i].para_Bmc          = list_AvBlk[i].blk_Eng_Para_Bmc.Trim();
                    tmpSBP[i].para_BmcScores    = gradeScore;
                    tmpSBP[i].para_BmcWeight    = wgt_Bmc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_BmcScores * tmpSBP[i].para_BmcWeight;
                }
                else
                {
                    tmpSBP[i].para_Bmc          = list_AvBlk[i].blk_Eng_Para_Bmc.Trim();
                    tmpSBP[i].para_BmcScores    = 0;
                    tmpSBP[i].para_BmcWeight    = wgt_Bmc;
                    tmpSBP[i].para_TotalScores += 0;
                }
                #endregion


                //市场经济条件

                #region
                //地表地貌求值
                if (list_AvBlk[i].blk_Mkt_Para_Sg.Trim() != "" &&
                    lstBx_Selected_EcoPara.Items.Contains("地表地貌"))
                {
                    //values = Convert.ToDouble(list_AvBlk[i].blk_Eng_Para_Pc.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvBlk[i].blk_Eng_Para_Pc.Trim();
                    tmpSBP[i].para_SgScores     = 0;
                    tmpSBP[i].para_SgWeight     = wgt_Sg;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_SgScores * tmpSBP[i].para_SgWeight;
                }
                else
                {
                    tmpSBP[i].para_Sg           = list_AvBlk[i].blk_Mkt_Para_Sg.Trim();
                    tmpSBP[i].para_SgScores     = 0;
                    tmpSBP[i].para_SgWeight     = wgt_Sg;
                    tmpSBP[i].para_TotalScores += 0;
                }
                #endregion
                list_Sbp.Add(tmpSBP[i]);
            }
            return(list_Sbp);
        }
Exemple #2
0
        /// <summary>
        /// 对数据进行评分加权赋值等操作
        /// </summary>
        /// <param name="list_AvTgt"></param>
        /// <returns></returns>
        public List <SortedTargetsParas> BlockGrade(List <AverageValuesTargetEntity> list_AvTgt)
        {
            //定义模糊隶属函数的实例
            FuzzyMembershipFunction   fMf      = new FuzzyMembershipFunction();
            SubjectiveGrading         sG       = new SubjectiveGrading();
            List <SortedTargetsParas> list_Sbp = new List <SortedTargetsParas>();

            //定义赋值分数变量
            double gradeScore;

            //定义SortedBlocksParas Entity类变量

            SortedTargetsParas [] tmpSBP = new SortedTargetsParas[list_AvTgt.Count];
            //定义数值变量
            double values;

            for (int i = 0; i < list_AvTgt.Count; i++)
            {
                tmpSBP[i] = new SortedTargetsParas();
                tmpSBP[i].para_TotalScores = 0;
                //区块名称 没有分值
                tmpSBP[i].para_Tgt = list_AvTgt[i].tgt_Att_Name;

                //盆地/区域名称 没有分值
                tmpSBP[i].para_Bsn = list_AvTgt[i].bsn_Att_Name;

                //主力层系 分值
                tmpSBP[i].para_Ps = list_AvTgt[i].tgt_Att_Ps;
                //tmpSBP[i].para_PsScores = sG.Grade(list_AvTgt[i].tgt_Att_Ps);
                //tmpSBP[i].para_TotalScores += tmpSBP[i].para_PsScores;

                //保存条件 分值
                tmpSBP[i].para_Sc = list_AvTgt[i].tgt_Att_Para_Sc;
                //tmpSBP[i].para_ScScores = fMf.FuzzyRankScore(list_AvTgt[i].tgt_Att_Para_Sc);
                //tmpSBP[i].para_TotalScores += tmpSBP[i].para_ScScores;

                //地质资源量 (赋值标准没有制定)
                tmpSBP[i].para_Gr = list_AvTgt[i].tgt_Att_Para_Gr_Avg;
                //tmpSBP[i].para_GrScores = 0;
                //tmpSBP[i].para_TotalScores += tmpSBP[i].para_GrScores;

                //地质条件

                #region
                //对富含有机质页岩厚度的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Geo_Para_TrRoms_Avg.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("页岩厚度(m)"))
                {
                    values                       = Convert.ToDouble(list_AvTgt[i].tgt_Geo_Para_TrRoms_Avg);
                    gradeScore                   = fMf.FuzzyLarge(1.6, 15, values);
                    tmpSBP[i].para_StromAt       = list_AvTgt[i].tgt_Geo_Para_TrRoms_Avg;
                    tmpSBP[i].para_StromAtScores = gradeScore;
                    tmpSBP[i].para_StromAtWeight = wgt_StromAt;
                    tmpSBP[i].para_TotalScores  += tmpSBP[i].para_StromAtScores * tmpSBP[i].para_StromAtWeight;
                }
                else
                {
                    tmpSBP[i].para_StromAt       = list_AvTgt[i].tgt_Geo_Para_TrRoms_Avg;
                    tmpSBP[i].para_StromAtScores = 0;
                    tmpSBP[i].para_StromAtWeight = wgt_StromAt;
                    tmpSBP[i].para_TotalScores  += 0;
                }

                //对Toc 的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Geo_Para_Toc_Avg.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("含量TOC(%)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Geo_Para_Toc_Avg);
                    gradeScore                  = fMf.FuzzyLarge(1.6, 2, values);
                    tmpSBP[i].para_Toc          = list_AvTgt[i].tgt_Geo_Para_Toc_Avg;
                    tmpSBP[i].para_TocScores    = gradeScore;
                    tmpSBP[i].para_TocWeight    = wgt_Toc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_TocScores * tmpSBP[i].para_TocWeight;
                }
                else
                {
                    tmpSBP[i].para_Toc          = list_AvTgt[i].tgt_Geo_Para_Toc_Avg;
                    tmpSBP[i].para_TocScores    = 0;
                    tmpSBP[i].para_TocWeight    = wgt_Toc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对干酪根类型求值 干酪根类型没有赋值函数,没有完成该函数的条件
                if (list_AvTgt[i].tgt_Geo_Para_Kt.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("干酪根类型"))
                {
                    string val = list_AvTgt[i].tgt_Geo_Para_Kt;
                    gradeScore                  = fMf.ToAssignForKerogenType(val);
                    tmpSBP[i].para_Kt           = list_AvTgt[i].tgt_Geo_Para_Kt;
                    tmpSBP[i].para_KtScores     = gradeScore;
                    tmpSBP[i].para_KtWeight     = wgt_Kt;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_KtScores * tmpSBP[i].para_KtWeight;
                }
                else
                {
                    tmpSBP[i].para_Kt           = list_AvTgt[i].tgt_Geo_Para_Kt;
                    tmpSBP[i].para_KtScores     = 0;
                    tmpSBP[i].para_KtWeight     = wgt_Kt;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Ro 的平均值进行高斯型隶属函数求值
                if (list_AvTgt[i].tgt_Geo_Para_Ro_Avg.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("成熟度Ro(%)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Geo_Para_Ro_Avg);
                    gradeScore                  = fMf.FuzzyGussian(values);
                    tmpSBP[i].para_Ro           = list_AvTgt[i].tgt_Geo_Para_Ro_Avg;
                    tmpSBP[i].para_RoScores     = gradeScore;
                    tmpSBP[i].para_RoWeight     = wgt_Ro;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_RoScores * tmpSBP[i].para_RoWeight;
                }
                else
                {
                    tmpSBP[i].para_Ro           = list_AvTgt[i].tgt_Geo_Para_Ro_Avg;
                    tmpSBP[i].para_RoScores     = 0;
                    tmpSBP[i].para_RoWeight     = wgt_Ro;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Ea 的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Geo_Para_Ea.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("圈定面积(km^2)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Geo_Para_Ea);
                    gradeScore                  = fMf.FuzzyLarge(1.2, 200, values);
                    tmpSBP[i].para_Ea           = list_AvTgt[i].tgt_Geo_Para_Ea;
                    tmpSBP[i].para_EaScores     = gradeScore;
                    tmpSBP[i].para_EaWeight     = wgt_Ea;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_EaScores * tmpSBP[i].para_EaWeight;
                }
                else
                {
                    tmpSBP[i].para_Ea           = list_AvTgt[i].tgt_Geo_Para_Ea;
                    tmpSBP[i].para_EaScores     = 0;
                    tmpSBP[i].para_EaWeight     = wgt_Ea;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Gc 的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Geo_Para_Gc_Avg.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("含气量(m^3/t)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Geo_Para_Gc_Avg.Trim());
                    gradeScore                  = fMf.FuzzyLarge(1.6, 2, values);
                    tmpSBP[i].para_Gc           = list_AvTgt[i].tgt_Geo_Para_Gc_Avg.Trim();
                    tmpSBP[i].para_GcScores     = gradeScore;
                    tmpSBP[i].para_GcWeight     = wgt_Gc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_GcScores * tmpSBP[i].para_GcWeight;
                }
                else
                {
                    tmpSBP[i].para_Gc           = list_AvTgt[i].tgt_Geo_Para_Gc_Avg.Trim();
                    tmpSBP[i].para_GcScores     = 0;
                    tmpSBP[i].para_GcWeight     = wgt_Gc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Rr 的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Geo_Para_Rr_Avg.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("丰度(亿方/km^2)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Geo_Para_Rr_Avg.Trim());
                    gradeScore                  = fMf.FuzzyLarge(1, 0.5, values);
                    tmpSBP[i].para_Rr           = list_AvTgt[i].tgt_Geo_Para_Rr_Avg.Trim();
                    tmpSBP[i].para_RrScores     = gradeScore;
                    tmpSBP[i].para_RrWeight     = wgt_Rr;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_RrScores * tmpSBP[i].para_RrWeight;
                }
                else
                {
                    tmpSBP[i].para_Rr           = list_AvTgt[i].tgt_Geo_Para_Rr_Avg.Trim();
                    tmpSBP[i].para_RrScores     = 0;
                    tmpSBP[i].para_RrWeight     = wgt_Rr;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Por 的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Geo_Para_Por_Avg.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("孔隙度(%)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Geo_Para_Por_Avg.Trim());
                    gradeScore                  = fMf.FuzzyLarge(1.2, 2, values);
                    tmpSBP[i].para_Por          = list_AvTgt[i].tgt_Geo_Para_Por_Avg.Trim();
                    tmpSBP[i].para_PorScores    = gradeScore;
                    tmpSBP[i].para_PorWeight    = wgt_Por;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_PorScores * tmpSBP[i].para_PorWeight;
                }
                else
                {
                    tmpSBP[i].para_Por          = list_AvTgt[i].tgt_Geo_Para_Por_Avg.Trim();
                    tmpSBP[i].para_PorScores    = 0;
                    tmpSBP[i].para_PorWeight    = wgt_Por;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对构造复杂度Scd 求值
                if (list_AvTgt[i].tgt_Geo_Para_Scd.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("构造复杂度"))
                {
                    string val = list_AvTgt[i].tgt_Geo_Para_Scd.Trim();
                    gradeScore                  = fMf.FuzzyRankScore(val);
                    tmpSBP[i].para_Scd          = list_AvTgt[i].tgt_Geo_Para_Scd;
                    tmpSBP[i].para_ScdScores    = gradeScore;
                    tmpSBP[i].para_ScdWeight    = wgt_Scd;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_ScdScores * tmpSBP[i].para_ScdWeight;
                }
                else
                {
                    tmpSBP[i].para_Scd          = list_AvTgt[i].tgt_Geo_Para_Scd;
                    tmpSBP[i].para_ScdScores    = 0;
                    tmpSBP[i].para_ScdWeight    = wgt_Scd;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对顶底板岩性Rfc求值
                if (list_AvTgt[i].tgt_Geo_Para_Rfc.Trim() != "" &&
                    lstBx_Selected_GeoPara.Items.Contains("顶底板岩性"))
                {
                    string val = list_AvTgt[i].tgt_Geo_Para_Rfc.Trim();
                    gradeScore                  = fMf.FuzzyRankScore(val);
                    tmpSBP[i].para_Rfc          = list_AvTgt[i].tgt_Geo_Para_Rfc;
                    tmpSBP[i].para_RfcScores    = gradeScore;
                    tmpSBP[i].para_RfcWeight    = wgt_Rfc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_RfcScores * tmpSBP[i].para_RfcWeight;
                }
                else
                {
                    tmpSBP[i].para_Rfc          = list_AvTgt[i].tgt_Geo_Para_Rfc;
                    tmpSBP[i].para_RfcScores    = 0;
                    tmpSBP[i].para_RfcWeight    = wgt_Rfc;
                    tmpSBP[i].para_TotalScores += 0;
                }
                #endregion

                //工程条件
                #region
                //埋深 Dr Depth Range先计算平均值,然后利用高斯型隶属函数赋分
                if (list_AvTgt[i].tgt_Eng_Para_Dr_Avg.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("埋深(m)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Dr_Avg.Trim());
                    gradeScore                  = fMf.FuzzyGussian(values);
                    tmpSBP[i].para_Dr           = list_AvTgt[i].tgt_Eng_Para_Dr_Avg.Trim();
                    tmpSBP[i].para_DrScores     = gradeScore;
                    tmpSBP[i].para_DrWeight     = wgt_Dr;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_DrScores * tmpSBP[i].para_DrWeight;
                }
                else
                {
                    tmpSBP[i].para_Dr           = list_AvTgt[i].tgt_Eng_Para_Dr_Avg.Trim();
                    tmpSBP[i].para_DrScores     = 0;
                    tmpSBP[i].para_DrWeight     = wgt_Dr;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Pc 压力系数 的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("压力系数"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    gradeScore                  = fMf.FuzzyLarge(6, 1, values);
                    tmpSBP[i].para_Pc           = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_PcScores     = gradeScore;
                    tmpSBP[i].para_PcWeight     = wgt_Pc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_PcScores * tmpSBP[i].para_PcWeight;
                }
                else
                {
                    tmpSBP[i].para_Pc           = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_PcScores     = 0;
                    tmpSBP[i].para_PcWeight     = wgt_Pc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //渗透率(对页岩气,没必要的一个参数)求值
                if (list_AvTgt[i].tgt_Eng_Para_Per.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("渗透率(mD)"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_PerScores    = 0;
                    tmpSBP[i].para_PerWeight    = wgt_Per;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_PerScores * tmpSBP[i].para_PerWeight;
                }
                else
                {
                    tmpSBP[i].para_Per          = list_AvTgt[i].tgt_Eng_Para_Per.Trim();
                    tmpSBP[i].para_PerScores    = 0;
                    tmpSBP[i].para_PerWeight    = wgt_Per;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //裂缝发育度 分值
                if (list_AvTgt[i].tgt_Eng_Para_Fdd.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("裂缝发育程度"))
                {
                    string val = list_AvTgt[i].tgt_Eng_Para_Fdd.Trim();
                    gradeScore                  = fMf.FuzzyRankScore(val);
                    tmpSBP[i].para_Fdd          = list_AvTgt[i].tgt_Eng_Para_Fdd.Trim();
                    tmpSBP[i].para_FddScores    = gradeScore;
                    tmpSBP[i].para_FddWeight    = wgt_Fdd;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_FddScores * tmpSBP[i].para_FddWeight;
                }
                else
                {
                    tmpSBP[i].para_Fdd          = list_AvTgt[i].tgt_Eng_Para_Fdd.Trim();
                    tmpSBP[i].para_FddScores    = 0;
                    tmpSBP[i].para_FddWeight    = wgt_Fdd;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Psdc 主应力差异 的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Eng_Para_Psdc_Avg.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("主应力差异系数"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Psdc_Avg.Trim());
                    gradeScore                  = fMf.FuzzySmall(2.15, 0.5, values);
                    tmpSBP[i].para_Psdc         = list_AvTgt[i].tgt_Eng_Para_Psdc_Avg.Trim();
                    tmpSBP[i].para_PsdcScores   = gradeScore;
                    tmpSBP[i].para_PsdcWeight   = wgt_Psdc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_PsdcScores * tmpSBP[i].para_PsdcWeight;
                }
                else
                {
                    tmpSBP[i].para_Psdc         = list_AvTgt[i].tgt_Eng_Para_Psdc_Avg.Trim();
                    tmpSBP[i].para_PsdcScores   = 0;
                    tmpSBP[i].para_PsdcWeight   = wgt_Psdc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //对Bmc  的平均值进行增大型隶属函数求值
                if (list_AvTgt[i].tgt_Eng_Para_Bmc_Avg.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("脆性矿物含量(%)"))
                {
                    values                      = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Bmc_Avg.Trim());
                    gradeScore                  = fMf.FuzzyLarge(2.15, 30, values);
                    tmpSBP[i].para_Bmc          = list_AvTgt[i].tgt_Eng_Para_Bmc_Avg.Trim();
                    tmpSBP[i].para_BmcScores    = gradeScore;
                    tmpSBP[i].para_BmcWeight    = wgt_Bmc;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_BmcScores * tmpSBP[i].para_BmcWeight;
                }
                else
                {
                    tmpSBP[i].para_Bmc          = list_AvTgt[i].tgt_Eng_Para_Bmc_Avg.Trim();
                    tmpSBP[i].para_BmcScores    = 0;
                    tmpSBP[i].para_BmcWeight    = wgt_Bmc;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //水系求值
                if (list_AvTgt[i].tgt_Eng_Para_Ds.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("水系"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_DsScores     = 0;
                    tmpSBP[i].para_DsWeight     = wgt_Ds;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_DsScores * tmpSBP[i].para_DsWeight;
                }
                else
                {
                    tmpSBP[i].para_Ds           = list_AvTgt[i].tgt_Eng_Para_Ds.Trim();
                    tmpSBP[i].para_DsScores     = 0;
                    tmpSBP[i].para_DsWeight     = wgt_Ds;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //区域勘探程度求值
                if (list_AvTgt[i].tgt_Eng_Para_Led.Trim() != "" &&
                    lstBx_Selected_EngPara.Items.Contains("区域勘探程度"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_LedScores    = 0;
                    tmpSBP[i].para_LedWeight    = wgt_Led;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_LedScores * tmpSBP[i].para_LedWeight;
                }
                else
                {
                    tmpSBP[i].para_Led          = list_AvTgt[i].tgt_Eng_Para_Led.Trim();
                    tmpSBP[i].para_LedScores    = 0;
                    tmpSBP[i].para_LedWeight    = wgt_Led;
                    tmpSBP[i].para_TotalScores += 0;
                }

                #endregion


                //市场经济条件

                #region
                //市场气价求值
                if (list_AvTgt[i].tgt_Mkt_Para_Gp.Trim() != "" &&
                    lstBx_Selected_EcoPara.Items.Contains("市场气价"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_GpScores     = 0;
                    tmpSBP[i].para_GpWeight     = wgt_Gp;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_GpScores * tmpSBP[i].para_GpWeight;
                }
                else
                {
                    tmpSBP[i].para_Gp           = list_AvTgt[i].tgt_Mkt_Para_Gp.Trim();
                    tmpSBP[i].para_GpScores     = 0;
                    tmpSBP[i].para_GpWeight     = wgt_Gp;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //市场需求求值
                if (list_AvTgt[i].tgt_Mkt_Para_Dmd.Trim() != "" &&
                    lstBx_Selected_EcoPara.Items.Contains("市场需求"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_DmdScores    = 0;
                    tmpSBP[i].para_DmdWeight    = wgt_Dmd;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_DmdScores * tmpSBP[i].para_DmdWeight;
                }
                else
                {
                    tmpSBP[i].para_Dmd          = list_AvTgt[i].tgt_Mkt_Para_Dmd.Trim();
                    tmpSBP[i].para_DmdScores    = 0;
                    tmpSBP[i].para_DmdWeight    = wgt_Dmd;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //交通设施求值
                if (list_AvTgt[i].tgt_Mkt_Para_Tu.Trim() != "" &&
                    lstBx_Selected_EcoPara.Items.Contains("交通设施"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_TuScores     = 0;
                    tmpSBP[i].para_TuWeight     = wgt_Tu;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_TuScores * tmpSBP[i].para_TuWeight;
                }
                else
                {
                    tmpSBP[i].para_Tu           = list_AvTgt[i].tgt_Mkt_Para_Tu.Trim();
                    tmpSBP[i].para_TuScores     = 0;
                    tmpSBP[i].para_TuWeight     = wgt_Tu;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //管网条件求值
                if (list_AvTgt[i].tgt_Mkt_Para_Pn.Trim() != "" &&
                    lstBx_Selected_EcoPara.Items.Contains("管网条件"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_PnScores     = 0;
                    tmpSBP[i].para_PnWeight     = wgt_Pn;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_PnScores * tmpSBP[i].para_PnWeight;
                }
                else
                {
                    tmpSBP[i].para_Pn           = list_AvTgt[i].tgt_Mkt_Para_Pn.Trim();
                    tmpSBP[i].para_PnScores     = 0;
                    tmpSBP[i].para_PnWeight     = wgt_Pn;
                    tmpSBP[i].para_TotalScores += 0;
                }

                //地表地貌求值
                if (list_AvTgt[i].tgt_Mkt_Para_Sg.Trim() != "" &&
                    lstBx_Selected_EcoPara.Items.Contains("地表地貌"))
                {
                    //values = Convert.ToDouble(list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim());
                    //gradeScore = fMf.FuzzyLarge(6, 1, values);
                    // tmpSBP[i].para_Pc = list_AvTgt[i].tgt_Eng_Para_Pc_Avg.Trim();
                    tmpSBP[i].para_SgScores     = 0;
                    tmpSBP[i].para_SgWeight     = wgt_Sg;
                    tmpSBP[i].para_TotalScores += tmpSBP[i].para_SgScores * tmpSBP[i].para_SgWeight;
                }
                else
                {
                    tmpSBP[i].para_Sg           = list_AvTgt[i].tgt_Mkt_Para_Sg.Trim();
                    tmpSBP[i].para_SgScores     = 0;
                    tmpSBP[i].para_SgWeight     = wgt_Sg;
                    tmpSBP[i].para_TotalScores += 0;
                }
                #endregion
                list_Sbp.Add(tmpSBP[i]);
            }
            return(list_Sbp);
        }