OTS/OTSIncAReportApp/1-UI/OTSReportExport/DataIntegration/ParticleAnalysis.cs



using OTSCommon.DBOperate;
using OTSIncAReportApp.DataOperation.DataAccess;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static OTSDataType.otsdataconst;
using static OTSIncAReportApp.OTSReport_Export;

namespace OTSIncAReportApp._1_UI.OTSReportExport.DataIntegration
{
    /// <summary>
    /// 颗粒分析
    /// </summary>
    class ParticleAnalysis
    {
        /// <summary>
        /// 大分类
        /// </summary>
        /// <returns></returns>
        public DataTable GetLargeClassification(OTSReport_Export m_otsreport_export,BasicData basicData)
        {
			List<DataTable> DBData = basicData.GetDBData();
			DataTable Out_data = new DataTable();
			Out_data.Columns.Add("Name");
			Out_data.Columns.Add("total");
			Out_data.Columns.Add("TypeId");
			Out_data.Columns.Add("Class");
			int it = 1;
			for (int i = 7; i < DBData[0].Columns.Count; i++)
			{
				Out_data.Columns.Add("c" + it);
				it++;
			}
			List<string> ClassName = ObtainParticleCategory(m_otsreport_export, basicData);
			for (int i = 0; i < DBData.Count; i++)
			{
				if (DBData[i].Rows.Count == 0)
				{
					continue;
				}

				DataRow row1 = Out_data.NewRow();
				row1["Class"] = ClassName[i];

                List<double> ints = new List<double>();
                for (int a = 7; a < DBData[i].Columns.Count; a++)
                { 
                    double ias = CalculationTableColumn(DBData[i], DBData[i].Columns[a].ColumnName);
                    ints.Add(ias);
				}
                int zur = 0;
                for (int a = 0; a < ints.Count; a++)
                {
                    zur = zur + Convert.ToInt32(ints[a]);
				}
				row1["total"] = zur;
                Out_data.Rows.Add(row1);
			}
			return Out_data;
		}
        /// <summary>
        /// 小分类
        /// </summary>
        /// <returns></returns>
        public DataTable GetSubClassification(BasicData basicData)
        {
			List<DataTable> DBData = basicData.GetDBData();
            DataTable Out_data = new DataTable();
			Out_data.Columns.Add("Name");
			Out_data.Columns.Add("total");
			Out_data.Columns.Add("TypeId");
			Out_data.Columns.Add("Class");
			int it = 1;
			for (int i = 7; i < DBData[0].Columns.Count; i++)
			{
				Out_data.Columns.Add("c" + it);
				it++;
			}

            for (int i = 0; i < DBData.Count; i++)
            {
                if (DBData[i].Rows.Count == 0)
                {
                    continue;
                }
				for (int a = 0; a < DBData[i].Rows.Count; a++)
				{
				


					DataRow row1 = Out_data.NewRow();
					row1["Name"] = DBData[i].Rows[a]["TypeName"];
					row1["total"] = DBData[i].Rows[a]["con"];
					row1["TypeId"] = DBData[i].Rows[a]["TypeId"];
					row1["Class"] = "";

					int ii = 4;
					for (int j = 7; j < DBData[i].Columns.Count; j++)
					{
						row1[ii] = DBData[i].Rows[a][j];
						ii++;
					}
					Out_data.Rows.Add(row1);

			}
		
            }
            return Out_data;
        }
        /// <summary>
        /// 分类整合大小分类都有
        /// </summary>
        /// <returns></returns>
        public List<DataTable>  GetClassificationConsolidationTable(OTSReport_Export m_otsreport_export, BasicData basicData ,out DataTable dataTable)
        {
			List<DataTable> datas = new List<DataTable>();
			List<DataTable> DBData = basicData.GetDBData();
            DataTable DtName = new DataTable();
            DataTable table = new DataTable();
            table.Columns.Add("Name");
            table.Columns.Add("total");
            table.Columns.Add("TypeId");
			table.Columns.Add("Class");
            int it = 1;
            List<string> strings = new List<string>();
            for (int i = 7; i < DBData[0].Columns.Count; i++)
            {
                table.Columns.Add("c" + it);
                DtName.Columns.Add("c" + it);
                strings.Add(DBData[0].Columns[i].ColumnName);
				it++;
			}
            DataRow dataRow = DtName.NewRow();
			for (int i = 0; i < strings.Count; i++)
            {
                dataRow[i] = strings[i];
			}
            DtName.Rows.Add(dataRow);
            datas.Add(DtName);
			//数据
			List<string> ClassName = ObtainParticleCategory(m_otsreport_export, basicData);
			DataTable Dt = table.Clone();

            DataTable statisticalQuantity = Dt.Clone();


			for (int i = 0; i < DBData.Count; i++)
            {
                if (DBData[i].Rows.Count == 0)
                {
                    continue;
                }

                DataRow row = Dt.NewRow();
                row["Name"] = "";
                row["total"] = CalculationTableColumn(DBData[i], "con");
				row["TypeId"] = "";
                row["Class"] = ClassName[i];
                int ie = 0;
                for (int a = 4; a < Dt.Columns.Count; a++)
                {
                    row[a] = CalculationTableColumn(DBData[i], DtName.Rows[0][ie].ToString());
                    ie++;
				}
                Dt.Rows.Add(row);

				for (int a = 0; a < DBData[i].Rows.Count; a++)
                {
                    DataRow dataRow1 = statisticalQuantity.NewRow();
					dataRow1["Name"] = DBData[i].Rows[a]["TypeName"];
					dataRow1["total"] = DBData[i].Rows[a]["con"];
					dataRow1["TypeId"] = DBData[i].Rows[a]["TypeId"];
					//dataRow1["Class"] = DBData[i].Rows[a]["Class"];
					dataRow1["Class"] = "";


					DataRow row1= Dt.NewRow();
                    row1["Name"] = DBData[i].Rows[a]["TypeName"];
                    row1["total"] = DBData[i].Rows[a]["con"];
					row1["TypeId"] = DBData[i].Rows[a]["TypeId"];
					//row1["Class"] = DBData[i].Rows[a]["Class"];
					row1["Class"] = "";


					int ii = 4;
                    for (int j = 7; j < DBData[i].Columns.Count; j++)
                    {
						row1[ii]= DBData[i].Rows[a][j];
						dataRow1[ii] = DBData[i].Rows[a][j];
						ii++;
					}
                    Dt.Rows.Add(row1);
                    statisticalQuantity.Rows.Add(dataRow1);
				}
            }
            datas.Add(Dt);


            DataTable OutStatisticalQuantity = statisticalQuantity.Clone();
            DataRow row2 = OutStatisticalQuantity.NewRow();
            for (int i = 4; i < statisticalQuantity.Columns.Count; i++)
            {
				row2[i]= CalculationTableColumn(statisticalQuantity, statisticalQuantity.Columns[i].ColumnName);

			}
            OutStatisticalQuantity.Rows.Add(row2);
			dataTable = OutStatisticalQuantity.Copy();

			return datas;
        }
		/// <summary>
		/// 获得颗粒类别
		/// </summary>
		/// <returns></returns>
		private List<string> ObtainParticleCategory(OTSReport_Export m_otsreport_export, BasicData basicData)
		{
			List<string> ClassName = new List<string>();
			if (m_otsreport_export.m_ReportApp.m_RptConfigFile.Systype != OTS_SysType_ID.IncA)
			{
				DataTable get_dt = ReadClassification(basicData);
				DataTable getClass_dt = get_dt.Clone();
				DataRow[] dataRow = get_dt.Select("", "iorder ASC");
				foreach (DataRow row in dataRow)
				{
					if (row.ItemArray[1].ToString() != "Default")
					{
						getClass_dt.ImportRow(row);
					}
				}
				for (int i = 0; i < getClass_dt.Rows.Count; i++)
				{
					ClassName.Add(getClass_dt.Rows[i][1].ToString());
				}
				ClassName.Add("Default");

			}
			else
			{
                ClassName = basicData.GetGroupInformation();
			}
			return ClassName;
		}
		private DataTable ReadClassification(BasicData basicData )
		{
			DataTable dt_stl = new DataTable();
			SqLiteHelper sh = new SqLiteHelper("data source='" + basicData.GetFilePath()+ "\\"+basicData.GetResfile() + "'");
			dt_stl = sh.ExecuteQuery("select * from STDGroups");
			return dt_stl;
		}

