XdCxRhDW/XdCxRhDW.App/FindRef/PosWithRefFind.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using XdCxRhDW.Dto;
using XdCxRhDW.Entity;
using XdCxRhDW.Repostory;

namespace XdCxRhDW.App
{

    public class PosWithRefFind
    {
        /// <summary>
        /// 任务编号
        /// </summary>
        private int _taskId;

        public void Start(int taskId, CancellationToken token)
        {
            this._taskId = taskId;
            Task.Run(async () =>
            {

                while (!token.IsCancellationRequested)
                {
                    try
                    {
                        var taskTars = TaskTarCache.Instance.GetTaskTar(_taskId);
                        if (taskTars.Count == 0)
                        {
                            await Task.Delay(5000);
                            LogHelper.Info($"等待任务[{_taskId}]添加目标信号缓存").Wait(5000);
                            continue;
                        }
                        var taritem = taskTars[0];
                        var refcgDto = GetRefCg(taritem, out bool needWait);
                        if (needWait)
                        {
                            await Task.Delay(10 * 1000);
                            continue;
                        }

                        if (refcgDto.MainYbDto == 0 || refcgDto.AdjaYbDto == 0)
                        {
                            await SendX2D1NoXlNoParAsync(taritem);
                        }
                        else
                        { //执行两星一地有参定位
                            X2D1NoXlPosDto X2D1NoXlPosDto = new X2D1NoXlPosDto()
                            {
                                SigTime = taritem.SigTime,
                                MainCode = taritem.MainCode,
                                AdjaCode = taritem.AdjaCode,
                                SxDto = taritem.SxDto,
                                XdDto = taritem.XdDto,
                                MainYbDto = refcgDto.MainYbDto,
                                AdjaYbDto = refcgDto.AdjaYbDto,
                                SatTxLon = taritem.SatTxLon,
                                SatTxLat = taritem.SatTxLat,
                                CdbTxLon = taritem.CdbTxLon,
                                CdbTxLat = taritem.CdbTxLat,
                                RefLon = refcgDto.FixedLon,
                                RefLat = refcgDto.FixedLat,
                                FreqDown = taritem.FreqDown,
                                FreqUp = taritem.FreqUp,
                                XdDfo = taritem.XdDfo,
                                XdSnr = taritem.XdSnr,
                                SxDfo = taritem.SxDfo,
                                SxSnr = taritem.SxSnr,
                                CalcConfidence = true,
                                TheoryDfoCalc = true,
                                TaskID = taritem.TaskID,
                                CheckRes = taritem.CheckRes,
                            };
                            await SendX2D1RefAsync(X2D1NoXlPosDto);
                        }
                        TaskTarCache.Instance.Remove(_taskId, taritem);
                        TaskRefCache.Instance.ClearExpireRef(_taskId);
                    }
                    catch (Exception ex)
                    {

                        await LogHelper.Error($"【启动任务[{this._taskId}]目标取参考信号缓存异常{ex.Message}", ex);
                    }

                }
                await ClearCacheAsync(_taskId);

            });
        }
        /// <summary>
        /// 获取参考参估
        /// </summary>
        /// <param name="taritem"></param>
        /// <param name="needWait"></param>
        /// <returns></returns>
        public TaskCgDto GetRefCg(X2D1NoXlNoParlPosDto taritem, out bool needWait)
        {
            needWait = true;
            var cgdto = new TaskCgDto();
            var _tarkRefTime = TaskTarCache.Instance.TakeRefTimeSeconds;
            DateTime startTime = taritem.SigTime.AddSeconds(-_tarkRefTime);
            DateTime endTime = taritem.SigTime.AddSeconds(_tarkRefTime);
            //获取指定任务时间范围内的参考信号
            var taskRefs = TaskRefCache.Instance.GetTaskRef(_taskId, startTime, endTime);
            //没有参考信号时 做无参考
            if (taskRefs.Count == 0)
            {
                needWait = false;
                return cgdto;
            }
            var cgOrderList = taskRefs.OrderBy(d => d.SigTime).ToList();//注意记得时间排序，根据时间取最接近的信号时刻
            var point1s = cgOrderList.Where(c => c.SigTime <= taritem.SigTime);
            var point2s = cgOrderList.Where(c => c.SigTime >= taritem.SigTime);
            if (point2s == null || point2s.Count() == 0)//若没有比目标信号时刻大的参考信号则需要等待
            {
                needWait = true;
                return null;
            }
            var point1 = point1s.Where(c => c.YbSnr != 0).FirstOrDefault();
            var point2 = point2s.Where(c => c.YbSnr != 0).FirstOrDefault();

            if (point2 == null || point1 == null)//若查找到比目标信号时刻大的参考信号信噪比为0则表示参考信号已经做过了
            {
                cgdto.MainYbDto = 0;
                cgdto.AdjaYbDto = 0;
            }
            else
            {
                double refMainYbDto = LinearInterpolation.CalSigTimeDto(taritem.SigTime, point1.SigTime, point2.SigTime, point1.MainYbDto, point2.MainYbDto);
                double refAdjaYbDto = LinearInterpolation.CalSigTimeDto(taritem.SigTime, point1.SigTime, point2.SigTime, point1.AdjaYbDto, point2.AdjaYbDto);
                cgdto.MainYbDto = refMainYbDto;
                cgdto.AdjaYbDto = refAdjaYbDto;
                cgdto.FixedLon = point1.FixedLon;
                cgdto.FixedLat = point1.FixedLat;

            }
            needWait = false;
            return cgdto;
        }

