public void CheckAndSet(FrequenceType phaseName, SatelliteNumber prn)
{
if (!Contians(phaseName, prn))
{
this.data[phaseName][prn] = new List <SlipMarker>();
}
}
/// <summary>
/// 对载波距离进行修正，若超出一定的距离。
/// </summary>
/// <param name="prn"></param>
/// <param name="freqType"></param>
/// <param name="PhaseRangeMinusPseudorange"></param>
/// <returns></returns>
private double RevisePhaseRange(SatelliteNumber prn, FrequenceType freqType, double PhaseRangeMinusPseudorange)
{
if (!PreviousData.ContainsKey(prn))
{
PreviousData[prn] = new Dictionary <FrequenceType, double>();
}
if (!PreviousData[prn].ContainsKey(freqType))
{
PreviousData[prn][freqType] = 0;
}
else
{
var prevValue = PreviousData[prn][freqType];
if (PhaseRangeMinusPseudorange < prevValue - 750.0)
{
PhaseRangeMinusPseudorange += 1500.0;
}
else if (PhaseRangeMinusPseudorange > prevValue + 750.0)
{
PhaseRangeMinusPseudorange -= 1500.0;
}
}
PreviousData[prn][freqType] = PhaseRangeMinusPseudorange;
return(PhaseRangeMinusPseudorange);
}
public void CheckAndSet(FrequenceType phaseName)
{
if (!Contians(phaseName))
{
this.data[phaseName] = new Dictionary <SatelliteNumber, List <SlipMarker> >();
}
}
/// <summary>
/// 获取窗口
/// </summary>
/// <param name="prn"></param>
/// <param name="frequenceType"></param>
/// <returns></returns>
public TimeNumeralWindowData GetBufferValues(SatelliteNumber prn, FrequenceType frequenceType)
{
TimeNumeralWindowData window = new TimeNumeralWindowData(WindowSize);
var buffer = this.Buffers;
//首先从过去的
var lastWindowOfP1 = LastWindowDataManager.GetOrCreate(BuildKey(prn, frequenceType));
window.Add(lastWindowOfP1);
//然后从bufffer里面提取另一半
var bufferOfEpoches = buffer.GetSubList(0, HalfWindowSize);
foreach (var epoch in bufferOfEpoches)
{
if (epoch.Contains(prn))
{
var sat = epoch[prn];
var time = epoch.ReceiverTime;
var p = sat[frequenceType].PseudoRange.Value;//原始数据
window.Add(time, p);
}
}
return(window);
}
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);
}
public List <SlipMarker> GetClipeMarkers(FrequenceType phaseA, SatelliteNumber prn)
{
if (Contians(phaseA, prn))
{
return(data[phaseA][prn]);
}
return(new List <SlipMarker>());
}
/// <summary>
/// 获取 RINEX 频率编号。
/// </summary>
/// <param name="satType"></param>
/// <param name="frequenceType"></param>
/// <returns></returns>
public static List <int> GetRinexFrequenceNumber(SatelliteType satType, FrequenceType frequenceType)
{
Dictionary <FrequenceType, List <int> > dic = GetRinexFreqIndexDic(satType);
if (dic.ContainsKey(frequenceType))
{
return(dic[frequenceType]);
}
return(new List <int>());
}
/// <summary>
/// 通用构造函数
/// </summary>
/// <param name="band">频率</param>
/// <param name="FrequenceType">频率类型</param>
public FreqenceObservation(Frequence band, FrequenceType FrequenceType)
{
this.FrequenceType = FrequenceType;
this.Frequence = band;
this.CommonCorrection = new NumerialCorrectionDic();
this.PhaseOnlyCorrection = new NumerialCorrectionDic();
this.RangeOnlyCorrection = new NumerialCorrectionDic();
this.Enabled = true;
this.Message = "";
}
/// <summary>
/// 设置改正的误差
/// </summary>
/// <param name="sat"></param>
/// <param name="frequenceType"></param>
private void SetPolyFitCorrection(EpochSatellite sat, FrequenceType frequenceType)
{
var prn = sat.Prn;
var sp = GetBufferValues(prn, frequenceType).GetPolyFitValue(sat.ReceiverTime, 2);
if (sp.Rms > 10)
{
log.Warn("多项式平滑伪距效果差！ RMS: " + sp.Rms);
return;
}
var correctionOfP = sp.Value - sat[frequenceType].PseudoRange.Value;
sat[frequenceType].PseudoRange.Corrections.Add("PolyFit", correctionOfP);
}
/// <summary>
/// 获取无电离层组合量,双频无电离层距离组合,返回已改正后的值。s
/// </summary>
/// <param name="type1"></param>
/// <param name="type2"></param>
/// <param name="isPsuedoOrPhaseRange">是否伪距或相位距离</param>
/// <returns></returns>
public PhaseCombination GetIonoFreeRangeOf(FrequenceType type1, FrequenceType type2, bool isPsuedoOrPhaseRange)
{
var freA = EpochSat[type1];
var freB = EpochSat[type2];
Frequence A = freA.Frequence;
Frequence B = freB.Frequence;
Frequence freqence = GetIonoFreeComPhaseFrequence(A, B);
double rangeA = 0;
double rangeB = 0;
if (isPsuedoOrPhaseRange)
{
rangeA = freA.PseudoRange.CorrectedValue;
rangeB = freB.PseudoRange.CorrectedValue;
}
else
{
rangeA = freA.PhaseRange.CorrectedValue;
rangeB = freB.PhaseRange.CorrectedValue;
}
if (rangeA == 0)
{
if (rangeB == 0)
{
log.Debug(this.EpochSat.Prn + ", " + this.EpochSat.ReceiverTime + ", 载波 “" + type1 + "”和载波 “" + type2 + "”的" + (isPsuedoOrPhaseRange?"伪距":"载波") + "都为 0 。");
return(new PhaseCombination(0, freqence));
throw new ArgumentNullException("载波 1 和载波 2 的伪距都为 0 。");
}
else
{
return(new PhaseCombination(rangeB, freqence));
}
}
else if (rangeB == 0)
{
return(new PhaseCombination(rangeA, freqence));
}
double[] facs = GetIonoFreeRangeCombFactors(A, B);
double fac1 = facs[0];
double fac2 = facs[1];
double range = GetCombinationValue(fac1, rangeA, fac2, rangeB);
//伪距也用组合
var val = new PhaseCombination(range, freqence);
return(val);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="IsUseGNSSerSmoothRangeMethod"></param>
/// <param name="ObsDataType"></param>
/// <param name="WindowSize"></param>
/// <param name="isWeighted"></param>
/// <param name="FrequenceType"></param>
/// <param name="isDeltaIonoFit"></param>
/// <param name="OrderOfDeltaIonoPolyFit"></param>
/// <param name="BufferSize"></param>
/// <param name="ionoFitEpochCount"></param>
/// <param name="SmoothRangeType"></param>
/// <param name="IndicatedIonoDeltaFilePath"></param>
public SingleFreqSelfIonoRangeReviser(bool IsUseGNSSerSmoothRangeMethod,
SatObsDataType ObsDataType,
int WindowSize,
bool isWeighted,
FrequenceType FrequenceType,
IonoDifferCorrectionType isDeltaIonoFit,
int OrderOfDeltaIonoPolyFit, int BufferSize, int ionoFitEpochCount, SmoothRangeSuperpositionType SmoothRangeType, string IndicatedIonoDeltaFilePath)
: this(IsUseGNSSerSmoothRangeMethod,
ObsDataType,
WindowSize, isWeighted,
new List <FrequenceType>() { FrequenceType },
isDeltaIonoFit,
OrderOfDeltaIonoPolyFit, BufferSize, ionoFitEpochCount, SmoothRangeType, IndicatedIonoDeltaFilePath)
{
}
/// <summary>
/// 获取电离层格网模型延迟
/// </summary>
/// <param name="sat"></param>
/// <param name="frequenceType"></param>
/// <param name="IonoService"></param>
/// <returns></returns>
public static double GetGridModelCorrection(EpochSatellite sat, FrequenceType frequenceType, IIonoService IonoService)
{
//计算穿刺点获取电离层浓度
var punctPoint = sat.GetIntersectionXyz(IonoService.HeightOfModel);
var geocentricLonLat = Geo.Coordinates.CoordTransformer.XyzToSphere(punctPoint);
var tec = IonoService.GetSlope(sat.ReceiverTime, geocentricLonLat, sat.SphereElevation);
if (tec == null || tec.Value == 0)
{
return(0);
}
Frequence freq = sat[frequenceType].Frequence;
double slopeDelayFreqA = 1.0 * GetIonoDelayRange(tec.Value, freq.Value);//斜方向延迟
return(slopeDelayFreqA);
}
/// <summary>
/// 通过前两个预报当前值。预报值采用上一段差值。
/// </summary>
/// <param name="prev1"></param>
/// <param name="prev2"></param>
/// <param name="commonPrns"></param>
/// <param name="frequenceType"></param>
/// <returns></returns>
public BaseDictionary <SatelliteNumber, double> GetPredicted(
EpochInformation prev2,
EpochInformation prev1,
List <SatelliteNumber> commonPrns,
FrequenceType frequenceType)
{
//从前和后，两个方向预报当前星和上一个的大小
var predictedCurrent = new BaseDictionary <SatelliteNumber, double>();
foreach (var item in commonPrns)
{
var prev2Val = prev2[item][frequenceType].PhaseRange.Value;
var prev1Val = prev1[item][frequenceType].PhaseRange.Value;
predictedCurrent[item] = prev1Val + (prev1Val - prev2Val);//上一减去上二，得钟跳前差,以此差预报下一个
}
return(predictedCurrent);
}
public static Frequence GetFrequence(SatelliteNumber prn, ObsPhaseType ObsPhaseType, Geo.Times.Time time = default(Geo.Times.Time))
{
FrequenceType ft = FrequenceType.A;
switch (ObsPhaseType)
{
case ObsPhaseType.L1:
ft = FrequenceType.A;
break;
case ObsPhaseType.L2:
ft = FrequenceType.B;
break;
default:
break;
}
return(GetFrequence(prn, ft, time));
}
/// <summary>
/// 获取，优先匹配第一个
/// </summary>
/// <param name="frequenceType"></param>
/// <param name="prefix"></param>
/// <returns></returns>
private RinexObsValue GetRinexObsValue(FrequenceType frequenceType, params string [] prefix)
{
List <int> builedFreq = ObsCodeConvert.GetRinexFrequenceNumber(Prn.SatelliteType, frequenceType);
foreach (var item in this)
{
foreach (var freq in builedFreq)
{
foreach (var pre in prefix)
{
var keyCode = pre + freq;
if (item.Key.Contains(keyCode) && item.Value.Value != 0)
{
return(item.Value);
}
}
}
}
return(null);
}
public EBAFrequenceAttribute(FrequenceType type, double unit)
{
switch (type)
{
case FrequenceType.Second:
seconds = unit;
break;
case FrequenceType.Minute:
seconds = unit * 60;
break;
case FrequenceType.Hour:
seconds = unit * 60 * 60;
break;
case FrequenceType.Day:
seconds = unit * 60 * 60 * 24;
break;
}
}
/// <summary>
/// 通过前两个历元，预报当前历元，并与当前历元实际数值作差。返回预报差值。
/// </summary>
/// <param name="prev2"></param>
/// <param name="prev1"></param>
/// <param name="current"></param>
/// <param name="commonPrns"></param>
/// <param name="frequenceType"></param>
/// <returns></returns>
public BaseDictionary <SatelliteNumber, double> GetPredictedDiffer(
EpochInformation prev2,
EpochInformation prev1,
EpochInformation current,
List <SatelliteNumber> commonPrns,
FrequenceType frequenceType)
{
var predictedCurrent = GetPredicted(prev2, prev1, commonPrns, frequenceType);
//最后比较预报与实际二者之差
var currentPreditceDiffer = new BaseDictionary <SatelliteNumber, double>();
foreach (var item in commonPrns)
{
var predictValue = predictedCurrent[item];
var trueVal = current[item][frequenceType].PhaseRange.Value;
var differ = predictValue - trueVal;
currentPreditceDiffer[item] = differ;
}
return(currentPreditceDiffer);
}
/// <summary>
/// 通过卫星和观测类型获取频率。注意：无电离层组合默认采用L1频率
/// </summary>
/// <param name="prn"></param>
/// <param name="SatObsDataType"></param>
/// <param name="time">时间，历元，GLONASS或频分多址需要</param>
/// <returns></returns>
public static Frequence GetFrequence(SatelliteNumber prn, SatObsDataType SatObsDataType, Geo.Times.Time time = default(Geo.Times.Time))
{
FrequenceType ft = FrequenceType.A;
switch (SatObsDataType)
{
case SatObsDataType.PhaseRangeA:
case SatObsDataType.PseudoRangeA:
case SatObsDataType.PhaseA:
case SatObsDataType.IonoFreePhaseRange:
case SatObsDataType.IonoFreeRange:
case SatObsDataType.AlignedIonoFreePhaseRange:
case SatObsDataType.AlignedIonoFreePhaseRangeOfTriFreq:
case SatObsDataType.IonoFreePhaseRangeOfTriFreq:
case SatObsDataType.IonoFreeRangeOfTriFreq:
ft = FrequenceType.A; //注意：无电离层组合默认采用L1频率，2018.11.05, czs, hmx
break;
case SatObsDataType.PhaseRangeB:
case SatObsDataType.PseudoRangeB:
case SatObsDataType.PhaseB:
ft = FrequenceType.B;
break;
case SatObsDataType.PhaseRangeC:
case SatObsDataType.PseudoRangeC:
case SatObsDataType.PhaseC:
ft = FrequenceType.C;
break;
default:
log.Warn("无法得到可行的频率" + prn.SatelliteType + " " + SatObsDataType + " ，默认采用 " + ft);
break;
}
return(GetFrequence(prn, ft, time));
}
private static string BuildSatFreqName(EpochSatellite sat, FrequenceType freq)
{
return(sat.Prn + "_" + freq);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="Prn"></param>
/// <param name="Time"></param>
/// <param name="ObservationNames"></param>
public SlipMarker(SatelliteNumber Prn, Time GpsTime, FrequenceType PhaseName)
{
this.Prn = Prn;
this.GpsTime = GpsTime;
this.PhaseName = PhaseName;
}
/// <summary>
/// 获取频率带宽
/// </summary>
/// <param name="type">系统类型</param>
/// <param name="freqType">频率类型</param>
/// <param name="satNumber">卫星编号，GLONASS 系统需要</param>
/// <param name="time">time，GLONASS 系统需要</param>
/// <returns></returns>
public static Frequence GetFrequenceBand(GnssType type, FrequenceType freqType, int satNumber = -1, Time time = default(Time))
{
switch (type)
{
case GnssType.GPS:
case GnssType.SBAS:
switch (freqType)
{
case FrequenceType.A: return(Frequence.GpsL1);
case FrequenceType.B: return(Frequence.GpsL2);
case FrequenceType.C: return(Frequence.GpsL5);
default:
return(null);
// throw new ArgumentException("GPS 有三个频率。分别以编号1、2、3表示。");
}
case GnssType.Galileo:
switch (freqType)
{
case FrequenceType.A: return(Frequence.GalileoE1);
case FrequenceType.B: return(Frequence.GalileoE5a);
case FrequenceType.C: return(Frequence.GalileoE5b);
case FrequenceType.D: return(Frequence.GalileoE5);
case FrequenceType.E: return(Frequence.GalileoE6);
default:
return(null);
// throw new ArgumentException("Galileo 有5个频率。分别以编号 1-5 表示。");
}
case GnssType.BeiDou: //215786
switch (freqType)
{
case FrequenceType.A: return(Frequence.CompassB1);
case FrequenceType.B: return(Frequence.CompassB2);
case FrequenceType.C: return(Frequence.CompassB3);
default:
return(null);
// throw new ArgumentException("BeiDou 有三个频率。分别以编号1、2、3表示。");
}
case GnssType.GLONASS:
if (satNumber == -1)
{
throw new ArgumentException("GLONASS是频分多址，需要指定卫星编号，此处有待改进！！！！请联系开发人员。");
}
var prn = new SatelliteNumber(satNumber, SatelliteType.R);
var k = (int)GlobalGlonassSlotFreqService.Instance.Get(prn, time);
// var k = Setting.GnsserConfig.GlonassSlotFrequences[prn];
switch (freqType)
{
case FrequenceType.A: return(Frequence.GetGlonassG1(k));
case FrequenceType.B: return(Frequence.GetGlonassG2(k));
case FrequenceType.C: return(Frequence.GlonassG3);
default:
return(null);
// throw new ArgumentException("GLONASS 有2个载波。分别以编号1、2表示。");
}
case GnssType.QZSS:
switch (freqType)
{
case FrequenceType.A: return(Frequence.GpsL1);
case FrequenceType.B: return(Frequence.GpsL2);
case FrequenceType.C: return(Frequence.GpsL5);
case FrequenceType.D: return(Frequence.QzssL6);
default:
return(null);
}
case GnssType.NAVIC:
switch (freqType)
{
case FrequenceType.A: return(Frequence.NavicL5);
default:
return(null);
}
default:
switch (freqType)
{
case FrequenceType.A: return(Frequence.GpsL1);
case FrequenceType.B: return(Frequence.GpsL2);
case FrequenceType.C: return(Frequence.GpsL5);
default:
return(null);
}
}
throw new ArgumentException(type + "尚不支持，请联系管理员。");
}
/// <summary>
/// 设置频率类型
/// </summary>
/// <param name="FrequenceType"></param>
/// <returns></returns>
public RinexFreqObsBuilder SetFrequenceType(FrequenceType FrequenceType)
{
this.FrequenceType = FrequenceType; return(this);
}
/// <summary>
/// 校正其中一个。
/// </summary>
/// <param name="sat"></param>
/// <param name="freq"></param>
/// <param name="obsFreq"></param>
private void ReviseOneFreq(EpochSatellite sat, FrequenceType freq, FreqenceObservation obsFreq)
{
double correction = 0;
RmsedNumeral corredRange = RmsedNumeral.Zero;
var rangeObservation = obsFreq.PseudoRange;
double rawRange = rangeObservation.Value;
double rawPhase = obsFreq.PhaseRange.Value;
var PS = PhaseSmoothedRangeBuilderManager.GetOrCreate(BuildSatFreqName(sat, freq));
double ionoDiffer = 0;
switch (this.PhaseSmoothedRangeBuilderManager.IonoDifferCorrectionType)
{
case IonoDifferCorrectionType.No:
break;
case IonoDifferCorrectionType.DualFreqCarrier:
ionoDiffer = sat.GetIonoLenByDifferPhase(freq);
break;
case IonoDifferCorrectionType.WindowPolyfit:
break;
case IonoDifferCorrectionType.WindowWeightedAverage:
break;
case IonoDifferCorrectionType.IndicatedFile:
if (IonoDeltaTable == null)
{
log.Warn("电离层延迟变化表格为NULL！无法改正");
}
else
{
var dat = InputedIonoDelta.Get(sat.Prn.ToString());
if (dat != null)
{
var win = dat.GetNumeralWindowData(sat.ReceiverTime);
if (win != null)
{
ionoDiffer = win.GetPolyFitValue(sat.ReceiverTime, 1, 2).Value;
}
}
}
break;
default:
break;
}
corredRange = PS.SetReset(sat.IsUnstable)
.SetRawValue(sat.ReceiverTime, rawRange, rawPhase, ionoDiffer)
.Build();
correction = corredRange.Value - rawRange;
//规定：原生观测量改正到观测值上【在观测方程的左边，因此符号不变】。 //2018.05.29, czs, int hmx
CorrectionNames name = CorrectionNames.PhaseSmoothRange;
switch (freq)
{
case FrequenceType.A:
name = CorrectionNames.PhaseSmoothRangeA;
break;
case FrequenceType.B:
name = CorrectionNames.PhaseSmoothRangeB;
break;
case FrequenceType.C:
name = CorrectionNames.PhaseSmoothRangeC;
break;
default:
name = CorrectionNames.PhaseSmoothRange;
break;
}
rangeObservation.SetCorrection(name, correction);
sat.StdDevOfRange = corredRange.StdDev;
//检查更新电离层改正
if (PS is GnsserWindowedPhaseSmoothedRangeBuilder)
{
obsFreq.TempAmbiguityAndIonoLength = ((GnsserWindowedPhaseSmoothedRangeBuilder)PS).SmoothRangeWindow.CurrentIonoAndHalfLambdaLen;
}
}
/// <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);
}
string BuildKey(SatelliteNumber prn, FrequenceType frequenceType)
{
return(prn + "_" + frequenceType);
}
public bool Contians(FrequenceType phaseName, SatelliteNumber prn, Time time)
{
return(Contians(phaseName, prn) && data[phaseName][prn].Exists(m => m.GpsTime.Equals(time)));
}
/// <summary>
/// 构建，如果可以，默认支持3个频率
/// </summary>
/// <returns></returns>
public override EpochSatellite Build(RinexSatObsData observtion)
{
EpochSatellite epochSat = new EpochSatellite(this.EpochInfo, prn);
//需要重新修改，RINEX 3.0 有的对 BDS 是 C1，C7, C6,3.02 明确规定是 C2， C7, C6
Dictionary <FrequenceType, List <int> > freqDic = ObsCodeConvert.GetRinexFreqIndexDic(observtion.Prn.SatelliteType);
//新算法，2018.09.24，hmx
var freqNums = observtion.GetFrequenceNums();
foreach (var num in freqNums)
{
var prn = observtion.Prn;
FrequenceType freqType = ObsCodeConvert.GetFrequenceType(freqDic, num);
Frequence band = Frequence.GetFrequence(prn, freqType, Time);
if (band == null)
{
band = Frequence.Default;
log.Warn("系统并未设置 " + prn.SatelliteType + " 的第 " + freqType + " 频率， 以 " + band + " 代替 ！");
}
FreqenceObservation freqObs1 = FreqObsBuilder
.SetFrequenceType(freqType)
.SetFrequence(band)
.SetRinexFrequenceNumber(num)
.Build(observtion);
epochSat.Set(freqObs1.FrequenceType, freqObs1);
}
//次新算法，比较繁琐，2018
//List<FrequenceType> builded = new List<FrequenceType>();
//foreach (var item in observtion)
//{
// var num = Geo.Utils.StringUtil.GetNumber(item.Key);
// FrequenceType freqType = ObsCodeConvert.GetFrequenceType(freqDic, num);// (FrequenceType)(builedFreq.IndexOf(num) + 1);
// if (!builded.Contains(freqType)) { builded.Add(freqType); }
// else { continue; }
// FreqenceObservation freqObs1 = FreqObsBuilder
// .SetFrequenceType(freqType)
// .SetRinexFrequenceNumber(num)
// .Build(observtion);
// epochSat.Set(freqObs1.FrequenceType, freqObs1);
//}
/** //老算法，只支持3个频率
#region 转换观测值到频率A、频率B、频率C的基本观测值
* //第一频率
* FreqenceObservation freqObs = FreqObsBuilder
* .SetFrequenceType(FrequenceType.A).Build(observtion);
* epochSat.Set(freqObs.FrequenceType, freqObs);
*
* //第二频率
* freqObs = FreqObsBuilder
* .SetFrequenceType(FrequenceType.B).Build(observtion);
* if (freqObs != null) epochSat.Set(freqObs.FrequenceType, freqObs);
*
* //第三频率
* freqObs = FreqObsBuilder
* .SetFrequenceType(FrequenceType.C).Build(observtion);
* if (freqObs != null) epochSat.Set(freqObs.FrequenceType, freqObs);
#endregion
*/
return(epochSat);
}
/// <summary>
/// 获取已知卫星的频率带宽
/// </summary>
/// <param name="type"></param>
/// <param name="freqtType"></param>
/// <param name="satNumber">卫星编号，GLONASS需要</param>
/// <returns></returns>
public static Frequence GetFrequence(SatelliteType type, FrequenceType freqtType, int satNumber = -1, Geo.Times.Time time = default(Geo.Times.Time))
{
return(ObsCodeConvert.GetFrequenceBand(GnssSystem.GetGnssType(type), freqtType, satNumber, time));
}
/// <summary>
/// Common constructor
/// </summary>
/// <param name="watchFlag">cycle slip flag to be watched，默认的是L1频率的周跳标识</param>
/// <param name="delUnstableSats">whether unstable satellites will be deleted.</param>
/// <param name="unstableTime">unmber of fraction since last arc change that a satellite will be considered as unstable</param>
public SatArcMarkerFilter(FrequenceType watchFlag, bool delUnstableSats, double unstableTime)
{
WatchCsFlag = watchFlag; //默认的是L1频率的周跳标识
DeleteUnstableSat = delUnstableSats;
UnstablePeriod = unstableTime; //unstableTime value
}
/// <summary>
/// 获取频率
/// </summary>
/// <param name="prn"></param>
/// <param name="frequenceType"></param>
/// <param name="time">时间，历元，GLONASS或频分多址需要</param>
/// <returns></returns>
public static Frequence GetFrequence(SatelliteNumber prn, FrequenceType frequenceType, Geo.Times.Time time = default(Geo.Times.Time))
{
return(GetFrequence(prn.SatelliteType, frequenceType, prn.PRN, time));
}