		/// <summary>
		/// 大分类chart数据
		/// </summary>
		/// <param name="m_mbszclass"></param>
		/// <param name="m_otsreport_export"></param>
		/// <returns></returns>
		public DataTable GetChartDataCalss(BasicData basicData)
        {
            //DataTable data =basicData.GetDBData();
            DataTable data = new DataTable();
			//获取粒级表
			List<string> colid = basicData.GetParticlesizeTable();
            //------------------------------------------------
            DataTable ls_partsize_dt = new DataTable();
            ls_partsize_dt.TableName = "PartSize";
            for (int i = 0; i < colid.Count; i++)
            {
                ls_partsize_dt.Columns.Add("c"+(i+1).ToString());
            }
           

            DataTable ls_Particel_dt = new DataTable();
            ls_Particel_dt.TableName = "Particel";
            DataRow dr = ls_partsize_dt.NewRow();
            int colidCount = 1;
            for (int i = 0; i < colid.Count; i++)
            {
                if (colid.Count < i)
                {
                    dr["c" + (i + 1).ToString()] = "";
                }
                else
                {
                    dr["c" + (i + 1).ToString()] = colid[i];
                    ls_Particel_dt.Columns.Add("c" + (i + 1).ToString(), typeof(double));
                    colidCount++;
                }
            }
            ls_partsize_dt.Rows.Add(dr);

            ls_Particel_dt.Columns.Add("Name");
            ls_Particel_dt.Columns.Add("total", typeof(double));
            ls_Particel_dt.Columns.Add("TypeId");
            ls_Particel_dt.Columns.Add("Class");

            for (int i = 0; i < data.Rows.Count; i++)
            {
                DataRow dr2 = ls_Particel_dt.NewRow();
                dr2["Name"] = data.Rows[i]["TypeName"].ToString();
                dr2["Class"] = data.Rows[i]["Class"].ToString();
                dr2["TypeId"] = data.Rows[i]["TypeId"].ToString();//获取分类编号
                for (int j = 1; j < colidCount; j++)
                {
                    if (colid.Count >= j)
                    {
                        dr2["c" + j.ToString()] = Convert.ToDouble(data.Rows[i][colid[j - 1]]);
                    }
                }
                if (dr2["Name"].ToString() != "" && dr2["Name"].ToString().IndexOf("number") < 0)
                {
                    dr2["total"] = "0"; //求合
                    double d_total = 0;

                    for (int j = 1; j < colidCount; j++)
                    {
                        if (colid.Count >= j)
                        {
                            d_total = d_total + Convert.ToInt64(data.Rows[i][colid[j - 1]]);
                        }
                    }
                    dr2["total"] = d_total.ToString();
                }
                ls_Particel_dt.Rows.Add(dr2);
            }
            //按照list列表进行物质类排序，物质类中的元素分类按照面积的大小进行排序
            List<string> ClassName = new List<string>();
            DataTable getClass_dt = basicData.GetAllClass();
            for (int i = 0; i < getClass_dt.Rows.Count; i++)
            {
                if (getClass_dt.Rows[i]["GroupName"].ToString() != "NOT_INCLUTION" && getClass_dt.Rows[i]["GroupName"].ToString() != "Invalid")
                    if (getClass_dt.Rows[i]["GroupName"].ToString() == "")
                        ClassName.Add("NULL");
                    else
                        ClassName.Add(getClass_dt.Rows[i]["GroupName"].ToString());
            }

            //颗粒尺寸数据（例 1.5有多少，2.0有多少）
            DataTable colid_data = new DataTable();
            colid_data.Columns.Add("name");
            colid_data.Columns.Add("quantity", typeof(double));
            for (int i = 0; i < ls_Particel_dt.Columns.Count; i++)
            {

                if (ls_Particel_dt.Columns[i].ColumnName == "c" + (i + 1).ToString())
                {
                    if (i < colid.Count)
                    {
                        DataRow dr1 = colid_data.NewRow();
                        dr1["name"] = colid[i].ToString();
                        int quantity = 0;
                        for (int a = 0; a < ls_Particel_dt.Rows.Count; a++)
                        {
                            quantity = quantity + Convert.ToInt32(ls_Particel_dt.Rows[a][i].ToString());
                        }
                        dr1["quantity"] = quantity.ToString();
                        colid_data.Rows.Add(dr1);
                    }
                }
            }
            return colid_data;
         
        }
        public DataTable ParticleResults(c_TemplateClass m_mbszclass, OTSReport_Export m_otsreport_export, string ComputeMode)
        {
            DataTable data = GetDBData(m_mbszclass, m_otsreport_export, ComputeMode);

            List<string> colid = new List<string>();
            //获取粒级表
            string path1 = m_otsreport_export.m_ReportApp.m_rstDataMgr.m_RptConfigFile.PartSizeFileFolder +
                 m_otsreport_export.m_ReportApp.m_rstDataMgr.m_RptConfigFile.PartSizeFile;
            DataSet ds = OTSIncAReportApp.DataOperation.DataAccess.XMLoperate.GetXml(path1);
            string sizestr = ds.Tables[0].Rows[0]["Sizes"].ToString();
            for (int i = 0; i < sizestr.Split(',').Length; i++)
            {
                if (sizestr.Split(',')[i].Length > 0)
                {
                    double d1 = Convert.ToDouble(sizestr.Split(',')[i]);
                    colid.Add("≥" + d1.ToString() );
                }
            }

            ParticleData fielddata = new ParticleData(m_otsreport_export.m_ReportApp.m_rstDataMgr.ResultFilesList[m_otsreport_export.m_ReportApp.m_rstDataMgr.GetWorkingResultId()].FilePath);


            //------------------------------------------------
            DataTable ls_partsize_dt = new DataTable();
            ls_partsize_dt.TableName = "PartSize";
            for(int i=0;i< colid.Count;i++)
            {
                ls_partsize_dt.Columns.Add("c"+(i+1).ToString());
            }
 
            DataRow dr = ls_partsize_dt.NewRow();
            DataTable ls_Particel_dt = new DataTable();
            ls_Particel_dt.TableName = "Particel";
            int colidCount = 1;
            for (int i = 0; i < colid.Count; i++)
            {
   
                    dr["c" + (i+1).ToString()] = colid[i];
          

                ls_Particel_dt.Columns.Add("c"+ (i + 1).ToString());
                colidCount++;
            }
            ls_partsize_dt.Rows.Add(dr);
            ls_Particel_dt.Columns.Add("Name");
            ls_Particel_dt.Columns.Add("total");
            ls_Particel_dt.Columns.Add("TypeId");


            for (int i = 0; i < data.Rows.Count; i++)
            {
                DataRow dr2 = ls_Particel_dt.NewRow();
                dr2["Name"] = data.Rows[i]["TypeName"].ToString();

                dr2["TypeId"] = data.Rows[i]["TypeId"].ToString();//获取分类编号
                for (int j = 1; j < colidCount; j++)
                {
                    if (colid.Count >= j)
                    {
                        double de = Convert.ToDouble(data.Rows[i][colid[j - 1]]);
                        if (de == 0)
                            dr2["c" + j.ToString()] = " ";
                        else
                            dr2["c" + j.ToString()] = de.ToString();
                    }
                }
                if (dr2["Name"].ToString() != "" && dr2["Name"].ToString().IndexOf("number") < 0)
                {
                    dr2["total"] = " "; //求合
                    double d_total = 0;

                    for (int j = 1; j < colidCount; j++)
                    {
                        if (colid.Count >= j)
                        {
                            d_total = d_total + Convert.ToInt64(data.Rows[i][colid[j - 1]]);
                        }
                    }
                    if (d_total == 0)
                    {
                        continue;
                        dr2["total"] = " ";
                    }
                    else
                        dr2["total"] = d_total.ToString();
                }
                ls_Particel_dt.Rows.Add(dr2);
            }
            return ls_Particel_dt;
        }
        public DataTable TypeRange(c_TemplateClass m_mbszclass, OTSReport_Export m_otsreport_export)
        {
            List<string> colid = new List<string>();
            //获取粒级表
            string path1 = m_otsreport_export.m_ReportApp.m_rstDataMgr.m_RptConfigFile.PartSizeFileFolder +
                 m_otsreport_export.m_ReportApp.m_rstDataMgr.m_RptConfigFile.PartSizeFile;
            DataSet ds = OTSIncAReportApp.DataOperation.DataAccess.XMLoperate.GetXml(path1);
            string sizestr = ds.Tables[0].Rows[0]["Sizes"].ToString();
            for (int i = 0; i < sizestr.Split(',').Length; i++)
            {
                if (sizestr.Split(',')[i].Length > 0)
                {
                    double d1 = Convert.ToDouble(sizestr.Split(',')[i]);
                
                    colid.Add("≥" + d1.ToString());
                }
            }
 
            DataTable ls_partsize_dt = new DataTable();
            ls_partsize_dt.TableName = "PartSize";

            for (int i=0;i< colid.Count;i++)
            {
                ls_partsize_dt.Columns.Add("c"+(i+1).ToString());
            }
            
            DataRow dr = ls_partsize_dt.NewRow();
            for (int i = 0; i < colid.Count; i++)
            {
               
                    dr["c" + (i+1).ToString()] = colid[i];
             
            }
            ls_partsize_dt.Rows.Add(dr);

            return ls_partsize_dt;
        }
        private DataTable QuantityOfIntegratedSubstances(DataTable dataTable, List<string> ClassName)
        {
            DataTable dt_Class = dataTable.Copy();
            dt_Class.Clear();
            dt_Class.TableName = "Particel";
            dt_Class.Columns.Remove("Name");

            for (int i = 0; i < ClassName.Count; i++)
            {
                //保留当前循环中大类物质，去除其他物质
                DataTable dt = dataTable.Copy();
                dt.Clear();
                for (int a = 0; a < dataTable.Rows.Count; a++)
                {
                    if (dataTable.Rows[a]["Class"].ToString() == ClassName[i].ToString())
                    {
                        dt.Rows.Add(dataTable.Rows[a].ItemArray);
                    }
                }
                //if (dt.Rows.Count == 0)
                //    continue;

                DataTable dt_2 = new DataTable();
                dt_2 = dataTable.Copy();
                dt_2.Clear();
                DataRow row = dt_2.NewRow();
                dt_2.Rows.Add(row);

                for (int a = 0; a < dt.Columns.Count; a++)
                {
                    if (dt.Columns[a].ToString() != "Name" && dt.Columns[a].ToString() != "Class" && dt.Columns[a].ToString() != "TypeId")
                    {
                        bool bl = false;
                        for (int b = 0; b < dt.Rows.Count; b++)
                        {
                            if (!dt.Rows[b].IsNull(dt.Columns[a].ToString()))
                            {
                                bl = true;
                            }
                        }
                        if (bl)
                        {
                            dt_2.Rows[0][dt.Columns[a].ToString()] = decimal.Parse(dt.Compute("sum(" + dt.Columns[a].ToString() + ")", "").ToString());
                        }
                        else
                        {
                            dt_2.Rows[0][dt.Columns[a].ToString()] = 0;
						}
                    }
                  
                }
                dt_2.Columns.Remove("Name");
                dt_2.Rows[0]["Class"] = ClassName[i];
                dt_Class.Rows.Add(dt_2.Rows[0].ItemArray);
            }
            return dt_Class;
        }
        private DataTable classIfIcationSort(DataTable dataTable, List<string> ClassName, DataTable data,int colidCount)
        {
            DataTable dt = new DataTable();
            dt = dataTable.Copy();
            dt.Clear();
            dt.TableName = "Particel_subdivision";
            //循环list中每个类型
            for (int i = 0; i < ClassName.Count(); i++)
            {
                DataTable data1 = dt.Copy();
                data1.Clear();
                data1.Rows.Add();
                for (int a = 0; a < data.Rows.Count; a++)
                {
                    if (data.Rows[a]["Class"].ToString() == ClassName[i].ToString())
                    {
                        for (int b = 1; b < colidCount; b++)
                        {
                            data1.Rows[0]["c" + b.ToString()] = data.Rows[a]["c" + b.ToString()];
                        }
                        data1.Rows[0]["total"] = data.Rows[a]["total"];
                        data1.Rows[0]["Class"] = data.Rows[a]["Class"];

                        dt.Rows.Add(data1.Rows[0].ItemArray);
                    }
                }

                DataTable dt_1 = new DataTable();
                dt_1 = dt.Copy();
                dt_1.Clear();
                //循环DataTable中每个分类的数据
                for (int a = 0; a < dataTable.Rows.Count; a++)
                {
                    if (!string.IsNullOrWhiteSpace(ClassName[i].ToString()))
                        if (dataTable.Rows[a]["Class"].ToString() == ClassName[i].ToString())
                        {
                            dataTable.Rows[a]["Class"] = "";
                            dt_1.Rows.Add(dataTable.Rows[a].ItemArray);
                        }
                }
                //将颗粒数量排序（从大到小）
                DataView dv = dt_1.DefaultView;
                dv.Sort = "total DESC";
                DataTable dt_1_sort = dv.ToTable();
                for (int a = 0; a < dt_1_sort.Rows.Count; a++)
                {
                    dt.Rows.Add(dt_1_sort.Rows[a].ItemArray);
                }
            }
   
            return dt;

        }
        private DataTable InvalidRemoval(DataTable dt)
        {
            DataTable dataTable = dt.Copy();
            dataTable.Clear();

            for (int i = 0; i < dt.Rows.Count; i++)
            {
                if (Convert.ToInt32(dt.Rows[i]["TypeId"])>10 )
                {
                    dataTable.Rows.Add(dt.Rows[i].ItemArray);
                }
            }
            return dataTable;
        }
        private string getWhere(string max, string min, string col, string partic)
        {
            return col + ">=" + min + " and " + col + "<" + max + " and TypeId=" + partic;
        }
        private DataTable GetDBData(c_TemplateClass m_mbszclass , OTSReport_Export m_otsreport_export,string ComputeMode)
        {

            DataTable m_bt_DBData = new DataTable();
            ParticleData fielddata = new ParticleData(m_otsreport_export.m_ReportApp.m_rstDataMgr.ResultFilesList[m_otsreport_export.m_ReportApp.m_rstDataMgr.GetWorkingResultId()].FilePath);
            List<string> colid = new List<string>() { "TypeName", "ar", "TypeId", "Largest", "Class", "con" };
            //获取粒级表
            string path1 = m_otsreport_export.m_ReportApp.m_rstDataMgr.m_RptConfigFile.PartSizeFileFolder +
                 m_otsreport_export.m_ReportApp.m_rstDataMgr.m_RptConfigFile.PartSizeFile;
            DataSet ds = OTSIncAReportApp.DataOperation.DataAccess.XMLoperate.GetXml(path1);
            string sizestr = ds.Tables[0].Rows[0]["Sizes"].ToString();
            for (int i = 0; i < sizestr.Split(',').Length ; i++)
            {
                if (sizestr.Split(',')[i].Length > 0)
                {
                    double d1 = Convert.ToDouble(sizestr.Split(',')[i]);
                    colid.Add("≥" + d1.ToString() );
                }
            }
          
            for (int i = 0; i < colid.Count; i++)
            {
                m_bt_DBData.Columns.Add(colid[i].ToString());
            }

            DataTable dt = InvalidRemoval(fielddata.GetParticleListForParticlSize("area", ""));
            DataTable AreaInformationOfAllElements = InvalidRemoval(fielddata.GetAreaByAllIncA(""));
            DataTable dtp = InvalidRemoval(fielddata.GetParticleAll(""));
          
            string po = ComputeMode;
            switch (po)
            {
                case "DMAX":
                    po = "DMAX";
                    break;
                case "DMIN":
                    po = "DMIN";
                    break;
                case "ECD":
                    po = "Area";
                    break;
                case "FERET":
                    po = "DFERET";
                    break;
            }


            for (int i = 0; i < dt.Rows.Count; i++)
            {
                DataRow dr = m_bt_DBData.NewRow();
                dr["TypeName"] = dt.Rows[i]["TypeName"].ToString();
                dr["TypeId"] = dt.Rows[i]["TypeId"].ToString();
                dr["con"] = dt.Rows[i]["con"].ToString();

                if (dt.Rows[i]["GroupName"].ToString() == "")
                    dr["Class"] = "Default";
                else
                    dr["Class"] = dt.Rows[i]["GroupName"].ToString();
                //continue;
                dr["Largest"] = Math.Round(Convert.ToDouble(dt.Rows[i]["max"]), 2);
                for (int a = 6; a < colid.Count; a++)
                {
                    string d2;
                    if (a== colid.Count-1)
                    {
                        d2 = "999";
                    }
                    else
                    {
                        d2 = colid[a+1].Split('≥')[1];
                    }
                    string d1 = colid[a].Split('≥')[1];
                    
                    DataRow[] datas = dtp.Select(getWhere(d2, d1, po, dt.Rows[i]["TypeId"].ToString()));
                    dr[colid[a]] = datas.Count();
                }
                for (int a = 0; a < AreaInformationOfAllElements.Rows.Count; a++)
                {
                    if (dt.Rows[i]["TypeId"].ToString() == AreaInformationOfAllElements.Rows[a]["TypeId"].ToString())
                    {
                        dr["ar"] = AreaInformationOfAllElements.Rows[a]["ar"];
                    }
                }
                m_bt_DBData.Rows.Add(dr);
            }



            //去除物质分类（非夹杂物分类）
            for (int a = 0; a < m_mbszclass.M_KLLBXX.list_str_kllb_DeleteClass_Serial.Count; a++)
            {
                for (int i = m_bt_DBData.Rows.Count - 1; i >= 0; i--)
                {
                    if (m_bt_DBData.Rows[i]["TypeId"].ToString() == m_mbszclass.M_KLLBXX.list_str_kllb_DeleteClass_Serial[a].ToString())
                    {
                        m_bt_DBData.Rows.RemoveAt(i);
                    }
                }
            }

            if (m_mbszclass.list_str_MainPriority_Serial.Count==0)
            {
                return m_bt_DBData;
            }

            DataTable datass = m_bt_DBData.Clone();

            for (int i=0;i< m_mbszclass.list_str_MainPriority_Serial.Count;i++)
            {
                bool bl = false;
                for (int a = 0; a < m_bt_DBData.Rows.Count; a++)
                {
                    if (m_bt_DBData.Rows[a]["TypeId"].ToString() == m_mbszclass.list_str_MainPriority_Serial[i])
                    {
                        datass.Rows.Add(m_bt_DBData.Rows[a].ItemArray);
                        bl = true;
                        continue;
                    }
                }
                if(!bl)
                {
                    DataTable dta= m_bt_DBData.Clone();
                    if (m_bt_DBData.Rows.Count != 0)
                    {
                        dta.Rows.Add(m_bt_DBData.Rows[0].ItemArray);
                        for (int b = 0; b < dta.Columns.Count; b++)
                        {
                            if (dta.Columns[b].ColumnName == "TypeName")
                            {
                                dta.Rows[0][b] = m_mbszclass.list_str_MainPriority[i];
                            }
                            else if (dta.Columns[b].ColumnName == "Class")
                            {
                                dta.Rows[0][b] = "Default";
                            }
                            else
                            {
                                dta.Rows[0][b] = 0;
                            }
                        }

                        datass.Rows.Add(dta.Rows[0].ItemArray);
                    }

                    
                }
            }

            return datass;
        }

		private double CalculationTableColumn(DataTable a_data, string a_str)
		{
			double dl = 0;
			if (a_data.Columns.Contains(a_str))
			{
				for (int i = 0; i < a_data.Rows.Count; i++)
				{
					if (a_data.Rows[i][a_str].ToString() != "")
					{
						dl = dl + Convert.ToDouble(a_data.Rows[i][a_str]);
					}
				}
			}



			return dl;

		}
	}
}