/// <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)
{
}
/// <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)
{
}
/// <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="Material">历元信息</param>
/// <param name="Adjustment">平差信息</param>
/// <param name="NameBuilder">参数名称</param>
public SimpleGnssResult(
TMaterial Material,
AdjustResultMatrix Adjustment,
GnssParamNameBuilder NameBuilder) : base(Adjustment)
{
this.Material = Material;
}
/// <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="Adjustment"></param>
protected override void TrySetCommonParamValues(AdjustResultMatrix Adjustment)
{
base.TrySetCommonParamValues(Adjustment);
Vector estmated = Adjustment.Estimated;
if (estmated != null)
{
//对流层设置
//if (Adjustment.ParamNames.Contains(Gnsser.ParamNames.Trop))
//{
// epochInfo.NumeralCorrections[Gnsser.ParamNames.Trop] = estmated[Adjustment.GetIndexOf(Gnsser.ParamNames.Trop)];
//}
//需要计算的属性
//接收机钟差
if (Adjustment.ParamNames.Contains(Gnsser.ParamNames.RcvClkErrDistance))
{
this.RcvClkErrDistance = estmated[Adjustment.GetIndexOf(Gnsser.ParamNames.RcvClkErrDistance)];
//log.Debug("取消了接收机钟差改正！");
//钟差到改正数，需要转换为相反数 // 2018.06.08, czs, HMX
double clkError = this.RcvClkErrDistance / GnssConst.LIGHT_SPEED;
if (Math.Abs(clkError) > GnssConst.LIGHT_SPEED)
{
log.Warn("钟差太大了吧！ " + clkError);
}
this.MaterialObj.Time.Correction = -clkError; //钟差变成改正数
}
}
}
/// <summary>
/// 追加测站信息
/// </summary>
/// <param name="sb"></param>
/// <param name="Adjustment"></param>
private void BuildAdjustInfo(StringBuilder sb, AdjustResultMatrix Adjustment)
{
sb.AppendLine("-------------- 最后历元平差信息 ---------------");
AppendLine(sb, "观测数量", Adjustment.ObsMatrix.ObsCount);
AppendLine(sb, "参数数量", Adjustment.ParamCount);
AppendLine(sb, "单位权中误差", Adjustment.StdDev);
AppendLine(sb, "参数估值", Adjustment.Estimated);
}
/// <summary>
/// 单站ＧＮＳＳ结果
/// </summary>
/// <param name="epochInfo"></param>
/// <param name="adjust"></param>
/// <param name="nameBuilder"></param>
public SingleSiteGnssResult(EpochInformation epochInfo, AdjustResultMatrix adjust, GnssParamNameBuilder nameBuilder, bool isTopSpeed = false)
: base(epochInfo, adjust, nameBuilder, isTopSpeed)
{
if (!isTopSpeed)
{
this.DilutionOfPrecision = new DilutionOfPrecision(epochInfo);
}
}
/// <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="epochInfo">历元信息</param>
/// <param name="Adjustment">平差信息</param>
/// <param name="ClockEstimationer">钟差估计器</param>
/// <param name="previousResult">上一历元结果</param>
public DifferClockEstimationResult(
MultiSitePeriodInfo epochInfo,
AdjustResultMatrix Adjustment,
GnssParamNameBuilder DifferenceClockEstimationer,
DifferClockEstimationResult previousResult = null)
: base(epochInfo, Adjustment, DifferenceClockEstimationer)
{
}
/// <summary>
/// 精密单点定位结果构造函数。
/// </summary>
/// <param name="receiverInfo">接收信息</param>
/// <param name="Adjustment">平差</param>
/// <param name="positioner">名称</param>
/// <param name="baseParamCount">基础参数数量</param>
public RecursiveIonoFreePppResult(
EpochInformation receiverInfo,
AdjustResultMatrix Adjustment,
GnssParamNameBuilder positioner,
int baseParamCount = 5
)
: base(receiverInfo, Adjustment, positioner)
{
}
/// <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="Adjustment">平差</param>
/// <param name="BasePrn">基准星</param>
/// <param name="PeriodDifferInfo">区间差分信息</param>
/// <param name="lastPppResult">最后结果</param>
public TwoSitePeriodDifferPositionResult(
MultiSitePeriodInfo PeriodDifferInfo,
AdjustResultMatrix Adjustment,
SatelliteNumber BasePrn,
GnssParamNameBuilder nameBuilder)
: base(PeriodDifferInfo, Adjustment, nameBuilder)
{
this.BasePrn = BasePrn;
}
/// <summary>
/// 精密单点定位结果构造函数。
/// </summary>
/// <param name="receiverInfo">接收信息</param>
/// <param name="Adjustment">平差</param>
/// <param name="paramNames">参数名称</param>
public UncombinedPppResult(
EpochInformation receiverInfo,
AdjustResultMatrix Adjustment, GnssParamNameBuilder positioner
)
: base(receiverInfo, Adjustment, positioner)
{
this.WetTropoFactor = this.ResultMatrix.Corrected.CorrectedValue[Adjustment.GetIndexOf(Gnsser.ParamNames.WetTropZpd)];
//处理模糊度
}
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>
/// 单站单历元GNSS计算预留测试类
/// </summary>
/// <param name="receiverInfo">接收信息</param>
/// <param name="Adjustment">平差</param>
/// <param name="positioner">定位器</param>
/// <param name="baseParamCount">基础参数数量</param>
public SingeSiteGnssExtentResult(
EpochInformation receiverInfo,
AdjustResultMatrix Adjustment,
GnssParamNameBuilder positioner,
int baseParamCount = 5
)
: base(receiverInfo, Adjustment, positioner)
{
}
/// <summary>
/// 双差差分定位结果。具有模糊度。
/// </summary>
/// <param name="Adjustment"></param>
/// <param name="BasePrn"></param>
/// <param name="DifferPositionOption"></param>
/// <param name="PeriodDifferInfo"></param>
/// <param name="nameBuilder"></param>
public PeriodDoubleDifferPositionResult(
MultiSitePeriodInfo PeriodDifferInfo,
AdjustResultMatrix Adjustment,
SatelliteNumber BasePrn,
GnssProcessOption DifferPositionOption, GnssParamNameBuilder nameBuilder)
: base(PeriodDifferInfo, Adjustment, BasePrn, nameBuilder)
{
this.Option = DifferPositionOption;
}
/// <summary>
/// 滤波
/// </summary>
/// <param name="newVal"></param>
/// <returns></returns>
public RmsedNumeral Filter(RmsedNumeral newVal)
{
var builder = new OneDimAdjustMatrixBuilder(newVal, PrevAdjustment);
var sp = new SimpleKalmanFilter();
var a = sp.Run(builder);
var est = a.Estimated;
this.PrevAdjustment = a;//update
return(new RmsedNumeral(est[0], est.GetRmsVector()[0]));
}
/// <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>
/// 水平Kalman滤波
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
private double DoLevelKalmanFilter(double val)
{
var builder = new OneDimAdjustMatrixBuilder(val, Adjustment);
var sp = new SimpleKalmanFilter();
Adjustment = sp.Run(builder);
var smoothData = Adjustment.Estimated[0];
return(smoothData);
}
/// <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;
}
public override BaseGnssResult CaculateIndependent(MultiSitePeriodInfo epochInfos)
{
if (!this.MatrixBuilder.IsAdjustable)
{
log.Warn("不适合平差！" + MatrixBuilder.Message); return(null);
}
this.Adjustment = this.RunAdjuster(BuildAdjustObsMatrix(this.CurrentMaterial));
AdjustResultMatrix lastFloat = this.Adjustment;
return(BuildResult());
}
/// <summary>
/// GNSS结果构造函数
/// </summary>
/// <param name="epochInfo">历元信息</param>
/// <param name="Adjustment">平差信息</param>
/// <param name="NameBuilder">参数生成器</param>
public BaseGnssResult(
TMaterial epochInfo,
AdjustResultMatrix Adjustment,
GnssParamNameBuilder NameBuilder, bool isTopSpeed = false)
: base(epochInfo, Adjustment, NameBuilder)
{
this.Name = epochInfo.Name;
this.MaterialObj = epochInfo;
if (!isTopSpeed)
{
TrySetCommonParamValues(Adjustment);
}
}
/// <summary>
/// 滤波。默认期望为常数。
/// </summary>
/// <param name="rawValue"></param>
/// <returns></returns>
protected double Filter(double rawValue)
{
AdjustResultMatrix prev = CurrentAdjustment;
var builder = new OneDimAdjustMatrixBuilder(rawValue, prev);
var sp = new SimpleKalmanFilter();
var ad = sp.Run(builder);
CurrentAdjustment = ad;
var smoothData = ad.Estimated[0];
return(smoothData);
}
/// <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="receiverInfo">接收信息</param>
/// <param name="Adjustment">平差</param>
/// <param name="paramNames">参数名称</param>
public int Process(EpochInformation receiverInfo, AdjustResultMatrix Adjustment)
{
int m = 0, stat = 0;
int n = receiverInfo.EnabledPrns.Count;
int[] NW = new int[n * n];
int[] sat1 = new int[n * n];
int[] sat2 = new int[n * n];
//average LC
ComputeAverage_LC(receiverInfo);
//fix wide-lane ambiguity
for (int i = 0; i < n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
//test already fixed
if (ambc[receiverInfo[i].Prn].flags[receiverInfo[j].Prn] != 0 &&
ambc[receiverInfo[j].Prn].flags[receiverInfo[i].Prn] != 0)
{
continue;
}
sat1[m] = receiverInfo[i].Prn.PRN; //只考虑GPS的固定
sat2[m] = receiverInfo[j].Prn.PRN;
if (fix_amb_WL(receiverInfo, sat1[m], sat2[m], ref NW[m]) == 1)
{
m++;
}
}
}
//fix narrow-lane ambiguity
//AR mode: PPP_AR (目前实现的)
stat = fxi_amb_NL_ROUND(receiverInfo, Adjustment, sat1, sat2, NW, m);
//AR mode: PPP_AR ILS
return(stat);
}
/// <summary>
/// 运行计算器
/// </summary>
/// <param name="obsMatrix"></param>
/// <returns></returns>
protected virtual AdjustResultMatrix RunAdjuster(AdjustObsMatrix obsMatrix)
{
AdjustResultMatrix result = null;
if (this.Option.IsAdjustEnabled)
{
result = this.MatrixAdjuster.Run(obsMatrix);
}
else
{
result = new AdjustResultMatrix()
{
ObsMatrix = obsMatrix
};
}
return(result);
}
/// <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>
/// 参数估计
/// </summary>
/// <returns></returns>
public PlainXyConvertParam Estimate()
{
var obsVector = new Vector(ObsCount);
//构建观测向量
for (int i = 0; i < CoordCount; i++)
{
int index = 2 * i;
var oldXy = OldOrTobeConvertingXys[i];
var newXy = NewOrTargedXys[i];
obsVector[index + 0] = newXy.X - oldXy.X;
obsVector[index + 1] = newXy.Y - oldXy.Y;
}
//构建系数阵
Matrix coeffOfParam = new Matrix(ObsCount, 4);
for (int i = 0; i < CoordCount; i++)
{
int index = 2 * i;
var oldXy = OldOrTobeConvertingXys[i];
//尺度因子，
coeffOfParam[index + 0, 0] = 1;
coeffOfParam[index + 1, 1] = 1;
//转换参数，弧度
coeffOfParam[index + 0, 2] = oldXy.X;
coeffOfParam[index + 0, 3] = oldXy.Y;
coeffOfParam[index + 1, 2] = oldXy.Y;
coeffOfParam[index + 1, 3] = -oldXy.X;
}
AdjustObsMatrix obsMatrix = new AdjustObsMatrix();
obsMatrix.SetCoefficient(coeffOfParam).SetObservation(obsVector);
var adjuster = new ParamAdjuster();
this.ResultMatrix = adjuster.Run(obsMatrix);
var ested = ResultMatrix.Estimated;
var result = new PlainXyConvertParam(new XY(ested[0], ested[1]), ested[2] * 1e6, ested[3] * CoordConsts.RadToSecMultiplier);
return(result);
}
/// <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;
}
}
