XdCxRhDW/XdCxRhDW.X2D1TaskServer/Tasks/X2D1Task.cs

using MySqlX.XDevAPI.Common;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using XdCxRhDW.Dto;

namespace XdCxRhDW.X2D1TaskServer.Tasks
{
    public class X2D1Task : HistoryTaskI
    {
        public override void Start(HistoryTaskProcessingDto dto)
        {
            IsRuning = true;
            TaskDto = dto;
            System.Threading.Tasks.Task.Run(async () =>
            {

                DateTime preTime = dto.StartTime;

                while (IsRuning || dto.EndTime.HasValue && dto.EndTime <= DateTime.Now)
                {
                    string capfile = Path.Combine(dto.CapDir, $"{preTime.ToString(dto.DateDirFormat)}");
                    IEnumerable<string> files;
                    try
                    {
                        if (!Directory.Exists(capfile))
                        {
                            LogHelper.Error($"【任务{dto.ID}】执行异常,路径[{capfile}]不存在!");
                            await Task.Delay(5000);
                            continue;
                        }
                        files = Directory.EnumerateFiles(capfile, "*.dat");
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error($"【任务{dto.ID}】执行异常.{ex.Message}", ex);
                        await Task.Delay(5000);
                        continue;
                    }
                    IOrderedEnumerable<IGrouping<DateTime, HistoryFile>> groups = null;
                    try
                    {
                        groups = files.Select(f => FileToHistoryFile(f)).GroupBy(m => m.CapTime).OrderBy(m => m.Key);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error($"【任务{dto.ID}】执行异常", ex);
                    }
                    foreach (var item in groups)
                    {
                        if (!IsRuning)
                        {
                            break;
                        }
                        var finfos = item.ToList();
                        if (finfos.Count < 3)
                        {
                            LogHelper.Warning($"【任务{dto.ID}】{finfos.First().CapTime:yyyyMMddHHmmss}时刻文件数量只有{finfos.Count}个,跳过此组数据");
                            continue;
                        }
                        //超短波信号
                        var dinfo = finfos.FirstOrDefault(m => m.Ch == 1);
                        if (dinfo == null)
                        {
                            LogHelper.Warning($"【任务{dto.ID}】{finfos.First().CapTime:yyyyMMddHHmmss}时刻未找到超短波信号ch1文件,跳过此组数据");
                            continue;
                        }
                        //主星
                        var minfo = finfos.FirstOrDefault(m => m.Ch == 2);
                        if (minfo == null)
                        {
                            LogHelper.Warning($"【任务{dto.ID}】{finfos.First().CapTime:yyyyMMddHHmmss}时刻未找到主星信号ch2文件,跳过此组数据");
                            continue;
                        }
                        //邻1
                        var ninfo = finfos.FirstOrDefault(m => m.Ch == 3);
                        if (ninfo == null)
                        {
                            LogHelper.Info($"【任务{dto.ID}】{finfos.First().CapTime:yyyyMMddHHmmss}时刻未找到邻星信号ch3文件,跳过此组数据");
                            continue;
                        }
                        try
                        {
                            var txInfos = await GetTxInfoAsync(dto);
                            var satTx = txInfos.First(t => t.TxType == EnumTxType.Rec);
                            var cdbTx = txInfos.First(t => t.TxType == EnumTxType.Cdb);
                            var refTx = txInfos.First(t => t.TxType == EnumTxType.Ref);
                            //根据信号类型执行检测或参数估计 
                            if (dto.SigType == EnumSigTypeDto.Normal)
                            {
                                var xd = await GPUCalcAsync(minfo.FilePath, dinfo.FilePath, minfo.FsHz, 260000, 40000);
                                var sx = await GPUCalcAsync(minfo.FilePath, ninfo.FilePath, minfo.FsHz, 0, 40000);
                                X2D1NoXlPosDto x2D1 = new X2D1NoXlPosDto()
                                {
                                    SigTime = minfo.CapTime,
                                    MainCode = minfo.SatId,
                                    AdjaCode = ninfo.SatId,
                                    SxDto = sx.Dt,
                                    XdDto = xd.Dt,
                                    SatTxLon = satTx.Lon,
                                    SatTxLat = satTx.Lat,
                                    CdbTxLon = cdbTx.Lon,
                                    CdbTxLat = cdbTx.Lat,
                                    RefLon = refTx.Lon,
                                    RefLat = refTx.Lat,
                                    FreqDown = minfo.FreqHz * 1e-6,
                                    FreqUp = dinfo.FreqHz * 1e-6,
                                    XdDfo = xd.Df,
                                    XdSnr = xd.Snr,
                                    SxDfo = sx.Df,
                                    SxSnr = sx.Snr,
                                };

                                await X2D1NoXlAsync(x2D1);
                            }
                            else
                            {
                                var mDetect = await DAMAAsync(dto.TaskCheckType, minfo.FsHz, minfo.FilePath);
                                var dfile = await ToResampleAsync((int)dinfo.FsHz, dinfo.FilePath);
                                var nfile = await ToResampleAsync((int)ninfo.FsHz, ninfo.FilePath);

                                if (mDetect.Count() <= 0)
                                {
                                    LogHelper.Warning($"【任务{dto.ID}】文件[{minfo.FilePath}]无检测结果");
                                    continue;
                                }
                                //主星文件
                                string mfile = mDetect.First().File1;

                                //时隙数
                                var smps = mDetect.Select(m => new SmpPosition() { smpStart = m.Start, smpCount = m.Length }).ToList();

                                int dtRange = 40000;
                                var xds = await CPUCalcAsync(mfile, dfile.File, dfile.OutFsHz, smps, -260000, dtRange);
                                var sxs = await CPUCalcAsync(mfile, nfile.File, nfile.OutFsHz, smps, 0, dtRange);

                                foreach (var sxitem in sxs)
                                {
                                    var xd = xds.FirstOrDefault(x => x.Smpstart == sxitem.Smpstart && x.Smplen == sxitem.Smplen);
                                    var deitem = mDetect.FirstOrDefault(x => x.Start == sxitem.Smpstart && x.Length == sxitem.Smplen);
                                    if (!IsRuning)
                                    {
                                        break;
                                    }

                                    X2D1NoXlPosDto x2D1 = new X2D1NoXlPosDto()
                                    {
                                        TaskID = dto.ID,
                                        SigTime = minfo.CapTime.AddSeconds(sxitem.Smpstart / nfile.OutFsHz),
                                        MainCode = minfo.SatId,
                                        AdjaCode = ninfo.SatId,
                                        SxDto = sxitem.Dt,
                                        XdDto = xd == null ? 0 : xd.Dt,
                                        SatTxLon = satTx.Lon,
                                        SatTxLat = satTx.Lat,
                                        CdbTxLon = cdbTx.Lon,
                                        CdbTxLat = cdbTx.Lat,
                                        RefLon = refTx.Lon,
                                        RefLat = refTx.Lat,
                                        FreqDown = minfo.FreqHz * 1e-6,
                                        FreqUp = dinfo.FreqHz * 1e-6,
                                        XdDfo = xd == null ? 0 : xd.Df,
                                        XdSnr = xd == null ? 0 : xd.Snr,
                                        SxDfo = sxitem.Df,
                                        SxSnr = sxitem.Snr,
                                        CheckRes = new CheckResDto()
                                        {
                                            FileName = deitem.File1,
                                            ModRate = deitem.ModRate,
                                            ModType = deitem.ModType,
                                            SmpCount = deitem.Length,
                                            SmpStart = deitem.Start,
                                            UserName = deitem.UserName,
                                            PosCheckType = deitem.DmcType.GetEnumByDisplayName<EnumPosCheckTypeDto>(),
                                        }
                                    };
                                    await X2D1NoXlAsync(x2D1);
                                }

                            }
                        }
                        catch (Exception ex)
                        {
                            LogHelper.Info($"【任务{dto.ID}】执行异常:{ex.Message}");
                            continue;
                        }

                    }
                    preTime = preTime.AddHours(1);
                }

            });
        }


