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

using DevExpress.Charts.Native;
using DevExpress.Office.Drawing;
using NPOI.Util;
using OTSCommon.DBOperate;
using OTSCommon.DBOperate.Model;
using OTSIncAReportApp._2_CommonFunction.CommonClass;
using OTSIncAReportApp.DataOperation.DataAccess;
using OTSIncAReportApp.OTSRstMgrFunction;
using OTSIncAReportGrids;
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
{
	public class BasicData
	{
		ParticleData fielddata;
		private string SizeChart = "";

		List<string> colid = new List<string>();
		List<string> colid_Below7 = new List<string>();

		List<string> GroupInformation = new List<string>();

		private List<DataTable> BData = new List<DataTable>();
		private List<DataTable> Measurements = new List<DataTable>();//测量结果数据列队
		private DataTable spliceMeasurements = new DataTable();//拼接测量结果数据列队

		private DataTable AllClass = new DataTable();
		private DataTable AllElement = new DataTable();
		private bool IsShereAClassificationGroup = false;
		private ResultFile resfile;
		private string FilePath = "";

		private string VDA19String = "5,15,25,50,100,150,200,400,600,1000";

		//DataTable particlesAll;
		//DataTable userSTDDbData;
		/// <summary>
		/// 获取粒级表
		/// </summary>
		public void SetParticlesizeTable(OTSReport_Export m_otsreport_export)
		{

			colid_Below7.Clear();
			//获取粒级表
			//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);
			//SizeChart = ds.Tables[0].Rows[0]["Sizes"].ToString();
            RptConfigFile rptConfigFile = RptConfigFile.GetRptConfig();
            string SizeChart = rptConfigFile.GetParticleSizeBYSizeScaleName(rptConfigFile.GetDefaultPartSize());

            for (int i = 0; i < SizeChart.Split(',').Length; i++)
			{
				if (SizeChart.Split(',')[i].Length > 0)
				{
					double d1 = Convert.ToDouble(SizeChart.Split(',')[i]);
					//double d2 = Convert.ToDouble(SizeChart.Split(',')[i + 1]);
					colid.Add("≥" + d1.ToString() /*+ "~" + d2.ToString()*/);
				}
			}


			for (int i = 0; i < SizeChart.Split(',').Length - 1; i++)
			{
				if (SizeChart.Split(',')[i].Length > 0)
				{
					double d1 = Convert.ToDouble(SizeChart.Split(',')[i]);
					double d2 = Convert.ToDouble(SizeChart.Split(',')[i + 1]);
					colid_Below7.Add(d1.ToString() + "~" + d2.ToString());
				}
			}
			double d = Convert.ToDouble(SizeChart.Split(',')[SizeChart.Split(',').Length - 1]);
			colid_Below7.Add(d.ToString() + "~MAX");
			//double d = Convert.ToDouble(SizeChart.Split(',')[SizeChart.Split(',').Length - 1]);
			//colid.Add(d.ToString() + "~MAX");
		}
		/// <summary>
		/// 获取粒级表
		/// </summary>
		/// <returns></returns>
		public List<string> GetParticlesizeTable()
		{
			if (colid.Count > 7)
			{
				return colid;
			}
			else
			{
				return colid_Below7;
			}

		}

		/// <summary>
		/// 获取拼接颗粒信息
		/// </summary>
		/// <returns></returns>
		public DataTable ObtainInformationOnSplicedParticles(OTSReport_Export m_otsreport_export)
		{
			DataTable userSTDDbData = new DataTable();
			DataTable particlesAll;
			ParticlesGridDevidePage particlesGridDevide = new ParticlesGridDevidePage(m_otsreport_export.m_ReportApp);
			var systype = m_otsreport_export.m_ReportApp.m_RptConfigFile.Systype;
			if (systype == OTS_SysType_ID.TCCleannessA || systype == OTS_SysType_ID.BatteryCleannessA)
			{
				string str_STDDbName = resfile.GetSTDName();
				particlesGridDevide.userSTDDb = new UserSTDDbAccess(str_STDDbName, resfile.FilePath + "\\");
				if (particlesGridDevide.userSTDDb.GetSqlHelper() != null)
				{
					userSTDDbData = particlesGridDevide.userSTDDb.GetSubAttributeFromDatabase();
				}
				else
				{
					userSTDDbData = null;
				}
			}
			particlesGridDevide.Particledata = new ParticleData(resfile.FilePath);
			DataTable qparticlesAll = particlesGridDevide.Particledata.GetInfoForPartucleDevidePage_mergeParticles("");
			particlesAll = SplicingParticleElementFilling(qparticlesAll, particlesGridDevide, userSTDDbData);
			return particlesAll;
		}



		public void SetDBData(c_TemplateClass m_mbszclass, OTSReport_Export m_otsreport_export, string ComputeMode)
		{
			// 入口方法：拆分后只做高层次流程控制，具体步骤委派给私有方法
			DataTable m_bt_DBData = new DataTable();

			// 初始化 fielddata（局部使用）
			ParticleData localFieldData = new ParticleData(m_otsreport_export.m_ReportApp.m_rstDataMgr.ResultFilesList[m_otsreport_export.m_ReportApp.m_rstDataMgr.GetWorkingResultId()].FilePath);

			// 构建粒级列定义（colid）并创建表列
			List<string> sizeColumns;
			bool blBelow7;
			BuildSizeColumns(m_mbszclass, m_otsreport_export, out sizeColumns, out blBelow7);
			//RptConfigFile rptConfigFile = RptConfigFile.GetRptConfig();
   //         string sizestr = rptConfigFile.GetParticleSizeBYSizeScaleName(rptConfigFile.GetDefaultPartSize());


            // 固定列名
            List<string> fixedCols = new List<string>() { "TypeName", "ar", "TypeId", "Largest", "Class", "GroupId", "con" };
			foreach (var c in fixedCols) m_bt_DBData.Columns.Add(c);
			foreach (var c in sizeColumns) m_bt_DBData.Columns.Add(c);

			// 读取并过滤数据表
			DataTable dt = InvalidRemoval(localFieldData.GetParticleListForParticlSize("area", ""));
			DataTable AreaInformationOfAllElements = InvalidRemoval(localFieldData.GetAreaByAllIncA(""));
			DataTable dtp = InvalidRemoval(localFieldData.GetParticleAll(""));
			spliceMeasurements = InvalidRemoval(localFieldData.GetSpliceParticleAll(""));

			// 拼接颗粒信息并去除拼接前的颗粒
			DataTable particlesAll = ObtainInformationOnSplicedParticles(m_otsreport_export);
			RemovePreSplicedParticles(dtp, particlesAll);

			// 计算分箱统计并填充 m_bt_DBData
			string measureCol = NormalizeComputeMode(ComputeMode);
			PopulateDBDataTable(m_bt_DBData, dt, dtp, AreaInformationOfAllElements, sizeColumns, blBelow7, measureCol);

			// 过滤并生成分组信息
			FilterDeletedClasses(m_mbszclass, m_bt_DBData);
			BuildGroupInformation(m_bt_DBData);

			// 根据系统类型分支处理（IncA 与 非 IncA 不同逻辑）
			if (m_otsreport_export.m_ReportApp.m_RptConfigFile.Systype == OTS_SysType_ID.IncA)
			{
				HandleIncAType(m_bt_DBData, dtp);
				return;
			}

			// 非 IncA：判断是否使用指定选择组和规则
			bool hasDefaultGroupRule = HasDefaultGroupRule(m_otsreport_export);
			if (!hasDefaultGroupRule)
			{
				HandleNonDefaultGroup(m_bt_DBData, dtp);
				return;
			}

			// 使用指定组和规则
			HandleSpecifiedGroups(m_mbszclass, m_bt_DBData, dtp, m_otsreport_export);
		}

		#region SetDBData 私有拆分方法

		private void BuildSizeColumns(c_TemplateClass m_mbszclass, OTSReport_Export m_otsreport_export, out List<string> sizeColumns, out bool blBelow7)
		{
            RptConfigFile rptConfigFile = RptConfigFile.GetRptConfig();
            string sizestr = rptConfigFile.GetParticleSizeBYSizeScaleName(rptConfigFile.GetDefaultPartSize());


            sizeColumns = new List<string>();
			blBelow7 = false;
			//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;
			if (m_mbszclass.M_VDA19.IsVDA19)
				sizestr = VDA19String;
			//else
                //sizestr = ds.Tables[0].Rows[0]["Sizes"].ToString();
              

            var parts = sizestr.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			if (parts.Length > 7)
			{
				blBelow7 = true;
				for (int i = 0; i < parts.Length; i++)
				{
					double d1 = Convert.ToDouble(parts[i]);
					sizeColumns.Add("≥" + d1.ToString());
				}
			}
			else
			{
				for (int i = 0; i < parts.Length - 1; i++)
				{
					double d1 = Convert.ToDouble(parts[i]);
					double d2 = Convert.ToDouble(parts[i + 1]);
					sizeColumns.Add(d1.ToString() + "~" + d2.ToString());
				}
				double d = Convert.ToDouble(parts[parts.Length - 1]);
				sizeColumns.Add(d.ToString() + "~MAX");
				blBelow7 = false;
			}
		}

		private void RemovePreSplicedParticles(DataTable dtp, DataTable particlesAll)
		{
			if (particlesAll == null || particlesAll.Rows.Count == 0) return;

			List<Tuple<string, string>> preList = new List<Tuple<string, string>>();
			for (int i = 0; i < particlesAll.Rows.Count; i++)
			{
				string detailedLocation = particlesAll.Rows[i]["SubParticles"].ToString();
				if (string.IsNullOrWhiteSpace(detailedLocation)) continue;
				string[] fruits = detailedLocation.Split(',');
				for (int a = 0; a < fruits.Length; a++)
				{
					var fruit = fruits[a].Split(':');
					if (fruit.Length >= 2)
						preList.Add(Tuple.Create(fruit[0], fruit[1]));
				}
			}

			for (int i = dtp.Rows.Count - 1; i >= 0; i--)
			{
				string fieldId = dtp.Rows[i]["FieldId"].ToString();
				string xrayId = dtp.Rows[i]["XrayId"].ToString();
				for (int a = 0; a < preList.Count; a++)
				{
					if (fieldId == preList[a].Item1 && xrayId == preList[a].Item2)
					{
						dtp.Rows.RemoveAt(i);
						break;
					}
				}
			}
		}

		private string NormalizeComputeMode(string ComputeMode)
		{
			string po = ComputeMode;
			switch (po)
			{
				case "DMAX":
					return "DMAX";
				case "DMIN":
					return "DMIN";
				case "ECD":
					return "Area";
				case "FERET":
					return "DFERET";
				default:
					return po;
			}
		}

		private void PopulateDBDataTable(DataTable m_bt_DBData, DataTable dt, DataTable dtp, DataTable AreaInfo, List<string> sizeColumns, bool blBelow7, string measureCol)
		{
			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();
				dr["GroupId"] = dt.Rows[i]["GroupId"].ToString();
				dr["Class"] = string.IsNullOrWhiteSpace(dt.Rows[i]["GroupName"].ToString()) ? "Default" : dt.Rows[i]["GroupName"].ToString();
				dr["Largest"] = Math.Round(Convert.ToDouble(dt.Rows[i]["max"]), 2);

				if (blBelow7)
				{
					for (int a = 0; a < sizeColumns.Count; a++)
					{
						string d1 = sizeColumns[a].Split('≥')[1];
						string d2;
						if (a == sizeColumns.Count - 1)
							d2 = int.MaxValue.ToString();
						else
							d2 = sizeColumns[a + 1].Split('≥')[1];

						DataRow[] datas = dtp.Select(getWhere(d2, d1, measureCol, dt.Rows[i]["TypeId"].ToString()));
						dr[sizeColumns[a]] = datas.Length;
					}
				}
				else
				{
					for (int a = 0; a < sizeColumns.Count; a++)
					{
						string d1 = sizeColumns[a].Split('~')[0];
						string d2 = sizeColumns[a].Split('~')[1];
						if (d2 == "MAX") d2 = int.MaxValue.ToString();
						DataRow[] datas = dtp.Select(getWhere(d2, d1, measureCol, dt.Rows[i]["TypeId"].ToString()));
						dr[sizeColumns[a]] = datas.Length;
					}
				}

				// 填充面积信息
				for (int a = 0; a < AreaInfo.Rows.Count; a++)
				{
					if (dt.Rows[i]["TypeId"].ToString() == AreaInfo.Rows[a]["TypeId"].ToString())
					{
						dr["ar"] = AreaInfo.Rows[a]["ar"];
						break;
					}
				}
				m_bt_DBData.Rows.Add(dr);
			}
		}

		private void FilterDeletedClasses(c_TemplateClass m_mbszclass, DataTable m_bt_DBData)
		{
			if (m_mbszclass?.M_KLLBXX?.list_str_kllb_DeleteClass == null) return;
			for (int a = 0; a < m_mbszclass.M_KLLBXX.list_str_kllb_DeleteClass.Count; a++)
			{
				for (int i = m_bt_DBData.Rows.Count - 1; i >= 0; i--)
				{
					if (m_bt_DBData.Rows[i]["TypeName"].ToString() == m_mbszclass.M_KLLBXX.list_str_kllb_DeleteClass[a].ToString())
					{
						m_bt_DBData.Rows.RemoveAt(i);
					}
				}
			}
		}

		private void BuildGroupInformation(DataTable m_bt_DBData)
		{
			GroupInformation = new List<string>();
			for (int i = 0; i < m_bt_DBData.Rows.Count; i++)
			{
				string cls = m_bt_DBData.Rows[i]["Class"].ToString();
				if (!GroupInformation.Contains(cls))
					GroupInformation.Add(cls);
			}
		}

		private void HandleIncAType(DataTable m_bt_DBData, DataTable dtp)
		{
			Measurements = new List<DataTable>();
			BData = new List<DataTable>();

			for (int i = 0; i < GroupInformation.Count; i++)
			{
				DataTable table = m_bt_DBData.Clone();
				for (int a = 0; a < m_bt_DBData.Rows.Count; a++)
				{
					if (GroupInformation[i] == m_bt_DBData.Rows[a]["Class"].ToString())
					{
						table.Rows.Add(m_bt_DBData.Rows[a].ItemArray);
					}
				}
				BData.Add(table);
			}

			for (int i = 0; i < GroupInformation.Count; i++)
			{
				DataTable table = dtp.Clone();
				for (int a = 0; a < dtp.Rows.Count; a++)
				{
					if (GroupInformation[i] == dtp.Rows[a]["GroupName"].ToString())
					{
						table.Rows.Add(dtp.Rows[a].ItemArray);
					}
				}
				Measurements.Add(table);
			}
		}

		private bool HasDefaultGroupRule(OTSReport_Export export)
		{
			if (export?.m_mbszclass?.RuleGroup == null) return false;
			for (int i = 0; i < export.m_mbszclass.RuleGroup.Rows.Count; i++)
			{
				if (export.m_mbszclass.RuleGroup.Rows[i]["GroupId"].ToString() == "0")
					return true;
			}
			return false;
		}

		private void HandleNonDefaultGroup(DataTable m_bt_DBData, DataTable dtp)
		{
			// 筛选现有组
			List<string> strings = new List<string>();
			for (int i = 0; i < m_bt_DBData.Rows.Count; i++)
			{
				string gid = m_bt_DBData.Rows[i]["GroupId"].ToString();
				if (!strings.Contains(gid)) strings.Add(gid);
			}

			List<DataTable> OutData = new List<DataTable>();
			for (int i = 0; i < strings.Count; i++)
			{
				DataTable data = m_bt_DBData.Clone();
				for (int a = 0; a < m_bt_DBData.Rows.Count; a++)
				{
					if (strings[i] == m_bt_DBData.Rows[a]["GroupId"].ToString())
					{
						data.Rows.Add(m_bt_DBData.Rows[a].ItemArray);
					}
				}
				OutData.Add(data);
			}
			BData = OutData.Copy();

			Measurements = new List<DataTable>();
			for (int i = 0; i < GroupInformation.Count; i++)
			{
				DataTable table = dtp.Clone();
				for (int a = 0; a < dtp.Rows.Count; a++)
				{
					string strGroupId = "Default";
					if (dtp.Rows[a]["GroupName"].ToString() != "")
						strGroupId = dtp.Rows[a]["GroupName"].ToString();
					if (GroupInformation[i] == strGroupId)
					{
						table.Rows.Add(dtp.Rows[a].ItemArray);
					}
				}
				Measurements.Add(table);
			}
		}

		private void HandleSpecifiedGroups(c_TemplateClass m_mbszclass, DataTable m_bt_DBData, DataTable dtp, OTSReport_Export m_otsreport_export)
		{
			List<DataTable> SpecifyGroup = new List<DataTable>();
			for (int i = 0; i < m_mbszclass.List_data.Count; i++)
			{
				DataTable data = m_bt_DBData.Clone();

				bool b3 = false;
				string str_class = "";
				for (int a = 0; a < m_mbszclass.RuleGroup.Rows.Count; a++)
				{
					if (m_mbszclass.RuleGroup.Rows[a]["GroupId"].ToString() == m_mbszclass.List_data[i].TableName)
					{
						if (m_mbszclass.RuleGroup.Rows[a]["display"].ToString() == "1")
						{
							str_class = m_mbszclass.RuleGroup.Rows[a]["GroupName"].ToString();
							b3 = true;
						}
					}
				}
				data.TableName = m_mbszclass.List_data[i].TableName;
				if (b3)
				{
					for (int a = 0; a < m_mbszclass.List_data[i].Rows.Count; a++)
					{
						if (m_mbszclass.List_data[i].Rows[a]["display"].ToString() == "1")
						{
							DataTable data1 = m_bt_DBData.Clone();
							DataRow row = data.NewRow();
							row["TypeName"] = m_mbszclass.List_data[i].Rows[a]["StrName"];
							row["ar"] = 0;
							row["TypeId"] = m_mbszclass.List_data[i].Rows[a]["STDId"];
							row["GroupId"] = m_mbszclass.List_data[i].Rows[a]["GroupId"];
							row["con"] = 0;
							row["Largest"] = 0;
							row["Class"] = str_class;
							for (int j = 7; j < data.Columns.Count; j++)
							{
								row[j] = 0;
							}

							bool b2 = false;
							for (int j = 0; j < m_bt_DBData.Rows.Count; j++)
							{
								if (m_mbszclass.List_data[i].Rows[a]["STDId"].ToString() == m_bt_DBData.Rows[j]["TypeId"].ToString())
								{
									data1.Rows.Add(m_bt_DBData.Rows[j].ItemArray);
									b2 = true;
								}
							}
							if (b2)
							{
								data.Rows.Add(data1.Rows[0].ItemArray);
							}
							else
							{
								data.Rows.Add(row);
							}
						}
					}
				}
				SpecifyGroup.Add(data);
			}

			BData = SpecifyGroup.Copy();

			// 测量结果颗粒组队列（为指定组生成 Measurements）
			List<DataTable> datas1 = new List<DataTable>();
			ResultFile rstf = m_otsreport_export.m_ReportApp.m_rstDataMgr.ResultFilesList[m_otsreport_export.m_ReportApp.m_rstDataMgr.GetWorkingResultId()];
			UserSTDDbAccess dbAccess = new UserSTDDbAccess(rstf.GetSTDName(), rstf.FilePath);
			List<string> stringsa = dbAccess.ObtainParticleCategory(m_otsreport_export, this);
			for (int i = 0; i < stringsa.Count; i++)
			{
				DataTable data = dtp.Clone();
				for (int a = 0; a < dtp.Rows.Count; a++)
				{
					long typeId = 0;
					long.TryParse(dtp.Rows[a]["TypeId"].ToString(), out typeId);
					if (typeId > 10)
					{
						string strGroupName = "Default";
						if (dtp.Rows[a]["GroupName"].ToString() != "")
						{
							strGroupName = dtp.Rows[a]["GroupName"].ToString();
						}
						if (stringsa[i].ToString() == strGroupName)
						{
							data.Rows.Add(dtp.Rows[a].ItemArray);
						}
					}
				}
				datas1.Add(data);
			}

			Measurements = new List<DataTable>();
			for (int i = 0; i < m_mbszclass.List_data.Count; i++)
			{
				bool bdisplay = false;
				for (int a = 0; a < m_mbszclass.RuleGroup.Rows.Count; a++)
				{
					if (m_mbszclass.RuleGroup.Rows[a]["GroupId"].ToString() == m_mbszclass.List_data[i].TableName)
					{
						if (m_mbszclass.RuleGroup.Rows[a]["display"].ToString() == "1")
						{
							bdisplay = true;
						}
					}
				}

				if (bdisplay)
				{
					DataTable table = datas1[i].Clone();
					for (int a = 0; a < datas1[i].Rows.Count; a++)
					{
						for (int b = 0; b < m_mbszclass.List_data[i].Rows.Count; b++)
						{
							if (m_mbszclass.List_data[i].Rows[b]["display"].ToString() == "1")
							{
								if (datas1[i].Rows[a]["TypeId"].ToString() == m_mbszclass.List_data[i].Rows[b]["STDId"].ToString())
								{
									table.Rows.Add(datas1[i].Rows[a].ItemArray);
								}
							}
						}
					}
					Measurements.Add(table);
				}
			}
		}

		#endregion

		/// <summary>
		/// 拼接颗粒元素填充
		/// </summary>
		/// <param name="data"></param>
		/// <returns></returns>
		private DataTable SplicingParticleElementFilling(DataTable a_particlesAll, ParticlesGridDevidePage particlesGridDevide, DataTable userSTDDbData)
		{
			a_particlesAll.Columns.Add("Hardness");
			a_particlesAll.Columns.Add("Density");
			a_particlesAll.Columns.Add("Electrical_conductivity");

			if (userSTDDbData.Rows.Count > 0)
			{
				for (int i = 0; i < a_particlesAll.Rows.Count; i++)
				{
					DataRow[] dr = userSTDDbData.Select("STDId=" + a_particlesAll.Rows[i]["TypeId"].ToString());
					if (dr.Length > 0)
					{
						a_particlesAll.Rows[i]["Hardness"] = dr[0]["Hardness"].ToString();
						a_particlesAll.Rows[i]["Density"] = dr[0]["Density"].ToString();
						a_particlesAll.Rows[i]["Electrical_conductivity"] = dr[0]["Electrical_conductivity"].ToString();
					}
					else
					{
						a_particlesAll.Rows[i]["Hardness"] = "";
						a_particlesAll.Rows[i]["Density"] = "";
						a_particlesAll.Rows[i]["Electrical_conductivity"] = "";
					}
				}
			}
			else
			{
				for (int i = 0; i < a_particlesAll.Rows.Count; i++)
				{
					a_particlesAll.Rows[i]["Hardness"] = "";
					a_particlesAll.Rows[i]["Density"] = "";
					a_particlesAll.Rows[i]["Electrical_conductivity"] = "";
				}
			}


			DataTable elementchemistry = particlesGridDevide.Particledata.GetElementChemistry();
			for (int i = 0; i < a_particlesAll.Rows.Count; i++)
			{
				string str = "XRayId = " + a_particlesAll.Rows[i]["particleId"].ToString() + " and fieldid = " + a_particlesAll.Rows[i]["fieldid"].ToString();
				DataRow[] drs = elementchemistry.Select(str);
				string ConcatenatedString = "";
				for (int j = 0; j < drs.Length; j++)
				{
					ConcatenatedString += drs[j]["name"] + "-" + drs[j]["Percentage"] + ';';
				}
				a_particlesAll.Rows[i]["Element"] = ConcatenatedString;
			}
			a_particlesAll.Columns.Add("XRayDataCount");
			DataTable XRayData = particlesGridDevide.Particledata.GetXRayData();
			for (int i = 0; i < a_particlesAll.Rows.Count; i++)
			{
				string subt = a_particlesAll.Rows[i]["SubParticles"].ToString();
				if (subt == "")
				{
					a_particlesAll.Rows[i]["XRayDataCount"] = 0;
					string str = " XrayIndex= " + a_particlesAll.Rows[i]["particleId"].ToString() + " and fieldid = " + a_particlesAll.Rows[i]["fieldid"].ToString();
					DataRow[] drs = XRayData.Select(str);
					uint xraycount = 0;
					if (drs != null)
					{
						if (drs.Length > 0)
						{
							uint[] Analysis_xray = new uint[2000];
							for (int j = 0; j < 2000; j++)
							{
								Analysis_xray[j] = BitConverter.ToUInt32((byte[])drs[0][2], j * 4);
							}
							for (int j = 0; j < 2000; j++)
							{
								xraycount += Analysis_xray[j];
							}
							a_particlesAll.Rows[i]["XRayDataCount"] = xraycount;
						}
					}
				}
				else
				{

					a_particlesAll.Rows[i]["XRayDataCount"] = 0;
					DataRow dgvr = a_particlesAll.Rows[i];
					uint[] Search_xray = new uint[2000];
					uint[] Analysis_xray = new uint[2000];
					particlesGridDevide.Particledata.GetXrayByParticleTagIDAndFieldID_ForMergeParticle(Convert.ToInt32(dgvr["particleId"]), Convert.ToInt32(dgvr["fieldid"]), out Analysis_xray);
					uint xraycount = 0;
					for (int j = 0; j < 2000; j++)
					{
						xraycount += Analysis_xray[j];
					}
					a_particlesAll.Rows[i]["XRayDataCount"] = xraycount;
				}
			}
			return a_particlesAll;
		}


		/// <summary>
		/// 获取夹杂物组信息
		/// </summary>
		/// <returns></returns>

		public List<string> GetGroupInformation()
		{
			return GroupInformation;
		}
		/// <summary>
		/// 获取读取数据库并过滤颗粒
		/// </summary>
		/// <returns></returns>
		public List<DataTable> GetDBData()
		{
			return BData;
		}
		/// <summary>
		/// 获取读取数据库并过滤颗粒
		/// </summary>
		/// <returns></returns>
		public List<DataTable> etDBData()
		{
			return BData;
		}
		public void SetAllClass()
		{
			AllClass = fielddata.GetAllClass();
		}
		/// <summary>
		/// 获取全部大类
		/// </summary>
		/// <returns></returns>
		public DataTable GetAllClass()
		{
			return AllClass;
		}
		/// <summary>
		///测量结果数据列队
		/// </summary>
		/// <returns></returns>
		public List<DataTable> GetMeasurements()
		{
			return Measurements;

		}

		/// <summary>
		///拼接测量结果数据列队
		/// </summary>
		/// <returns></returns>
		public DataTable GetSpliceMeasurements()
		{
			return spliceMeasurements;

		}

		/// <summary>
		/// 定义ParticleData类
		/// </summary>
		public void newParticleData(OTSReport_Export m_otsreport_export)
		{
			fielddata = new ParticleData(m_otsreport_export.m_ReportApp.m_rstDataMgr.ResultFilesList[m_otsreport_export.m_ReportApp.m_rstDataMgr.GetWorkingResultId()].FilePath);
		}
		public ParticleData getParticleData()
		{
			return fielddata;
		}
		public void SetAllElement()
		{
			AllElement = fielddata.GetAllElement();
		}
		/// <summary>
		/// 获取全部元素
		/// </summary>
		/// <returns></returns>
		public DataTable GetAllElement()
		{
			return AllElement;
		}
		/// <summary>
		/// 判断是否有大分类，有为true
		/// </summary>
		/// <param name="m_otsreport_export"></param>
		/// <returns></returns>
		public void IsThereAMajorClassification(BasicData basicData, OTSReport_Export m_otsreport_export)
		{
			//List<string> ClassName = ObtainParticleCategory(m_otsreport_export, basicData);
			List<string> ClassName = new List<string>();

			for (int i = 0; i < BData.Count; i++)
			{
				if (BData[i].Rows.Count != 0)
				{
					ClassName.Add(i.ToString());
				}
			}

			if (ClassName.Count < 2)
			{
				IsShereAClassificationGroup = false;
			}
			else
			{
				IsShereAClassificationGroup = true;
			}
		}
		public bool GetIsThereAMajorClassification()
		{
			return IsShereAClassificationGroup;
		}



		public void IsResultFilesList(OTSReport_Export m_otsreport_export)
		{
			resfile = m_otsreport_export.m_ReportApp.m_rstDataMgr.ResultFilesList[m_otsreport_export.m_ReportApp.m_rstDataMgr.GetWorkingResultId()];
		}
		/// <summary>
		/// 获取标准库名称
		/// </summary>
		/// <returns></returns>
		public string GetResfile()
		{
			string str_libraryName = "";
			bool endsWithDb = resfile.GetSTDName().EndsWith(".db", StringComparison.OrdinalIgnoreCase);
			if (endsWithDb)
			{
				str_libraryName = resfile.GetSTDName();
			}
			else
			{
				str_libraryName = resfile.GetSTDName() + ".db";
			}
			return str_libraryName;
		}
		public void IsFilePath(OTSReport_Export m_otsreport_export)
		{
			FilePath = m_otsreport_export.m_ReportApp.m_rstDataMgr.CurResultFile.FilePath;
		}
		/// <summary>
		/// 得到文件路径
		/// </summary>
		/// <returns></returns>
		public string GetFilePath()
		{
			return FilePath;
		}

		#region 内部函数
		private string getWhere(string max, string min, string col, string partic)
		{
			if (col == "Area")
			{
				return col + ">=" + ((Convert.ToDouble(min) / 2) * (Convert.ToDouble(min) / 2) * Math.PI).ToString() + " and " + col + "<" + ((Convert.ToDouble(max) / 2) * (Convert.ToDouble(max) / 2) * Math.PI).ToString() + " and TypeId=" + partic;

			}
			else
			{
				return col + ">=" + min + " and " + col + "<" + max + " and TypeId=" + partic;
			}

		}
		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;
		}
		#endregion



	}
}