        /// <summary>
        /// 发送两星一地无参定位
        /// </summary>
        /// <param name="dto"></param>
        private async Task SendX2D1NoXlNoParAsync(X2D1NoXlNoParlPosDto dto)
        {
            try
            {
                var result = await HttpHelper.PostRequestAsync<PosResDto>(SysConfig.GetUrl("Pos/PosX2D1NoXlNoParAsync"), dto);
                if (result.code != 200)
                {
                    await LogHelper.Error($"找参考任务{dto.TaskID}-{dto.SigTime:yyyy-MM-dd HH:mm:ss}两星一地无参定位失败{result.msg}");

                }
                else
                {
                    await LogHelper.Info($"找参考任务{dto.TaskID}-{dto.SigTime:yyyy-MM-dd HH:mm:ss}两星一地无参定位完成{result.msg}");
                }
            }
            catch (Exception ex)
            {
                await LogHelper.Error($"找参考任务{dto.TaskID}-{dto.SigTime:yyyy-MM-dd HH:mm:ss}两星一地无参定位失败{ex.Message}");
            }

        }

        /// <summary>
        /// 发送两星一地无参定位
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task SendX2D1RefAsync(X2D1NoXlPosDto dto)
        {
            try
            {
                var result = await HttpHelper.PostRequestAsync<PosResDto>(SysConfig.GetUrl("Pos/PosX2D1NoXlAsync"), dto);
                if (result.code != 200)
                {
                    await LogHelper.Error($"找参考任务{dto.TaskID}-{dto.SigTime:yyyy-MM-dd HH:mm:ss}两星一地定位失败{result.msg}");
                }
                else
                {
                    await LogHelper.Info($"找参考任务{dto.TaskID}-{dto.SigTime:yyyy-MM-dd HH:mm:ss}两星一地定位完成{result.msg}");
                }
            }
            catch (Exception ex)
            {
                await LogHelper.Error($"找参考任务{dto.TaskID}-{dto.SigTime:yyyy-MM-dd HH:mm:ss}两星一地定位失败{ex.Message}");
            }
        }
        public async Task ClearCacheAsync(int taskID)
        {
            try
            {
                await Task.Run(() =>
                {
                    TaskTarCache.Instance.ClearCache(taskID);
                    TaskRefCache.Instance.ClearCache(taskID);
                });
                await LogHelper.Info($"【停止任务[{this._taskId}]目标取参考信号缓存");
            }
            catch (Exception ex)
            {
                await LogHelper.Error($"【清除任务[{taskID}]目标参考信号缓存异常{ex.Message}", ex);
            }


        }

        public async Task ClearAllAsync()
        {
            try
            {
                await Task.Run(() =>
                {
                    TaskTarCache.Instance.ClearAll();
                    TaskRefCache.Instance.ClearAll();
                });
                await LogHelper.Info($"【停止所有任务目标取参考信号缓存");
            }
            catch (Exception ex)
            {
                await LogHelper.Error($"【清除所有目标参考信号缓存异常{ex.Message}", ex);
            }

        }



    }
}