        private async Task X2D1NoXlAsync(X2D1NoXlPosDto x2D1)
        {
            try
            {
                var result = await HttpHelper.PostRequestAsync<PosResDto>(baseUrl + "Pos/PosX2D1NoXlAsync", x2D1);
                if (result.code != 200)
                {
                    LogHelper.Error($"【任务{x2D1.TaskID}】定位异常.{result.msg}");
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"【任务{x2D1.TaskID}】定位异常.", ex);
            }
        }

        private async Task<List<TxInfo>> GetTxInfoAsync(HistoryTaskProcessingDto dto)
        {
            List<TxInfo> infos = new List<TxInfo>();
            try
            {
                var result = await HttpHelper.GetRequestAsync<(TxInfo recTx, TxInfo cdbTx, TxInfo cxTx, TxInfo refLoc)>(baseUrl + "Tx/GetTxInfoAsync");
                if (result.code != 200)
                {
                    LogHelper.Error($"【任务{dto.ID}】获取天线信息异常.{result.msg}");
                    return infos;
                }
                infos.Add(result.data.recTx == null ? new TxInfo() { TxType = EnumTxType.Rec } : result.data.recTx);
                infos.Add(result.data.cdbTx == null ? new TxInfo() { TxType = EnumTxType.Cdb } : result.data.cdbTx);
                infos.Add(result.data.cxTx == null ? new TxInfo() { TxType = EnumTxType.Cx } : result.data.cxTx);
                infos.Add(result.data.refLoc == null ? new TxInfo() { TxType = EnumTxType.Ref } : result.data.refLoc);
                return infos;
            }
            catch (Exception ex)
            {
                LogHelper.Error($"【任务{dto.ID}】获取天线信息异常.", ex);
                return infos;
            }
        }

