/// <summary>
/// 检核是否满足要求
/// </summary>
/// <param name="epochInfo"></param>
public override bool Check(EpochInformation epochInfo)
{
//多系统设计式有待改进 ！！！ 2014.12.17 czs
foreach (var item in epochInfo.SatelliteTypes)
{
if (EphemerisService.TimePeriod.Contains(epochInfo.ReceiverTime) ||
(epochInfo.ReceiverTime >= EphemerisService.TimePeriod.BufferedStart && epochInfo.ReceiverTime <= EphemerisService.TimePeriod.BufferedEnd))
{
return(true);
}
else
{
log.Error("无法获取星历，观测历元(" + epochInfo.ReceiverTime + ")不在星历有效时间内！" + EphemerisService.TimePeriod);
return(false);
}
}
foreach (var item in epochInfo)
{
if (!EphemerisService.Prns.Contains(item.Prn))
{
item.Enabled = false;
// noEphemerisPrns.Add(key.Prn);//可删除？？？2014.12.17
}
}
return(true);
}
public override SingleSiteGnssResult CaculateKalmanFilter(EpochInformation epochInfo, SingleSiteGnssResult lastResult)
{
CurrentIndex++;
var result = base.CaculateKalmanFilter(epochInfo, lastResult);
if (CurrentProduct != null)
{
if (XYZ.IsValueValid(CurrentProduct.EstimatedXyzRms))
{
LastValidXyzRms = CurrentProduct.EstimatedXyzRms;
}
}
result = CheckOrRecaculate(epochInfo, result);
if (!XYZ.IsValueValid(result.EstimatedXyzRms))
{
log.Error("RMS 检核未通过 " + result.EstimatedXyzRms);
return(null);
}
//if (LastValidXyzRms != null
// && CurrentIndex > 10 //先让其浪一会儿
// && (result.EstimatedXyzRms.Length > LastValidXyzRms.Length * 50))
//{
// log.Error("RMS 检核未通过 " + result.EstimatedXyzRms);
// return null;
//}
//ok
PrevResults.Add(CurrentIndex, result);
return(result);
}
/// <summary>
/// 写历元测站->卫星信息
/// </summary>
/// <param name="results">定位计算结果</param>
/// <param name="dirPath">工程目录</param>
private void WriteSatelliteInfos(List <SingleSiteGnssResult> results, string dirPath)
{
if (results == null || results.Count == 0)
{
return;
}
Geo.Utils.FileUtil.CheckOrCreateDirectory(dirPath);
EpochInformation epoch = results[results.Count - 1].MaterialObj;
StringBuilder sb = new StringBuilder();
string satePath = Path.Combine(dirPath, epoch.SiteInfo.SiteName + "_" + epoch.ReceiverTime.ToDateString() + "_" + "SatDetail");
string marker = "_" + (int)DateTime.Now.TimeOfDay.TotalSeconds + "";
//改正数文件
Dictionary <SatelliteNumber, string> prnPathes = new Dictionary <SatelliteNumber, string>();
foreach (var item in results)
{
foreach (var sat in item.MaterialObj)
{
if (!prnPathes.ContainsKey(sat.Prn))
{
string path = Path.Combine(satePath, sat.Prn + marker + ".xls");
prnPathes.Add(sat.Prn, path);
File.AppendAllText(prnPathes[sat.Prn], sat.GetTabTitles() + "\r\n", Encoding);
sb.AppendLine(path);
}
File.AppendAllText(prnPathes[sat.Prn], sat.GetTabValues() + "\r\n", Encoding);
}
}
}
/// <summary>
/// 精 通用单站单频计算，高度可配置构造函数。
/// </summary>
/// <param name="receiverInfo">接收信息</param>
/// <param name="Adjustment">平差</param>
/// <param name="paramNames">参数名称</param>
public CommonSingeFreqGnssResult(
EpochInformation receiverInfo,
AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner
)
: base(receiverInfo, Adjustment, positioner)
{
}
public bool Revise(ref EpochInformation info)
{
this.Correct(info);
Dictionary <RinexSatFrequency, NEU> frequencyDicCorrection = this.Correction;
foreach (var sat in info.EnabledSats)//分别对指定卫星指定频率进行改正
{
var satFreqs = sat.RinexSatFrequences;
//分别执行改正
foreach (var freqCorretion in frequencyDicCorrection)
{
if (satFreqs.Contains(freqCorretion.Key))//指定类型的卫星，该卫星包含指定频率
{
//改正等效距离
//double rangeCorretion = CoordUtil.GetDirectionLength(freqCorretion.Value, info.ApproxXyz, sat.Ephemeris.XYZ);
double rangeCorretion = CoordUtil.GetDirectionLength(freqCorretion.Value, sat.Polar);
FrequenceType freqType = ObsCodeConvert.GetFrequenceType(freqCorretion.Key);
FreqenceObservation freObs = sat[freqType];
if (rangeCorretion == 0)
{
continue;
}
// // freObs.AddCommonCorrection(this.Name, -freqCorretion.Value.U);//若为正，其让站星观测值变小了，作为近似值改正数，应该减去
freObs.AddCommonCorrection(this.Name, -rangeCorretion); //若为正，其让站星观测值变小了，作为近似值改正数，应该减去
//作为公共距离，还是只作为载波的改正？
}
}
}
return(true);
}
/// <summary>
/// 写平差矩阵文本信息
/// </summary>
/// <param name="results">定位计算结果</param>
/// <param name="dirPath">工程目录</param>
private void WriteAdjustMatrix(List <SingleSiteGnssResult> results, string dirPath)
{
if (results == null || results.Count == 0)
{
return;
}
Geo.Utils.FileUtil.CheckOrCreateDirectory(dirPath);
EpochInformation epoch = results[results.Count - 1].MaterialObj;
string marker = "_" + (int)DateTime.Now.TimeOfDay.TotalSeconds + "";
string path = Path.Combine(dirPath, epoch.SiteInfo.SiteName + "_" + epoch.ReceiverTime.ToDateString() + "_平差矩阵" + marker + ".adjust.txt");
//常数项，没有按照卫星对应输出。
StringBuilder sb = new StringBuilder();
int i = 0;
foreach (var result in results)
{
sb.AppendLine(result.ResultMatrix.ObsMatrix.ToReadableText());
i++;
}
File.AppendAllText(path, sb.ToString(), Encoding);
}
/// <summary>
/// 执行改正
/// </summary>
/// <param name="info"></param>
public override void Correct(EpochInformation info)
{
this.Corrections = new Dictionary <string, Dictionary <RinexSatFrequency, NEU> >();
//执行改正
foreach (var item in this.Correctors)
{
item.Correct(info);
Corrections.Add(item.Name, item.Correction);
}
Dictionary <RinexSatFrequency, NEU> vals = new Dictionary <RinexSatFrequency, NEU>();
foreach (var item in Correctors)
{
if (item == null || item.Correction == null)
{
continue;
}
foreach (var subitem in item.Correction)
{
if (!vals.ContainsKey(subitem.Key))
{
vals[subitem.Key] = NEU.Zero;
}
vals[subitem.Key] += subitem.Value;
}
}
//可在此设断点查看各个改正情况。
this.Correction = (vals);
}
/// <summary>
/// 探测并标记
/// </summary>
/// <param name="CurrentEpcohInfo"></param>
/// <returns></returns>
public override bool Revise(ref EpochInformation CurrentEpcohInfo)
{
this.CurrentEpcohInfo = CurrentEpcohInfo;
IWindowData <EpochInformation> buffers = Buffers;
if (buffers == null || buffers.Count == 0)
{
return(true);
}
if (buffers.First != null)
{
foreach (var sat in CurrentEpcohInfo)
{
//逆序，只针对连续两次以上具有周跳的卫星进行探测。
var nextSat = buffers.First.Get(sat.Prn);
if (nextSat != null)
{
//若顺序探测，未发现周跳，则不标记其为周跳，避免误探
if (sat.IsUnstable && nextSat.IsUnstable)
{
var sats = GetSats(buffers, sat, MinNum);
DetectOrMark(sats);
}
}
}
}
return(true);
}
private void BuildEphemerisReviser(EpochInformation info)
{
XYZ receiverPos = info.SiteInfo.EstimatedXyz;
//星历修正器
this.EphemerisProcessors = new List <IEphemerisReviser>();
if (Context.HasClockService)
{
this.EphemerisProcessors.Add(new ClockEphemerisReviser(Context.SimpleClockService));
} //SimpleClockService
else if (!IsNoticedClockService)
{
log.Warn("没有钟差服务！无法对星历进行二次矫正。"); IsNoticedClockService = true;
}
//修改到xy方向上
if (receiverPos != null && !receiverPos.IsZero)
{
this.EphemerisProcessors.Add(new EarthSagnacEphemerisReviser(receiverPos));
} //地球自转改正，
else if (!IsNoticedCoordZero)
{
log.Warn("接收机坐标为 0，无法进行地球自转改正！无法对星历进行二次矫正。"); IsNoticedCoordZero = true;
}
this.EphemerisProcessors.Add(new RelativeEphemerisReviser()); // 计算相对论改正，添加到钟上
}
/// <summary>
/// 如果有效，则直接返回，如果无效则重置先验值重新计算。
/// </summary>
/// <param name="epochInfo"></param>
/// <param name="result"></param>
/// <returns></returns>
private SingleSiteGnssResult CheckOrRecaculate(EpochInformation epochInfo, SingleSiteGnssResult result)
{
if (Geo.Algorithm.Vector.IsValid(result.ResultMatrix.StdOfEstimatedParam))
{
return(result);
}
var lastOkIndex = PrevResults.LastKey;
var differIndex = CurrentIndex - lastOkIndex;
var newAprioriIndex = PrevResults.LastKey - differIndex;
while (newAprioriIndex > 0)
{
if (PrevResults.Contains(newAprioriIndex))
{
var product = PrevResults[newAprioriIndex];
this.SetProduct(product);
if (differIndex > 5)
{
//this.MatrixBuilder.IsResetCovaOfApriori = true;
}
break;
}
newAprioriIndex--;
}
return(base.CaculateKalmanFilter(epochInfo, this.CurrentProduct));
}
/// <summary>
/// 矫正
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Revise(ref EpochInformation obj)
{
var buffer = this.Buffers;
//添加到往期数据
foreach (var sat in obj)
{
LastWindowDataManager
.GetOrCreate(BuildKey(sat.Prn, FrequenceType.A))
.Add(obj.ReceiverTime, sat[FrequenceType.A].PseudoRange.Value);
if (sat.Contains(FrequenceType.B))
{
LastWindowDataManager
.GetOrCreate(BuildKey(sat.Prn, FrequenceType.B))
.Add(obj.ReceiverTime, sat[FrequenceType.B].PseudoRange.Value);
}
}
//逐个拟合
//添加到往期数据
foreach (var sat in obj)
{
var prn = sat.Prn;
SetPolyFitCorrection(sat, FrequenceType.A);
if (sat.Contains(FrequenceType.B))
{
SetPolyFitCorrection(sat, FrequenceType.B);
}
}
return(true);
}
/// <summary>
/// 探测历元钟跳
/// </summary>
/// <param name="obj"></param>
private void Detect(EpochInformation obj)
{
List <SatelliteNumber> isJumpedes = new List <SatelliteNumber>();
foreach (var sat in obj)
{
var reffer = sat;
if (!ClockJumpCorrectManager.GetOrCreate(sat.Prn).Revise(ref reffer))
{
isJumpedes.Add(sat.Prn);
}
}
int jumped = isJumpedes.Count;
double jumpedRatio = 1.0 * jumped / obj.Count;
if (jumpedRatio > MinDetectingRatio)
{
obj.EpochState = EpochState.ClockJumped;
var differSeconds = obj.ReceiverTime - LastJumpTime;
var interval = TimeSpan.FromSeconds(differSeconds).ToString();
if (LastJumpTime == Time.MinValue)
{
interval = "第一次";
}
log.Info(obj.Name + "，" + obj.ReceiverTime + "，钟跳，间隔 " + interval + "，" + jumped.ToString("##") + "/" + obj.Count.ToString("##") + "=" + jumpedRatio.ToString("0.00"));
//是否修复
TotalCount++;
LastJumpTime = obj.ReceiverTime;
}
}
/// <summary>
/// 矫正
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public override bool Revise(ref EpochInformation info)
{
//第一个历元不计算。
if (PreviousTime.Equals(Time.MinValue))
{
Previous = info;
return(true);
}
//为了防止历元跳跃，还是老老实实一步一步的计算
double interVal = (Double)(info.ReceiverTime - PreviousTime);
foreach (var sat in info)
{
SatelliteNumber prn = sat.Prn;
if (!Previous.Contains(prn))
{
continue; //新卫星第一个历元不计算
}
foreach (var item in sat.FrequenceTypes)
{
if (!Previous[prn].Contains(item))
{
continue;
}
//这是一种近似算法，取得的是这段时间的平均值，但是误差不大，一般在一个频率以下，实际上应该积微分
//这里是前减后，定义如果为负，则远离，如果为正数，则靠近 approach
double doppler = (Previous[prn][item].PhaseRange.RawPhaseValue - sat[item].PhaseRange.RawPhaseValue) / interVal;
sat[item].Set(ObservationType.D, new Domain.Observation(doppler, new ObservationCode(ObservationType.D, (int)item)));
}
}
return(true);
}
private void GetEpochCoeffOfDesign(double[][] A, EpochInformation epoch, int IndexOfwetTropName)
{
foreach (var prn in epoch.EnabledSats)// 一颗卫星2行
{
var receiverClockName = this.GnssParamNameBuilder.GetReceiverClockParamName(epoch);
int IndexOfreceiverClockName = ParamNames.IndexOf(receiverClockName);
var satelliteName = this.GnssParamNameBuilder.GetSatClockParamName(prn.Prn);
int IndexOfsatelliteName = ParamNames.IndexOf(satelliteName);
var SiteSatAmbiguityName = this.GnssParamNameBuilder.GetSiteSatAmbiguityParamName(prn);
int IndexOfSiteSatAmbiguityName = ParamNames.IndexOf(SiteSatAmbiguityName);
int row = IndexOfSiteSatAmbiguityName - BaseCount;//行的索引号
int next = row + ObsCount;
double wetMap = epoch[prn.Prn].WetMap;
double[] A1 = A[row];
double[] A2 = A[next];
if (IndexOfreceiverClockName != 0)
{
A1[IndexOfreceiverClockName] = 1.0; //接收机钟差对应的距离 = clkError * 光速
A2[IndexOfreceiverClockName] = 1.0; //接收机钟差对应的距离 = clkError * 光速
}
A1[IndexOfwetTropName] = wetMap;
A1[IndexOfsatelliteName] = -1.0;//卫星钟差对应的距离 = clkError * 光速
A2[IndexOfwetTropName] = wetMap;
A2[IndexOfsatelliteName] = -1.0; //卫星钟差对应的距离 = clkError * 光速
A2[IndexOfSiteSatAmbiguityName] = 1; //模糊度,保持以m为单位
}
}
public override void Correct(EpochInformation epochInformation)
{
Time gpsTime = epochInformation.ReceiverTime;//.CorrectedTime;
XYZ reciverPosition = epochInformation.SiteInfo.EstimatedXyz;
//查找地球自转信息
//gpst2utc
Time tutc = gpsTime.GpstToUtc();
Gnsser.Data.ErpItem erpv = null;
if (DataSouceProvider.ErpDataService != null)
{
erpv = DataSouceProvider.ErpDataService.Get(tutc);
}
if (erpv == null)
{
erpv = ErpItem.Zero;
}
var pos = DataSouceProvider.UniverseObjectProvider.GetOrCreate(gpsTime, erpv);
//Gnsser.Data.ErpItem erpv = epochInformation.DataSouceProvider.ErpDataService.Gete);
//XYZ sunPos = new XYZ(); XYZ moonPos = new XYZ(); double gmst = 0.0;
//epochInformation.DataSouceProvider.UniverseObjectProvider.GetSunPosition(gpsTime, erpv, ref sunPos, ref moonPos,ref gmst);
NEU correction = GetSolidTidesCorrectValue(gpsTime, reciverPosition, pos.SunXyz, pos.MoonXyz);
this.Correction = (correction);
}
/// <summary>
/// 矫正方法。
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public override bool Revise(ref EpochInformation info)
{
if (SatExcludeDataSource == null) { return true; }
List<SatelliteNumber> toRemovePrns = new List<SatelliteNumber>();
foreach (var item in info)
{
if (SatExcludeDataSource.IsExcluded( info.ReceiverTime.Date, item.Prn))
{
toRemovePrns.Add(item.Prn);
}
}
if (toRemovePrns.Count > 0)
{
var toNotice = toRemovePrns.FindAll(m=> !NoticedPrns.Contains(m));
if (toNotice.Count > 0)
{
StringBuilder sb = new StringBuilder();
sb.Append("删除 "+info.ReceiverTime.ToDateString()+" 故障卫星：");
sb.Append(String.Format(new EnumerableFormatProvider(), "{0}", toRemovePrns));
log.Debug(sb.ToString());
NoticedPrns.AddRange(toNotice);
}
info.Remove(toRemovePrns, true, "删除 "+info.ReceiverTime.ToDateString()+" 故障卫星");
}
return info.EnabledPrns.Count > 0;
}
/// <summary>
/// 历元信息矫正
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public bool Revise(ref EpochInformation info)
{
foreach (var sat in info.EnabledSats)//分别对指定卫星进行改正
{
this.Correct(sat);
switch (this.CorrectChianType)
{
case CorrectChianType.Common:
sat.CommonCorrection.SetCorrection(this.Corrections);
break;
case CorrectChianType.PhaseRangeOnly:
sat.PhaseOnlyCorrection.SetCorrection(this.Corrections);
break;
case CorrectChianType.RangeOnly:
sat.RangeOnlyCorrection.SetCorrection(this.Corrections);
break;
case CorrectChianType.Self: //不需要任何处理
break;
default:
break;
}
}
return(true);
}
/// <summary>
/// 精密单点定位结果构造函数。
/// </summary>
/// <param name="receiverInfo">接收信息</param>
/// <param name="Adjustment">平差</param>
/// <param name="nameBuilder">参数名称生成器</param>
public IonoModeledSingleFreqPppResult(
EpochInformation receiverInfo,
AdjustResultMatrix Adjustment, GnssParamNameBuilder nameBuilder
)
: base(receiverInfo, Adjustment, nameBuilder)
{
this.WetTropoFactor = this.ResultMatrix.Corrected.CorrectedValue[Adjustment.GetIndexOf(Gnsser.ParamNames.WetTropZpd)];
//处理模糊度
this.AmbiguityDic = new Dictionary <SatelliteNumber, double>();
int length = receiverInfo.EnabledSatCount * 2 + 5;
Vector vector = Adjustment.Corrected.CorrectedValue;
for (int i = 5 + receiverInfo.EnabledSatCount; i < 5 + receiverInfo.EnabledSatCount; i++)
{
SatelliteNumber prn = receiverInfo[i - 5 - receiverInfo.EnabledSatCount].Prn;
//double val = vector[i];
//double[] AmbiguityItem = new double[1];
//AmbiguityItem[0] = val;
////AmbiguityItem[1] = vector[i + receiverInfo.EnabledSatCount];
//AmbiguityDic.Add(prn, val);
}
}
/// <summary>
/// 精 通用单站单频计算，高度可配置构造函数。
/// </summary>
/// <param name="receiverInfo">接收信息</param>
/// <param name="Adjustment">平差</param>
/// <param name="positioner">定位器</param>
public DoubleFreqIonoSingleFreqPppGnssResult(
EpochInformation receiverInfo,
AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner
)
: base(receiverInfo, Adjustment, positioner)
{
}
private void GetEpochObservationVector(Vector L, EpochInformation epoch)
{
Vector rangeVector = epoch.GetAdjustVector(SatObsDataType.IonoFreeRange);
Vector phaseVector = null;
if (this.Option.IsAliningPhaseWithRange)
{
phaseVector = epoch.GetAdjustVector(SatObsDataType.AlignedIonoFreePhaseRange, true);
}
else
{
phaseVector = epoch.GetAdjustVector(SatObsDataType.IonoFreePhaseRange, true);
}
int index = 0;
foreach (var item in epoch.EnabledSats)
{
var SiteSatAmbiguityName = this.GnssParamNameBuilder.GetSiteSatAmbiguityParamName(item);
int IndexOfSiteSatAmbiguityName = ParamNames.IndexOf(SiteSatAmbiguityName);
int row = IndexOfSiteSatAmbiguityName - BaseCount;//行的索引号
int next = row + ObsCount;
L[row] = rangeVector[index];
L[next] = phaseVector[index];
index++;
}
}
/// <summary>
/// 处理
/// </summary>
/// <param name="epochInfo"></param>
/// <returns></returns>
public override bool Revise(ref EpochInformation epochInfo)
{
//判断历元，避免重复探测而引起探测失败
if (epochInfo.ReceiverTime == LastDetectingTime)
{
log.Debug("此历元周跳已经探测过了" + LastDetectingTime);
return(true);
}
LastDetectingTime = epochInfo.ReceiverTime;
foreach (var sat in epochInfo)
{
var result = Detect(sat);
if (result && IsMarkingCycleSlipe)
{
MarkCycleSlip(sat, result);
}
if (!result && IsRemoveCycleSlipeMarker)
{
MarkCycleSlip(sat, result);
}
}
return(true);
}
/// <summary>
/// 最简单的4历元钟跳修复法，返回改正数。
/// </summary>
/// <param name="prev2"></param>
/// <param name="prev1"></param>
/// <param name="current"></param>
/// <param name="next"></param>
/// <param name="frequenceType"></param>
/// <returns></returns>
public double GetClockJumpSeconds(EpochInformation prev2, EpochInformation prev1, EpochInformation current, EpochInformation next, FrequenceType frequenceType)
{
List <SatelliteNumber> commonPrns = Geo.Utils.ListUtil.GetCommons <SatelliteNumber>(current.Keys, prev1.Keys, prev2.Keys, next.Keys);
//比较二者预报之差求后平均
var currentPreditceDiffer = GetPredictedDiffer(prev2, prev1, current, commonPrns, frequenceType);
//var aveVal0 = Geo.Utils.DoubleUtil.Average(currentPreditceDiffer.Values);
//var seconds0 = 1.0 * aveVal0 / GnssConst.LIGHT_SPEED;
//return seconds0;
var prevPreditceDiffer = GetPredictedDiffer(next, current, prev1, commonPrns, frequenceType);//这个符号是反的
//求预报平均值
var aves = new BaseDictionary <SatelliteNumber, double>();
foreach (var item in commonPrns)
{
aves[item] = (currentPreditceDiffer[item] - prevPreditceDiffer[item]) / 2.0;
}
var aveVal = Geo.Utils.DoubleUtil.Average(aves);
var seconds = aveVal / GnssConst.LIGHT_SPEED;
return(seconds);
}
/// <summary>
/// 添加前一个
/// </summary>
/// <param name="obj"></param>
public ClockJumpDetector SetPrev(EpochInformation obj)
{
this.Prev2 = Prev;
this.Prev = obj;
PrevBuffers.Add(Prev);
return(this);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="material"></param>
public override void Init(EpochInformation material)
{
if (material.EnabledPrns.Contains(Prn))
{
this.HasCycleSlip = material[Prn].IsUnstable;
}
}
/// <summary>
/// 构造函数
/// </summary>
public RangeDifferCorrector(EpochInformation refEpochInfo, double refClkError, SatObsDataType dataType = SatObsDataType.PseudoRangeA)
{
this.Name = "伪距差分距离改正";
this.CorrectionType = CorrectionType.RangeDifferCorrector;
this.RefEpochInfo = refEpochInfo;
this.RefClkError = refClkError;
this.EpochSatDataType = dataType;
}
void pp_ProgressIncreased(BaseGnssResult e, EpochInformation sender)
{
_processedEpochCount++;
this.Invoke(new Action(delegate()
{
this.backgroundWorker1.ReportProgress(_processedEpochCount);
}));
}
public override void Run(EpochInformation epoch)
{
PreProcess(epoch);
Process(epoch);
Result.EndRow();
}
/// <summary>
/// 注册时段
/// </summary>
/// <param name="obj"></param>
public void Regist(EpochInformation obj)
{
foreach (var item in obj)
{
this.Regist(item.Prn, obj.ReceiverTime);
}
LastRegistTime = obj.ReceiverTime;
}
private WeightedVector fix_sol(EpochInformation receiverInfo, AdjustResultMatrix adjustment, int[] satN1, int[] satN2, double[] NC, int n, ref double factor0)
{
int i, j, k;
double[] v = new double[n]; //m * 1
int nx = adjustment.Estimated.Count; //参数个数 n*1
double[][] H = new double[nx][]; for (i = 0; i < nx; i++)
{
H[i] = new double[n]; //n * m
}
double[][] R = new double[n][]; for (i = 0; i < n; i++)
{
R[i] = new double[n]; //m * m
}
SatelliteNumber sat1 = new SatelliteNumber();
SatelliteNumber sat2 = new SatelliteNumber();
//constraints to fixed ambiguities
for (i = 0; i < n; i++)
{
sat1.PRN = satN1[i];
sat1.SatelliteType = SatelliteType.G;
sat2.PRN = satN2[i];
sat2.SatelliteType = SatelliteType.G;
j = receiverInfo.EnabledPrns.IndexOf(sat1); //模糊度参数的索引
k = receiverInfo.EnabledPrns.IndexOf(sat2); //模糊度参数的索引
v[i] = NC[i] - (adjustment.Estimated.OneDimArray[j + 5] - adjustment.Estimated.OneDimArray[k + 5]);
// v[time] = NC[time] - (adjustment.Estimated[j + 5] - adjustment.Estimated[k + 5]);
H[j + 5][i] = 1.0;
H[k + 5][i] = -1.0;
R[i][i] = CONST_AMB * CONST_AMB;
}
//update states with constraints
WeightedVector Estimated = filter(adjustment.Estimated.OneDimArray, adjustment.Estimated.InverseWeight.Array, H, v, R, ref factor0);
//set flags
for (i = 0; i < n; i++)
{
sat1.PRN = satN1[i];
sat1.SatelliteType = SatelliteType.G;
sat2.PRN = satN2[i];
sat2.SatelliteType = SatelliteType.G;
ambc[sat1].flags[sat2] = 1;
ambc[sat2].flags[sat1] = 1;
}
return(Estimated);
}
/// <summary>
/// 注册时段
/// </summary>
/// <param name="obj"></param>
public void Regist(EpochInformation obj)
{
foreach (var sat in obj)
{
var paramWinData = this.GetOrCreate(sat.Prn);
paramWinData.Regist(ParamNames.MwCycle, obj.ReceiverTime, sat.MwCycle, sat.IsUnstable);
}
}
