/// <summary>获取时间窗口</summary>
/// <param name="rt">保留时间</param>
/// <param name="pim">定性方法</param>
/// <returns></returns>
public static double GetTimeBand(double rt, PeakIdentificationMethod pim)
{
double _band = 0.0;
if (pim.Time_Method == PeakIdentificationMethod.TimeMethod.tm_window)
{
_band = rt * pim.TimeWindow;
}
else
{
_band = pim.TimeBand;
}
return(_band);
}
private static List <Peak> GetAverStandardPeakList(List <PeakAndPointList> unknown_std_papl, List <Peak> standard_list, PeakIdentificationMethod pim, PeakQuantificationMethod pqm)
{
QualitativeErrorInfo _rc = QualitativeErrorInfo.Success;
if ((unknown_std_papl == null) || (unknown_std_papl.Count == 0) || (standard_list == null) || (standard_list.Count == 0))
{
return(null);
}
int[] _std_count = new int[standard_list.Count];
double[] _std_rt = new double[standard_list.Count];
List <Peak> _aver_std_list = new List <Peak>();
for (int i = 0; i < standard_list.Count; i++)
{
_std_count[i] = 0;
_std_rt[i] = 0;
Peak _p = new Peak();
_p.Name = standard_list[i].Name;
_p.Checked = true;
_p.Index = i;
_aver_std_list.Add(_p);
}
foreach (PeakAndPointList _papl in unknown_std_papl)
{
List <Peak> _unknown_std_list = _papl.PeakList.FindAll(CPeakFilter.FindNaturalPeak);
if (_unknown_std_list == null)
{
continue;
}
//定性标样峰
List <Peak> _target_list = CIdentificationFactory.Identify(standard_list, _unknown_std_list, pim);
if (_target_list == null)
{
continue;
}
_rc = CQuantificationFactory.GetAdjustFactor(_target_list, pqm); //计算校正因子
if (_rc != QualitativeErrorInfo.Success)
{
continue;
}
foreach (Peak _p in _aver_std_list)
{
foreach (Peak _p0 in _target_list)
{
if (_p.Name == _p0.Name)
{
_p.Capacity += _p0.Capacity;
_p.PeakHeight += _p0.PeakHeight;
_p.PeakArea += _p0.PeakArea;
_p.AdjustFactor += _p0.AdjustFactor;
_std_count[_p.Index]++;
_std_rt[_p.Index] += _p0.PeakPoint.X;
_target_list.Remove(_p0);
break;
}
}
}
}
foreach (Peak _p in _aver_std_list)
{
int _count = _std_count[_p.Index];
_std_rt[_p.Index] /= _count;
_p.Capacity /= _count;
_p.PeakHeight /= _count;
_p.PeakArea /= _count;
_p.AdjustFactor /= _count;
_p.PeakPoint = new PointF((float)_std_rt[_p.Index], 0);
}
return((_aver_std_list.Count > 0) ? _aver_std_list : null);
}
/// <summary>定性方法</summary>
/// <param name="std_pl">标样峰对象列表</param>
/// <param name="unknown_pl">未知样峰对象列表</param>
/// <param name="pim">定性参数</param>
/// <returns>返回识别峰列表</returns>
public static List <Peak> Identify(List <Peak> std_peak_list, List <Peak> unknown_peak_list, PeakIdentificationMethod pim)
{
switch (pim.Identification_Method)
{
case PeakIdentificationMethod.IdentificationMethod.im_relative:
//return CIdentificationRelative.IdentifyPeakList(std_peak_list, unknown_peak_list, pim);
return(_IdRelative.IdentifyPeakList(std_peak_list, unknown_peak_list, pim));
case PeakIdentificationMethod.IdentificationMethod.im_absolute:
default:
return(_IdAbsolute.IdentifyPeakList(std_peak_list, unknown_peak_list, pim));
//return CIdentificationAbsolute.IdentifyPeakList(std_peak_list, unknown_peak_list, pim);
}
}
/// <summary>相对保留时间定性方法</summary>
/// <param name="std_pl">标样峰对象列表</param>
/// <param name="unknown_pl">未知样峰对象列表</param>
/// <param name="pim">定性参数</param>
/// <returns>QualitativeErrorInfo枚举</returns>
public override List <Peak> IdentifyPeakList(List <Peak> std_peak_list, List <Peak> unknown_peak_list, PeakIdentificationMethod pim)
{
try
{
List <Peak> _valid_standard_list = std_peak_list.FindAll(CPeakFilter.FindCheckedPeak); //获取标样峰列表中的有效峰
List <Peak> _valid_unknown_list = unknown_peak_list.FindAll(CPeakFilter.FindNaturalPeak); //获取未知样峰列表中的有效峰
List <Peak> _std_ref_list = _valid_standard_list.FindAll(CPeakFilter.FindReferencePeak); //查找标样中的参考峰
//定性未知样中的参考物
List <Peak> _unknown_ref_list = base.IdentifyPeakList(_std_ref_list, _valid_unknown_list, pim);
if ((_unknown_ref_list == null) || (_unknown_ref_list.Count == 0) || (_unknown_ref_list.Count != _std_ref_list.Count))
{
return(null);
}
List <Peak> _target_list = new List <Peak>();
//定性未知样中的其他物质
//______/\_________/\_________/\___________
int _standard_ref_index = _valid_standard_list.IndexOf(_std_ref_list[0]);
int _unknown_ref_index = _valid_unknown_list.IndexOf(_unknown_ref_list[0]);
List <Peak> _valid_standard_peaks = _valid_standard_list.GetRange(0, _standard_ref_index); //第一个参考峰之前的标准峰
List <Peak> _valid_unknown_peaks = _valid_unknown_list.GetRange(0, _unknown_ref_index); //第一个参考峰之前的未知峰
//定性第一个参考峰之前的未知峰，单参考峰定性方法
List <Peak> _return_peaks = IdentifyPeakList(_valid_standard_peaks, _valid_unknown_peaks, _std_ref_list[0], _unknown_ref_list[0], pim);
_valid_standard_list.RemoveRange(0, _standard_ref_index);
_valid_unknown_list.RemoveRange(0, _unknown_ref_index);
if (_return_peaks != null)
{
_target_list.AddRange(_return_peaks);
}
//两个参考峰之间的标准峰
for (int i = 0; i < _std_ref_list.Count - 1; i++)
{
_standard_ref_index = _valid_standard_list.IndexOf(_std_ref_list[i]) + 1;
_unknown_ref_index = _valid_unknown_list.IndexOf(_unknown_ref_list[i]) + 1;
int _standard_peaks = _valid_standard_list.IndexOf(_std_ref_list[i + 1]) - _standard_ref_index;
if (_standard_peaks == 0)
{
continue;
}
int _unknown_peaks = _valid_unknown_list.IndexOf(_unknown_ref_list[i + 1]) - _unknown_ref_index;
if (_unknown_peaks == 0)
{
continue;
}
_valid_standard_peaks = _valid_standard_list.GetRange(_standard_ref_index, _standard_peaks);
if (_valid_standard_peaks == null)
{
continue;
}
_valid_unknown_peaks = _valid_unknown_list.GetRange(_unknown_ref_index, _unknown_peaks);
if (_valid_unknown_peaks == null)
{
continue;
}
List <Peak> _standard_ref_tmp = _std_ref_list.GetRange(i, 2);
List <Peak> _unknown_ref_tmp = _unknown_ref_list.GetRange(i, 2);
foreach (Peak _p in _valid_standard_peaks)
{
Peak _target_peak = IdentifyPeak(_valid_unknown_peaks, _standard_ref_tmp, _unknown_ref_tmp, _p.PeakPoint.X, pim);
if (_target_peak != null)
{
UpdatePeakInfo(_target_peak, _p, true);
_valid_unknown_peaks.RemoveRange(0, _valid_unknown_peaks.IndexOf(_target_peak) + 1);
_target_list.Add(_target_peak);
}
}
}
//最后一个参考峰之后的标准峰
int _last_index = _std_ref_list.Count - 1;
_standard_ref_index = _valid_standard_list.IndexOf(_std_ref_list[_last_index]);
_unknown_ref_index = _valid_unknown_list.IndexOf(_unknown_ref_list[_last_index]);
_valid_standard_peaks = _valid_standard_list.GetRange(_standard_ref_index, _valid_standard_list.Count - _standard_ref_index - 1); //最后一个参考峰之后的未知峰
_valid_unknown_peaks = _valid_unknown_list.GetRange(_unknown_ref_index, _valid_unknown_list.Count - _unknown_ref_index - 1); //定性最后一个参考峰之后的未知峰
_return_peaks = IdentifyPeakList(_valid_standard_peaks, _valid_unknown_peaks, _std_ref_list[_last_index], _unknown_ref_list[_last_index], pim);
if (_return_peaks != null)
{
_target_list.AddRange(_return_peaks);
}
return((_target_list.Count > 0) ? _target_list : null);
}
catch (System.Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
/// <summary>相对保留时间定性方法，单参考峰</summary>
/// <param name="std_peak_list">标样峰列表</param>
/// <param name="unknown_peak_list">未知样峰列表</param>
/// <param name="std_ref">标样中的参考峰</param>
/// <param name="unknown_ref">未知样中的参考峰</param>
/// <param name="pim">定性参数</param>
/// <returns>成功匹配的峰对象</returns>
public List <Peak> IdentifyPeakList(List <Peak> std_peak_list, List <Peak> unknown_peak_list, Peak std_ref, Peak unknown_ref, PeakIdentificationMethod pim)
{
if ((std_peak_list == null) || (unknown_peak_list == null))
{
return(null);
}
//获取有效峰列表
List <Peak> _standard_list = std_peak_list.FindAll(CPeakFilter.FindCheckedPeak);
if (_standard_list == null)
{
return(null);
}
List <Peak> _unknown_list = unknown_peak_list.FindAll(CPeakFilter.FindNaturalPeak);
if (_unknown_list == null)
{
return(null);
}
List <Peak> _target_list = new List <Peak>();
foreach (Peak _p in std_peak_list)
{
Peak _target_peak = IdentifyPeak(_unknown_list, std_ref, unknown_ref, _p.PeakPoint.X, pim);
if (_target_peak != null)
{
UpdatePeakInfo(_target_peak, _p, true);
_unknown_list.RemoveRange(0, _unknown_list.IndexOf(_target_peak) + 1);
_target_list.Add(_target_peak);
}
}
return((_target_list.Count > 0) ? _target_list : null);
}
/// <summary>相对保留时间定性方法，多参考峰</summary>
/// <param name="peak_list">未知样峰对象列表</param>
/// <param name="std_ref_list">标样中的参考峰列表</param>
/// <param name="measure_ref_list">未知样中的参考峰列表</param>
/// <param name="std_rt">保留时间</param>
/// <param name="pim">定性参数</param>
/// <returns>成功匹配的峰对象</returns>
public Peak IdentifyPeak(List <Peak> peak_list, List <Peak> std_ref_list, List <Peak> unknown_ref_list, double std_rt, PeakIdentificationMethod pim)
{
if ((peak_list == null) || (std_ref_list == null) || (unknown_ref_list == null))
{
return(null);
}
if ((std_ref_list.Count != 2) || (unknown_ref_list.Count != 2))
{
return(null);
}
List <Peak> _target_list = new List <Peak>();
double _band = CTimeBand.GetTimeBand(std_rt, pim);
double _corr_rt = 0.0, _delta_time = 0.0;
foreach (Peak _p in peak_list)
{
//if (!FilterPeak(_p)) continue;
_corr_rt = ((_p.PeakPoint.X - unknown_ref_list[0].PeakPoint.X) / (unknown_ref_list[1].PeakPoint.X - unknown_ref_list[0].PeakPoint.X)) * (std_ref_list[1].PeakPoint.X - std_ref_list[0].PeakPoint.X) + std_ref_list[0].PeakPoint.X;
_delta_time = Math.Abs(_corr_rt - std_rt);
if (_delta_time <= _band)
{
_target_list.Add(_p);
}
}
return(CPeakSelect.PeakSelect(_target_list, std_rt, pim.PeakSelect_Method));
}
/// <summary>相对保留时间定性方法，单参考峰</summary>
/// <param name="peak_list">未知样峰对象列表</param>
/// <param name="std_ref">标样中的参考峰</param>
/// <param name="measure_ref">未知样中的参考峰</param>
/// <param name="std_rt">保留时间</param>
/// <param name="pim">定性参数</param>
/// <returns>成功匹配的峰对象</returns>
public Peak IdentifyPeak(List <Peak> peak_list, Peak std_ref, Peak unknown_ref, double std_rt, PeakIdentificationMethod pim)
{
if ((std_ref == null) || (unknown_ref == null) || (peak_list == null))
{
return(null);
}
if (unknown_ref.PeakPoint.X == 0)
{
return(null);
}
List <Peak> _target_list = new List <Peak>();
double _band = CTimeBand.GetTimeBand(std_rt, pim);
double _delta_time = 0.0;
foreach (Peak _p in peak_list)
{
//if (!FilterPeak(_p)) continue;
_delta_time = Math.Abs(std_rt - (std_ref.PeakPoint.X / unknown_ref.PeakPoint.X) * _p.PeakPoint.X);
if (_delta_time <= _band)
{
_target_list.Add(_p);
}
}
return(CPeakSelect.PeakSelect(_target_list, std_rt, pim.PeakSelect_Method));
}
/// <summary>绝对保留时间定性方法</summary>
/// <param name="std_peak_list">标样峰对象列表</param>
/// <param name="unknown_peak_list">未知样峰对象列表</param>
/// <param name="pim">定性参数</param>
/// <returns>返回识别的峰列表</returns>
public virtual List <Peak> IdentifyPeakList(List <Peak> std_peak_list, List <Peak> unknown_peak_list, PeakIdentificationMethod pim)
{
try
{
//获取有效峰列表
List <Peak> _standard_list = std_peak_list.FindAll(CPeakFilter.FindCheckedPeak);
if (_standard_list == null)
{
return(null);
}
List <Peak> _unknown_list = unknown_peak_list.FindAll(CPeakFilter.FindNaturalPeak);
if (_unknown_list == null)
{
return(null);
}
List <Peak> _target_list = new List <Peak>();
//峰匹配过程
Peak _p, _pnext;
double next_sdt_rt = 0.0;
for (int i = 0; i < _standard_list.Count; i++)
{
_p = _standard_list[i];
if (i < (_standard_list.Count - 1))
{
_pnext = _standard_list[i + 1];
next_sdt_rt = _pnext.PeakPoint.X;
}
else
{
next_sdt_rt = double.MaxValue;
}
Peak _target_peak = IdentifyPeak(_unknown_list, _p.PeakPoint.X, next_sdt_rt, pim);
if (_target_peak != null)
{
UpdatePeakInfo(_target_peak, _p, true);
//将已经匹配过的峰从列表中移出，加速匹配过程
_unknown_list.RemoveRange(0, _unknown_list.IndexOf(_target_peak) + 1);
_target_list.Add(_target_peak);
}
}
return((_target_list.Count > 0) ? _target_list : null);
}
catch (System.Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
/// <summary>绝对保留时间定性方法</summary>
/// <param name="peakList">未知样峰对象列表</param>
/// <param name="std_rt">保留时间</param>
/// <param name="pim">定性参数</param>
/// <returns>成功匹配的峰对象</returns>
public Peak IdentifyPeak(List <Peak> peak_list, double std_rt, double next_std_rt, PeakIdentificationMethod pim)
{
if (peak_list == null)
{
return(null);
}
List <Peak> _target_peak_list = new List <Peak>();
double _band = CTimeBand.GetTimeBand(std_rt, pim);
double _delta_time = 0.0, _delta_time_for_next_std = 0.0;
foreach (Peak _p in peak_list)
{
//if (!FilterPeak(_p)) continue;
_delta_time = Math.Abs(std_rt - _p.PeakPoint.X);
_delta_time_for_next_std = Math.Abs(next_std_rt - _p.PeakPoint.X);
if ((_delta_time <= _band) && (_delta_time <= _delta_time_for_next_std))
{
_target_peak_list.Add(_p);
}
}
return(CPeakSelect.PeakSelect(_target_peak_list, std_rt, pim.PeakSelect_Method));
}