        /// <summary>
        /// 获取采集文件信息
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        private HistoryFile FileToHistoryFile(string filePath)
        {  //读取采集文件
           //2024_01_31_10_01_51_000000000_ch11_-1_＿Nxx.xxxxxx_Exx.xxxxxx_xxxxx.xxxHz_xxx.xxxMHz_ch1_xd1.dat
            HistoryFile historyFile = new HistoryFile();
            historyFile.FilePath = filePath;
            var fileName = Path.GetFileNameWithoutExtension(filePath);
            var strs = fileName.Split(new string[] { "_", "MHz", "Hz", "ch" }, StringSplitOptions.RemoveEmptyEntries);

            //采集时间
            var datestr = string.Join("_", strs.Take(6));
            DateTime dateTime;
            bool istime = DateTime.TryParseExact(datestr, "yyyy_MM_dd_HH_mm_ss", null, DateTimeStyles.None, out dateTime);
            if (!istime) return historyFile;
            historyFile.CapTime = dateTime;


            //采集通道
            var chstr = strs.Skip(strs.Length - 2).Take(1).First();
            int ch;
            int.TryParse(chstr, out ch);

            //采集频点
            var freqstr = strs.Skip(strs.Length - 3).Take(1).First();
            double freqMHz;
            double.TryParse(freqstr, out freqMHz);

            //采样率
            var fsstr = strs.Skip(strs.Length - 4).Take(1).First();
            double fsHz;
            double.TryParse(fsstr, out fsHz);

            historyFile.FreqHz = freqMHz * 1e6;
            historyFile.Ch = ch;
            historyFile.FsHz = fsHz;
            if (ch > 1)
            {
                historyFile.SatId = GetSatId(historyFile.FreqHz);

            }
            return historyFile;

        }

    }
}