/// <summary>
/// 写周跳到文件
/// </summary>
/// <param name="outputDirectory"></param>
/// <param name="soureName"></param>
/// <param name="ObsPhaseDataType"></param>
public void WriteStorageToFile(string outputDirectory, string soureName, SatObsDataType ObsPhaseDataType)
{
var OutputDirectory = Path.Combine(outputDirectory, "CycleSlipOf_" + soureName);
//先写汇总
Geo.Utils.FileUtil.CheckOrCreateDirectory(OutputDirectory);
var path = Path.Combine(OutputDirectory, BuildFileName(soureName, this.DetectorType, ObsPhaseDataType));
this.CycleSlipStorage.WriteToFile(path);
//再写各个分结果
foreach (var itemReviser in this.CycleSlipDetectors)
{
//生成子目录
var directory = Path.Combine(OutputDirectory, itemReviser.DetectorType.ToString());
Geo.Utils.FileUtil.CheckOrCreateDirectory(directory);
var subName = BuildFileName(soureName, itemReviser.DetectorType, ObsPhaseDataType);
var subPath = Path.Combine(directory, subName);
itemReviser.CycleSlipStorage.WriteToFile(subPath);
itemReviser.TableObjectManager.OutputDirectory = directory;
itemReviser.TableObjectManager.WriteAllToFileAndCloseStream();
}
}
/// <summary>
/// 获取指定测站，指定卫星的多历元数据向量。
/// 名称为时间。
/// </summary>
/// <param name="siteName"></param>
/// <param name="prn"></param>
/// <param name="dataType"></param>
/// <param name="defaultValue"></param>
/// <returns></returns>
public Vector GetVector(string siteName, SatelliteNumber prn, SatObsDataType dataType, double defaultValue = Double.NaN)
{
Vector vector = new Vector(this.EpochCount);
int i = 0;
string name = "";
foreach (var epochSites in this)
{
double val = defaultValue;
name = epochSites.ReceiverTime.ToShortTimeString();
foreach (var epochSite in epochSites)
{
if (epochSite.Name == siteName)
{
if (epochSite.Contains(prn))
{
val = epochSite[prn][dataType].Value;
}
}
}
vector[i] = val;
vector.ParamNames[i] = name;
}
return(vector);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="IsUseGNSSerSmoothRangeMethod"></param>
/// <param name="ObsDataType"></param>
/// <param name="WindowSize"></param>
/// <param name="isWeighted"></param>
/// <param name="FrequenceTypes"></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,
List <FrequenceType> FrequenceTypes,
IonoDifferCorrectionType isDeltaIonoFit,
int OrderOfDeltaIonoPolyFit, int BufferSize, int ionoFitEpochCount, SmoothRangeSuperpositionType SmoothRangeType, string IndicatedIonoDeltaFilePath)
{
this.Name = "单频电离层自我改正";
this.ObsDataType = ObsDataType;
this.FrequenceTypes = FrequenceTypes;
this.PhaseSmoothedRangeBuilderManager = new CarrierSmoothedRangeBuilderManager(
IsUseGNSSerSmoothRangeMethod, WindowSize, isWeighted, isDeltaIonoFit, OrderOfDeltaIonoPolyFit, BufferSize, ionoFitEpochCount, SmoothRangeType)
{
IndicatedIonoDeltaFilePath = IndicatedIonoDeltaFilePath
};
this.IsDualIonoFree = this.ObsDataType == SatObsDataType.IonoFreePhaseRange ||
this.ObsDataType == SatObsDataType.IonoFreeRange;
this.Data = new BaseDictionary <SatelliteNumber, TimeNumeralWindowData>("数据",
new Func <SatelliteNumber, TimeNumeralWindowData>(prn => new TimeNumeralWindowData(WindowSize)
));
TableObjectStorages = new ObjectTableManager();
TableObjectStorage = TableObjectStorages.AddTable("模糊度概略距离值");
log.Info("启用：" + this.Name + " 对观测值进行改正！是否双频：" + IsDualIonoFree);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="AmbiguityFilePath"></param>
/// <param name="IsUsingAmbiguityFile"></param>
/// <param name="ObsDataType"></param>
public AmbiguityManager(string AmbiguityFilePath, bool IsUsingAmbiguityFile, SatObsDataType ObsDataType)
{
this.AmbiguityFilePath = AmbiguityFilePath;
this.IsUsingAmbiguityFile = IsUsingAmbiguityFile;
this.SatObsDataType = ObsDataType;
Init();
}
/// <summary>
/// 周跳探测,并进行标记，而不修复。 默认构造函数。
/// </summary>
public AverageDetector(SatObsDataType obsType, double maxMaxRmsTimesOfLsPolyCs, double maxBreakingEpochCount, bool isUsingRecoredCsInfo)
: base(maxBreakingEpochCount, isUsingRecoredCsInfo)
{
Name = "平均数探测法";
this.SatObsDataType = obsType;
MaxRmsTimes = maxMaxRmsTimesOfLsPolyCs;
this.WindowSize = 5;
}
internal Vector GetAdjustVector(SatObsDataType ObsDataType, bool enabledSatOnly = true)
{
Vector list = new Vector(this.Count);
foreach (var item in this)
{
list.Add(item.GetAdjustValue(ObsDataType), item.ReceiverTime.ToShortTimeString());
}
return(list);
}
internal List <Vector> GetAdjustVector(SatObsDataType ObsDataType, bool enabledSatOnly = true)
{
List <Vector> list = new List <Vector>();
foreach (var item in this)
{
list.Add(item.GetAdjustVector(ObsDataType, enabledSatOnly));
}
return(list);
}
/// <summary>
/// 创建周跳探测的矫正器
/// </summary>
/// <param name="obsType"></param>
/// <param name="types"></param>
/// <param name="Option">GNSS数据处理选项</param>
/// <param name="isRevered">是否逆序探测，如果是，探测时将不会使用已有周跳信息</param>
/// <returns></returns>
public static CycleSlipDetectReviser CreateCycleSlipReviser(SatObsDataType obsType, List <CycleSlipDetectorType> types, GnssProcessOption Option, bool isRevered = false)
{
bool isUseRecorded = !isRevered && Option.IsUsingRecordedCycleSlipInfo;
CycleSlipDetectReviser reviser = new CycleSlipDetectReviser();
foreach (var type in types)
{
reviser.Add(Create(obsType, type, Option, isRevered));
}
return(reviser);
}
/// <summary>
/// 周跳探测,并进行标记，而不修复。 默认构造函数。
/// </summary>
public HighDifferSlipDetector(SatObsDataType obsType, double MaxValueDifferOfHeigherDifferCs, double maxBreakingEpochCount, bool isUsingRecordedCsInfo)
: base(maxBreakingEpochCount, isUsingRecordedCsInfo)
{
MaxValueDiffer = MaxValueDifferOfHeigherDifferCs; //14
//if (obsType.ToString().Contains("Range"))
//{
// MaxValueDiffer *= 0.2;//如果是距离，则阈值相应的乘以一个波长
//}
this.SatObsDataType = obsType;
WindowSize = 4;
log.Info("采用了高次差方法探测周跳。");
}
/// <summary>
/// 默认构造函数
/// </summary>
/// <param name="SatObsDataType"></param>
/// <param name="maxBreakCount"></param>
public BufferedCycleSlipDetector(SatObsDataType SatObsDataType, double maxBreakCount = 4)
{
this.SatObsDataType = SatObsDataType;
this.MaxBreakCount = maxBreakCount;
this.Interval = 30;
this.MaxErrorTimes = 3;
this.PolyFitOrder = 2;
this.MinWindowSize = 5;
this.DifferTime = 1;
this.IgnoreCsed = true;
this.Name = "缓存事后周跳探测";
DataManager = new WindowData <EpochInformation>(10);
this.IsFirstWindow = true;
}
/// <summary>
/// 双差平差残差
/// </summary>
/// <param name="dataType">观测类型</param>
/// <param name="approxType">近似类型</param>
/// <param name="basePrn">基准卫星</param>
/// <returns></returns>
public Vector GetDoubleDifferResidualVector(SatObsDataType dataType, SatApproxDataType approxType, SatelliteNumber basePrn)
{
var obsCount = this.EpochCount * (this.EnabledSatCount - 1);
Vector vector = new Vector(obsCount);
int i = 0;
foreach (var item in this)
{
Vector epochDiffer = item.GetTwoSiteDoubleDifferResidualVector(dataType, approxType, this.EnabledPrns, basePrn);
vector.SetSubVector(epochDiffer, i * epochDiffer.Count);
i++;
}
return(vector);
}
/// <summary>
/// 周跳探测,并进行标记，而不修复。 默认构造函数。
/// </summary>
/// <param name="obsType"></param>
/// <param name="maxMaxRmsTimesOfLsPolyCs"></param>
/// <param name="order"></param>
/// <param name="differTimes"></param>
/// <param name="maxBreakingEpochCount"></param>
/// <param name="isUsingRecoredCsInfo"></param>
public LsPolyFitDetector(SatObsDataType obsType,
double maxMaxRmsTimesOfLsPolyCs,
int order,
int differTimes,
double maxBreakingEpochCount,
bool isUsingRecoredCsInfo)
: base(maxBreakingEpochCount, isUsingRecoredCsInfo)
{
Name = "多项式拟合周跳探测法";
this.SatObsDataType = obsType;
this.MaxRmsTimes = maxMaxRmsTimesOfLsPolyCs;
this.WindowSize = 5;
this.Order = order;
this.DifferTimes = differTimes;
}
/// <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="ObsDataType"></param>
/// <returns></returns>
public static FrequenceType GetFrequenceTypeFromObsDataType(SatObsDataType ObsDataType)
{
if (ObsDataType.ToString().EndsWith("A"))
{
return(FrequenceType.A);
}
else if (ObsDataType.ToString().EndsWith("B"))
{
return(FrequenceType.B);
}
else if (ObsDataType.ToString().EndsWith("C"))
{
return(FrequenceType.C);
}
return(FrequenceType.A);
}
/// <summary>
/// 构建数据表格。
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private ObjectTableStorage BuildObjectTable(SatObsDataType type)
{
var EpochInfoBuilder = new RinexEpochInfoBuilder(ObsFile.Header.SatelliteTypes);
ObjectTableStorage table = new ObjectTableStorage();
foreach (var obs in ObsFile)
{
var epochInfo = EpochInfoBuilder.Build(obs);
table.NewRow();
table.AddItem("Epoch", epochInfo.ReceiverTime.ToShortTimeString());
foreach (var sat in epochInfo)
{
table.AddItem(sat.Prn + "", sat[type].Value + "");
}
}
table.EndRow();
return(table);
}
/// <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));
}
/// <summary>
/// 构造函数，采用GNSS计算配置构造。
/// </summary>
/// <param name="Option"></param>
public ReverseCycleSlipeReviser(SatObsDataType obsType, List <CycleSlipDetectorType> types, GnssProcessOption Option)
{
Detector = CycleSlipDetectReviser.CreateCycleSlipReviser(obsType, types, Option, true);
this.MinNum = 10;
}
/// <summary>
/// 周跳探测器建立
/// </summary>
/// <param name="obsType"></param>
/// <param name="type"></param>
/// <param name="Option"></param>
/// <param name="isRevered"></param>
/// <returns></returns>
public static ICycleSlipDetector Create(SatObsDataType obsType, CycleSlipDetectorType type, GnssProcessOption Option, bool isRevered = false)
{
bool isUseRecorded = !isRevered && Option.IsUsingRecordedCycleSlipInfo;
switch (type)
{
case CycleSlipDetectorType.高次差法:
return(new HighDifferSlipDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecorded
});
break;
case CycleSlipDetectorType.LI组合:
return(new LiCycleSlipDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecorded
});
break;
case CycleSlipDetectorType.多项式拟合法:
return(new LsPolyFitDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecorded
});
break;
case CycleSlipDetectorType.数值平均法:
return(new AverageDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecorded
});
break;
case CycleSlipDetectorType.灰色模型法:
return(new GreyPolyFitDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecorded
});
break;
case CycleSlipDetectorType.MW组合:
return(new MwCycleSlipDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecorded
});
break;
case CycleSlipDetectorType.首次出现标记法:
return(new TimeValueCycleSlipDetector(Option)
{
IsUsingRecordedCsInfo = isUseRecorded
});
break;
default:
throw new NotSupportedException("尚未实现！" + type);
}
}
/// <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;
}
/// <summary>
/// 构造文件名称
/// </summary>
/// <returns></returns>
public string BuildFileName(string ObsFileName, CycleSlipDetectorType DetectType, SatObsDataType SatObsDataType)
{
var timeMark = DateTime.Now.Ticks.ToString();
StringBuilder sb = new StringBuilder();
sb.Append(ObsFileName);
//sb.Append("_");
//sb.Append(timeMark.Substring(timeMark.Length / 2));//避免相同文件文件的时间冲突。
sb.Append("_");
sb.Append(DetectType.ToString());
sb.Append("_");
sb.Append(SatObsDataType.ToString());
sb.Append(".CycleSlip");
return(sb.ToString());
}
/// <summary>
/// 构造函数。此方法可以反复调用，无时间积累效应。
/// </summary>
/// <param name="maxBreakingEpochCount">最大允许断裂历元数量</param>
/// <param name="IsUsingRecordedCycleSlipInfo">是否采用已有的周跳信息</param>
public BaseValueCycleSlipDetector(SatObsDataType dataType, double maxBreakingEpochCount, bool IsUsingRecordedCycleSlipInfo)
: base(maxBreakingEpochCount, IsUsingRecordedCycleSlipInfo)
{
this.SatObsDataType = dataType;
}
