/// <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);
}
