/// <summary> /// 构造函数 /// </summary> /// <param name="CurrentMaterial"></param> /// <param name="BaseSiteName"></param> /// <param name="CurrentBasePrn"></param> public DifferCoeffBuilder(MultiSiteEpochInfo CurrentMaterial, string BaseSiteName, SatelliteNumber CurrentBasePrn, bool isSingleObs = false) { this.CurrentMaterial = CurrentMaterial; this.CurrentBasePrn = CurrentBasePrn; this.isSingleObs = isSingleObs; this.BaseSiteName = BaseSiteName; }
/// <summary> /// 双差网解定位。具有模糊度。 /// </summary> /// <param name="mInfo">历元观测信息</param> /// <param name="Adjustment"></param> /// <param name="positioner"></param> /// <param name="baseSatPrn"></param> /// <param name="baseParamCount"></param> public NetDoubleDifferPositionResult( MultiSiteEpochInfo mInfo, AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner, SatelliteNumber baseSatPrn, int baseParamCount = 5 ) : base(mInfo, Adjustment, positioner) { //设置第一个流动站坐标改正数 int i = 0; var estmated = this.ResultMatrix.Estimated; foreach (var paramName in estmated.ParamNames) { if (paramName.Contains(Gnsser.ParamNames.Dx)) { double x = estmated[i]; double y = estmated[i + 1]; double z = estmated[i + 2]; this.XyzCorrection = new XYZ(x, y, z); break; } } }
/// <summary> /// 登记记录 /// </summary> /// <param name="material"></param> public void Record(MultiSiteEpochInfo material) { foreach (var item in material) { this.GetOrCreate(item.Name).Record(item); } }
public void Add(MultiSiteEpochInfo mEpochInfo) { foreach (var item in mEpochInfo) { this.GetOrCreate(item.SiteName).Add(item); } }
/// <summary> /// 矫正 /// </summary> /// <param name="multiSiteEpochInfo"></param> /// <returns></returns> public virtual bool Revise(ref MultiSiteEpochInfo multiSiteEpochInfo) { bool a = true; if (Option.GnssSolverType == Gnsser.GnssSolverType.钟差网解)//并行计算 { //首先对各个单独的历元的并行矫正 ParallelOptions option = new ParallelOptions(); List <EpochInformation> list = new List <EpochInformation>(); Parallel.ForEach(multiSiteEpochInfo, option, (EpochInfo, state) => { var val = EpochInfo; var reviser = this[EpochInfo.Name]; if (this.Buffers != null) { reviser.Buffers = GetEpochBuffers(EpochInfo.Name); } if (!reviser.Revise(ref val)) { a = false; //return false; } else { log.Debug(EpochInfo.Name + EpochInfo.ReceiverTime + "检核不通过");//list.Add(EpochInfo); } }); } else//串行计算 { //首先对各个单独的历元的矫正 foreach (var epochInfo in multiSiteEpochInfo) { var val = epochInfo; var reviser = this[epochInfo.Name]; //若缓存为null表示,为初始校验 if (this.Buffers != null) { reviser.Buffers = GetEpochBuffers(epochInfo.Name); } if (!reviser.Revise(ref val)) { return(false); } } } if (a == false) { return(false); } //最后检查卫星是否相同 if (Option.IsSameSatRequired) { multiSiteEpochInfo.DisableDifferSats(); } return(true); }
/// <summary> /// 非差轨道确定 /// </summary> /// <param name="epochInfo">历元信息</param> /// <param name="Adjustment">平差信息</param> /// <param name="ClockEstimationer">钟差估计器</param> /// <param name="previousResult">上一历元结果</param> public ZeroDifferOrbitResult( MultiSiteEpochInfo epochInfo, AdjustResultMatrix Adjustment, ZeroDifferOrbitParamNameBuilder ClockEstimationer, MultiSiteGnssExtentResult previousResult = null) : base(epochInfo, Adjustment, ClockEstimationer) { }
/// <summary> /// 计算 /// </summary> /// <param name="mEpochInfo"></param> public override void Process(MultiSiteEpochInfo mEpochInfo) { var val = mEpochInfo; //计算宽项模糊度 MsiteMwWideLaneProcesser.Buffers = BufferedStream.MaterialBuffers; MsiteMwWideLaneProcesser.Revise(ref val); }
public override BaseGnssResult Produce(MultiSiteEpochInfo material) { //采用导航星历计算卫星初始坐标 var ephService = GlobalNavEphemerisService.Instance; RangeOrbitResult result = null; RangeOrbitResult prevResult = null; double timeDiffer = 1; int loopCount = 0; double loopThreshold = 100 / GnssConst.LIGHT_SPEED; do { prevResult = result; foreach (var site in material) { foreach (var sat in site) { if (prevResult == null) { var emissionTime = sat.RecevingTime - sat.GetTransitTime(); var eph = ephService.Get(sat.Prn, emissionTime);//不改正相对论、钟差等 sat.Ephemeris = eph; } else { var ephResult = prevResult.EphemerisResults.Get(sat.Prn); sat.Ephemeris = ephResult.Corrected; } //卫星钟差改正,根据计算的卫星钟差改正距离 new Gnsser.Correction.SatClockBiasCorrector().Correct(sat); } //直接计算,不用改正 //EpochEphemerisSetter.ReviseEphemerisOnly(site); } double old = 0d; if (prevResult != null) { old = prevResult.MaterialObj.BaseEpochInfo.Time.Correction; } result = (RangeOrbitResult)base.Produce(material); if (prevResult != null) { timeDiffer = old - result.MaterialObj.BaseEpochInfo.Time.Correction; int ii = 0; } if (loopCount > 6) { log.Error("迭代次数达到 " + loopCount + " 次,似乎不收敛!" + timeDiffer); } loopCount++; } while (loopCount < 10 && (prevResult == null || Math.Abs(timeDiffer) > loopThreshold)); //|| prevResult. return(result); }
/// <summary> /// 非差轨道确定 /// </summary> /// <param name="Material">历元信息</param> /// <param name="ResultMatrix">平差信息</param> /// <param name="ParamNameBuilder">钟差估计器</param> /// <param name="previousResult">上一历元结果</param> public RangeOrbitResult( MultiSiteEpochInfo Material, AdjustResultMatrix ResultMatrix, RangeOrbitParamNameBuilder ParamNameBuilder, RangeOrbitResult previousResult = null) : base(Material, ResultMatrix, ParamNameBuilder) { //测站接收机钟差改正 foreach (var site in Material) { var clkName = ParamNameBuilder.GetReceiverClockParamName(site.SiteName); var val = ResultMatrix.Estimated.Get(clkName); site.Time.Correction = GetTimeCorrectionSeconds(val.Value); } //提取星历参数,可以用于改正卫星位置,进行迭代计算 EphemerisResults = new BaseDictionary <SatelliteNumber, EphemerisResult>(); foreach (var site in Material) { foreach (var sat in site) { var prn = sat.Prn; Ephemeris estimated = new Ephemeris(sat.Ephemeris.Prn, sat.Ephemeris.Time) { XyzDotRms = new XYZ() }; var clkName = ParamNameBuilder.GetSatClockParamName(prn); var val = ResultMatrix.Estimated.Get(clkName); estimated.ClockBias = GetTimeCorrectionSeconds(val.Value); estimated.ClockBiasRms = val.Rms / GnssConst.LIGHT_SPEED; var names = ParamNameBuilder.GetSatDxyz(prn); foreach (var item in names) { val = ResultMatrix.Estimated.Get(item); if (item.Contains(Gnsser.ParamNames.Dx)) { estimated.XYZ.X = val.Value; estimated.XyzDotRms.X = val.Rms; } if (item.Contains(Gnsser.ParamNames.Dy)) { estimated.XYZ.Y = val.Value; estimated.XyzDotRms.Y = val.Rms; } if (item.Contains(Gnsser.ParamNames.Dz)) { estimated.XYZ.Z = val.Value; estimated.XyzDotRms.Z = val.Rms; } } EphemerisResults[prn] = new EphemerisResult((Ephemeris)sat.Ephemeris, estimated); } } }
/// <summary> /// 检核 /// </summary> /// <param name="t"></param> /// <returns></returns> public bool Check(MultiSiteEpochInfo t) { foreach (var item in t) { return(this.GetOrCreate(item.Name).Check(item)); } return(true); }
/// <summary> /// 双差网解定位。具有模糊度。 /// </summary> /// <param name="mInfo">历元观测信息</param> /// <param name="Adjustment"></param> /// <param name="positioner"></param> /// <param name="baseSatPrn"></param> /// <param name="baseParamCount"></param> public RecursiveNetDoubleDifferPositionResult( MultiSiteEpochInfo mInfo, AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner, SatelliteNumber baseSatPrn, int baseParamCount = 5 ) : base(mInfo, Adjustment, positioner) { }
/// <summary> /// 简易近距离单历元载波相位双差 /// </summary> /// <param name="material"></param> /// <param name="Adjustment"></param> /// <param name="positioner"></param> /// <param name="baseSatPrn"></param> public EpochDoubleDifferPositionResult( MultiSiteEpochInfo material, AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner, SatelliteNumber baseSatPrn ) : base(material, Adjustment, positioner) { this.BasePrn = baseSatPrn; this.Option = positioner.Option; }
/// <summary> /// 处理一个历元 /// </summary> /// <param name="epoch"></param> public override void Process(MultiSiteEpochInfo mEpoch) { if (mEpoch == null || mEpoch.Count == 0) { return; } foreach (var item in mEpoch) { EpochRinexObsFileWriterManager.GetOrCreate(item.Name).Write(item); } }
/// <summary> /// 初始化 /// </summary> /// <param name="material"></param> public override void Init(MultiSiteEpochInfo material) { foreach (var site in material) { if (SiteName == site.SiteName) { this.HasCycleSlip = site.HasCycleSlip(Prn); break; } } }
public override BaseGnssResult CaculateKalmanFilter(MultiSiteEpochInfo epochInfo, BaseGnssResult last = null) { var result = base.CaculateKalmanFilter(epochInfo, last); //外部模糊度文件直接固定 if (IsFixingAmbiguity && Option.IsUseFixedParamDirectly && File.Exists(Option.AmbiguityFilePath) && Option.IsUsingAmbiguityFile) { return(result); } return(result); }
void pp_ProgressIncreased(BaseGnssResult e, MultiSiteEpochInfo sender) { BaseGnssResult result = e as BaseGnssResult; if (result == null) { return; } _results.Add(result); Adjustments.Add(result.ResultMatrix.Estimated.GetRmsedVector()); ShowCurrent(result); }
/// <summary> /// Kalmam滤波。 /// </summary> /// <param name="epochInfos">接收信息</param> /// <param name="lastResult">上次解算结果(用于 Kalman 滤波),若为null则使用初始值计算</param> /// <returns></returns> public override BaseGnssResult CaculateKalmanFilter(MultiSiteEpochInfo epochInfos, BaseGnssResult lastResult = null) { var result = base.CaculateKalmanFilter(epochInfos, lastResult) as EpochDoubleDifferPositionResult; //这里其实不用了,顶层已经做了 if (Option.PositionType == PositionType.动态定位 && Option.IsUpdateEstimatePostition) { epochInfos.OtherEpochInfo.SiteInfo.EstimatedXyz = result.GetEstimatedBaseline().EstimatedXyzOfRov; } this.SetProduct(result); return(result); }
/// <summary> /// 双差网解定位构造函数 /// </summary> /// <param name="epochInfo">历元信息</param> /// <param name="Adjustment">平差信息</param> /// <param name="ClockEstimationer">钟差估计器</param> /// <param name="previousResult">上一历元结果</param> public MultiSiteGnssExtentResult( MultiSiteEpochInfo epochInfo, AdjustResultMatrix Adjustment, GnssParamNameBuilder ClockEstimationer, MultiSiteGnssExtentResult previousResult = null) : base(epochInfo, Adjustment, ClockEstimationer) { Vector vector = Adjustment.Corrected.CorrectedValue; //update foreach (var epoch in epochInfo) { var key = NameBuilder.GetSiteWetTropZpdName(epoch); epoch.NumeralCorrections[Gnsser.ParamNames.WetTropZpd] = vector[Adjustment.GetIndexOf(key)]; } }
/// <summary> /// 站间差分左乘系数阵. /// 基准站将被差分掉。 /// </summary> /// <param name="CurrentMaterial"></param> /// <param name="BaseSiteName"></param> /// <param name="CurrentBasePrn">基准星, 非必需,若是在单差基础上做双差,则需要指定</param> /// <param name="isIgnoreBasPrn">若是在单差基础上做双差,则需要指定true</param> /// <returns></returns> protected static Matrix BuildDifferCoeefBetweenSites(MultiSiteEpochInfo CurrentMaterial, string BaseSiteName, SatelliteNumber CurrentBasePrn, bool isIgnoreBasPrn = true) { int siteCount = CurrentMaterial.Count; int satCount = CurrentMaterial.EnabledSatCount; var rangeRowCount = (satCount - 1) * (siteCount - 1); int rangeColCount = (satCount - 1) * (siteCount); //伪距双差数量 Matrix doubleCoeff = new Matrix(rangeRowCount * 2, rangeColCount * 2); //单差系数阵 //第一个站也被差分掉啦 var rangeRow = 0; var siteIndex = 0; foreach (var site in CurrentMaterial)//所有观测值的权都要保留 { var siteName = site.SiteName; if (String.Equals(siteName, BaseSiteName, StringComparison.CurrentCultureIgnoreCase)) { continue; } int satIndex = 0; foreach (var prn in CurrentMaterial.EnabledPrns) { if (isIgnoreBasPrn && prn == CurrentBasePrn) { continue; } var sat = site[prn]; var phaseRow = rangeRow + rangeRowCount; int col = satIndex; doubleCoeff[rangeRow, col] = -1; //参考星 col = rangeColCount + satIndex; doubleCoeff[phaseRow, col] = -1; //参考星 col = (siteIndex + 1) * (satCount - 1) + satIndex; doubleCoeff[rangeRow, col] = 1; //流动星 col = rangeColCount + (siteIndex + 1) * (satCount - 1) + satIndex; doubleCoeff[phaseRow, col] = 1; //流动星 rangeRow++; satIndex++; } siteIndex++; } return(doubleCoeff); }
/// <summary> /// 双差差分定位结果。具有模糊度。 /// </summary> /// <param name="epochInfo">历元观测信息</param> /// <param name="PointPositionType">单点定位类型</param> public EpochDouFreDoubleDifferPositionResult( MultiSiteEpochInfo receiverInfo, AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner, SatelliteNumber baseSatPrn, int baseParamCount = 5 ) : base(receiverInfo, Adjustment, positioner) { this.BasePrn = baseSatPrn; int index = Adjustment.GetIndexOf(Gnsser.ParamNames.WetTropZpd); if (index != -1) { this.WetTropoFactor = this.ResultMatrix.Corrected.CorrectedValue[Adjustment.GetIndexOf(Gnsser.ParamNames.WetTropZpd)]; } else { this.WetTropoFactor = 0.0; } //处理模糊度 this.AmbiguityDic = new Dictionary <SatNumberAndFrequence, double>(); Vector vector = Adjustment.Corrected.CorrectedValue; int satIndex = 0; foreach (var item in receiverInfo.EnabledPrns) { if (item != BasePrn) { Frequence FrequenceA = Frequence.GetFrequence(this.BasePrn, SatObsDataType.PhaseRangeA, receiverInfo.ReceiverTime); Frequence FrequenceB = Frequence.GetFrequence(this.BasePrn, SatObsDataType.PhaseRangeB, receiverInfo.ReceiverTime); SatNumberAndFrequence satA = new SatNumberAndFrequence(); satA.SatNumber = item; satA.Frequence = FrequenceA; SatNumberAndFrequence satB = new SatNumberAndFrequence(); satB.SatNumber = item; satB.Frequence = FrequenceB; double val = vector[satIndex]; AmbiguityDic.Add(satA, val); AmbiguityDic.Add(satB, val); satIndex++; } } }
/// <summary> /// 获取MW双差值,名称与双差值匹配。 /// </summary> /// <param name="sites"></param> /// <param name="basePrn"></param> /// <param name="isNetSolver">是否为网解</param> /// <returns></returns> public NameRmsedNumeralVector GetMwCycleDoubleDifferValue(MultiSiteEpochInfo sites, SatelliteNumber basePrn, bool isNetSolver = true) { //计算所有测站星间单差 var satDiffersOfSites = new Dictionary <string, NameRmsedNumeralVector <SatelliteNumber> >(); var time = sites.ReceiverTime; foreach (var rovSiteObj in sites) { var rovSite = this.Get(rovSiteObj.SiteName); satDiffersOfSites[rovSiteObj.SiteName] = rovSite.GetDifferMwCycle(time, basePrn); } //计算站间单差,即双差 NameRmsedNumeralVector result = new NameRmsedNumeralVector(); var refSite = satDiffersOfSites[sites.BaseSiteName]; foreach (var kv in satDiffersOfSites) { if (kv.Key == sites.BaseSiteName) { continue; } var differ = kv.Value - refSite; foreach (var diffItem in differ) { NetDoubleDifferName differName = new NetDoubleDifferName() { RefPrn = basePrn, RovPrn = diffItem.Key }; if (isNetSolver)//网解带坐标 { differName.RefName = sites.BaseSiteName; differName.RovName = kv.Key; } var name = differName.ToString(Gnsser.ParamNames.DoubleDifferAmbiguitySuffix); result[name] = diffItem.Value; } } return(result); }
/// <summary> /// 构建双差观测矩阵协方差 /// </summary> /// <param name="epochMaterial"></param> /// <param name="CurrentBasePrn"></param> /// <param name="BaseSiteName"></param> /// <param name="invFactorOfPhase"></param> /// <param name="phaseOnly">是否只用载波,否则载波加伪距</param> /// <param name="isDualFreq">是否双频</param> /// <returns></returns> public Matrix BulidDoubleInverseWeightOfObs(MultiSiteEpochInfo epochMaterial, string BaseSiteName, SatelliteNumber CurrentBasePrn, double invFactorOfPhase, bool phaseOnly, bool isDualFreq = false) { DiagonalMatrix primevalCova = null; if (phaseOnly) { primevalCova = BuildPrmevalPhaseOnlyObsCovaMatrix(epochMaterial, BaseSiteName, CurrentBasePrn, invFactorOfPhase); } else { primevalCova = BuildPrmevalRangeAndPhaseObsCovaMatrix(epochMaterial, BaseSiteName, CurrentBasePrn, invFactorOfPhase); } Matrix undiffInverseWeigth = new Matrix(primevalCova); DifferCoeffBuilder differCoeffBuilder = new DifferCoeffBuilder(epochMaterial, BaseSiteName, CurrentBasePrn, phaseOnly); Matrix sigleCoeff = differCoeffBuilder.BuildDifferCoeefOfBetweenSats(); //构建星间单差系数阵的转换矩阵 //单差协因数阵 var singleDifferCova = sigleCoeff * undiffInverseWeigth * sigleCoeff.Transposition; //组建双差系数阵 Matrix doubleCoeff = differCoeffBuilder.BuildDifferCoeefBetweenSites(); //误差传播定律 var doubleDifferCova = doubleCoeff * singleDifferCova * doubleCoeff.Transposition; if (isDualFreq) { //二倍而已 var ObsCount = doubleDifferCova.RowCount * 2; Matrix result = new Matrix(ObsCount, ObsCount); result.SetSub(doubleDifferCova); result.SetSub(doubleDifferCova, doubleDifferCova.RowCount, doubleDifferCova.ColCount); return(result); } else { return(doubleDifferCova); } }
/// <summary> /// 计算 /// </summary> /// <param name="mEpochInfo"></param> public override void Process(MultiSiteEpochInfo mEpochInfo) { //base.Process(mEpochInfo); var val = mEpochInfo; //精密单点定位计算 IonoFreePppManager.Solve(val); if (IonoFreePppManager.CurrentResults.Count == 0) { return; } //缓存与模糊度固定计算 if (PppResultBuffer.IsFull) { MultiSiteNarrowLaneSolver.Solve(IonoFreePppManager.CurrentResults, PppResultBuffer, mEpochInfo, BufferedStream.MaterialBuffers); } PppResultBuffer.Add(IonoFreePppManager.CurrentResults); }
/// <summary> /// /// </summary> /// <param name="epochInfos"></param> /// <param name="Adjustment"></param> /// <param name="nameBuilder"></param> public AbstractClockEstimationResult( MultiSiteEpochInfo epochInfos, AdjustResultMatrix Adjustment, GnssParamNameBuilder nameBuilder) : base(epochInfos, Adjustment, nameBuilder) { Vector corrected = Adjustment.Corrected.CorrectedValue; //update this.DeltaTimeDistances = new Dictionary <string, double>(); foreach (var epoch in epochInfos) { var key = NameBuilder.GetReceiverClockParamName(epoch); var val = corrected[Adjustment.GetIndexOf(key)]; epoch.NumeralCorrections[Gnsser.ParamNames.cDt] = val; this.DeltaTimeDistances.Add(epoch.Name, val); epoch.Time.Correction = val / GnssConst.LIGHT_SPEED; } }
/// <summary> /// 预处理 /// </summary> /// <param name="mEpochInfo"></param> /// <returns></returns> public override LoopControlType PreProcess(MultiSiteEpochInfo mEpochInfo) { var loop = CheckLoop(mEpochInfo); if (loop != LoopControlType.GoOn) { return(loop); } //避免无谓工作 if (!mEpochInfo.BaseEpochInfo.Contains(BasePrn.SatelliteType)) { log.Error("糟糕!是不是设置错了?基准数据 " + mEpochInfo.BaseEpochInfo.Name + " 不包含系统: " + BasePrn.SatelliteType); return(LoopControlType.Continue); } if (!mEpochInfo.TotalPrns.Contains(BasePrn)) { return(LoopControlType.Continue); } return(ProducingRevise(mEpochInfo)); }
/// <summary> /// 钟差估计构造函数 /// </summary> /// <param name="epochInfo">历元信息</param> /// <param name="Adjustment">平差信息</param> /// <param name="ClockEstimationer">钟差估计器</param> /// <param name="previousResult">上一历元结果</param> public ClockEstimationResult( MultiSiteEpochInfo epochInfo, AdjustResultMatrix Adjustment, GnssParamNameBuilder ClockEstimationer, ClockEstimationResult previousResult = null) : base(epochInfo, Adjustment, ClockEstimationer) { Vector vector = Adjustment.Corrected.CorrectedValue; //update foreach (var epoch in epochInfo) { var key = NameBuilder.GetSiteWetTropZpdName(epoch); epoch.NumeralCorrections[Gnsser.ParamNames.WetTropZpd] = vector[Adjustment.GetIndexOf(key)]; } this.AmbiguityDic = new Dictionary <string, double>(); int length = ParamCount; for (int i = 2 * MaterialObj.Count + EnabledPrns.Count; i < length; i++) { double val = vector[i]; AmbiguityDic.Add(ParamNames[i], val); } //this.PrnWithSlips = new List<SatelliteNumber>(); this.PrnWithSlipss = new List <string>(); foreach (var item in epochInfo) { foreach (var item1 in item) { if (item1.IsUnstable) { //PrnWithSlips.Add(item1.Prn); PrnWithSlipss.Add(item.SiteName + "-" + item1.Prn); } } } }
/// <summary> /// 双差差分定位结果。具有模糊度。 /// </summary> /// <param name="mInfo">历元观测信息</param> /// <param name="Adjustment"></param> /// <param name="positioner"></param> /// <param name="baseSatPrn"></param> /// <param name="baseParamCount"></param> public IonFreeDoubleDifferPositionResult( MultiSiteEpochInfo mInfo, AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner, SatelliteNumber baseSatPrn, int baseParamCount = 5 ) : base(mInfo, Adjustment, positioner) { this.Name = mInfo.BaseEpochInfo.Name + Gnsser.ParamNames.BaseLinePointer + mInfo.OtherEpochInfo.Name; this.BasePrn = baseSatPrn; int index = Adjustment.GetIndexOf(Gnsser.ParamNames.WetTropZpd); if (index != -1) { this.WetTropoFactor = this.ResultMatrix.Corrected.CorrectedValue[Adjustment.GetIndexOf(Gnsser.ParamNames.WetTropZpd)]; } else { this.WetTropoFactor = 0.0; } //处理模糊度 this.AmbiguityDic = new Dictionary <SatelliteNumber, double>(); Vector vector = Adjustment.Corrected.CorrectedValue; int satIndex = 0; foreach (var item in mInfo.EnabledPrns) { if (item != BasePrn) { double val = vector[satIndex]; AmbiguityDic.Add(item, val); satIndex++; } } }
/// <summary> /// 计算 /// </summary> /// <param name="results"></param> /// <param name="mEpochInfo"></param> /// <param name="mSiteBuffers"></param> public void Solve( Dictionary <string, PppResult> results, IWindowData <Dictionary <string, PppResult> > resultBuffer, MultiSiteEpochInfo mEpochInfo, IWindowData <MultiSiteEpochInfo> mSiteBuffers) { this.CurrentMaterial = mEpochInfo; foreach (var item in mEpochInfo) { var key = item.Name; var info = item; var buffer = GetEpochInfoBuffer(key, mSiteBuffers);//单站缓存 var reviser = GetOrCreate(item.Name); reviser.DifferFcbManager = DifferFcbManager; reviser.Buffers = buffer; reviser.PppResult = results[key]; reviser.PppResultBuffers = GetEpochResultBuffer(key, resultBuffer);//结果缓存 reviser.Revise(ref info); } AddCurrentResultToOutputTable(); }
/// <summary> /// 计算 /// </summary> /// <param name="mEpochInfo"></param> public void Solve(MultiSiteEpochInfo mEpochInfo) { this.CurrentMaterial = mEpochInfo; CurrentResults = new Dictionary <string, PppResult>(); foreach (var epochInfo in mEpochInfo) { var result = this.GetOrCreate(epochInfo.Name).Get(epochInfo) as PppResult; if (result == null) { continue; } CurrentResults[epochInfo.Name] = result; //输出结果 if (IsOutputResult) { var table = this.TableTextManager.GetOrCreate(epochInfo.Name); table.NewRow(); table.AddItem("Epoch", mEpochInfo.ReceiverTime.ToShortTimeString()); table.AddItem((IVector)result.ResultMatrix.Estimated); table.EndRow(); } } }
/// <summary> /// 生成多测站单历元原始纯载波的观测权逆阵,将基准站放在第一,基准星放在第一。 /// 注意:伪距观测值排在前面,载波在后面。 /// </summary> public DiagonalMatrix BuildPrmevalRangeAndPhaseObsCovaMatrix(MultiSiteEpochInfo epochMaterial, string BaseSiteName, SatelliteNumber CurrentBasePrn, double invFactorOfPhase) { var enabledPrns = epochMaterial.EnabledPrns; int siteCount = epochMaterial.Count; int satCount = epochMaterial.EnabledSatCount; int totalObsCount = siteCount * satCount * 2; //原始非差观测数,伪距加载波 //首先建立非差观测值的权逆阵,这里前第一个是ref站,每个站的第一星是ref星,与观测值保持一致 DiagonalMatrix primevalCova = new DiagonalMatrix(totalObsCount); int rangeRowCount = totalObsCount / 2; int rangeRow = 0; int phaseRow = rangeRow + rangeRowCount; EpochInformation baseSite = epochMaterial[BaseSiteName]; //第一颗星 var refSat = baseSite[CurrentBasePrn]; double inverseWeightOfSat = SatWeightProvider.GetInverseWeightOfRange(refSat); primevalCova[rangeRow, rangeRow] = inverseWeightOfSat; primevalCova[phaseRow, phaseRow] = inverseWeightOfSat * invFactorOfPhase; rangeRow++; //第一个站 foreach (var prn in enabledPrns) { if (prn == CurrentBasePrn) { continue; } var sat = baseSite[prn]; phaseRow = rangeRow + rangeRowCount; inverseWeightOfSat = SatWeightProvider.GetInverseWeightOfRange(sat); primevalCova[rangeRow, rangeRow] = inverseWeightOfSat; primevalCova[phaseRow, phaseRow] = inverseWeightOfSat * invFactorOfPhase; rangeRow++; } //其它站 foreach (var site in epochMaterial)//所有观测值的权都要保留 { var siteName = site.SiteName; if (String.Equals(siteName, BaseSiteName, StringComparison.CurrentCultureIgnoreCase)) { continue; } //第一颗星 var baseSat = baseSite[CurrentBasePrn]; inverseWeightOfSat = SatWeightProvider.GetInverseWeightOfRange(baseSat); phaseRow = rangeRow + rangeRowCount; primevalCova[rangeRow, rangeRow] = inverseWeightOfSat; primevalCova[phaseRow, phaseRow] = inverseWeightOfSat * invFactorOfPhase; rangeRow++; foreach (var sat in site.EnabledSats) { if (sat.Prn == CurrentBasePrn) { continue; } phaseRow = rangeRow + rangeRowCount; inverseWeightOfSat = SatWeightProvider.GetInverseWeightOfRange(sat); primevalCova[rangeRow, rangeRow] = inverseWeightOfSat; primevalCova[phaseRow, phaseRow] = inverseWeightOfSat * invFactorOfPhase; rangeRow++; } } return(primevalCova); }