/// <summary>
        /// 输出sp3文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_export_Click(object sender, EventArgs e)
        {
            bool fillWithZero = checkBox1.Checked;
            var  directory    = this.directorySelectionControl1.Path;

            Geo.Utils.FileUtil.CheckOrCreateDirectory(directory);

            string[] pathes = this.textBox_Pathes.Lines;

            foreach (var sp3item in pathes)
            {
                Sp3Reader r = new Sp3Reader(sp3item);
                sp3 = r.ReadAll();
                string PredictedClockBiasPath = this.textBox_predictedresultPath.ToString();

                ClockBias = new Dictionary <Time, Clockbias>();

                GetPredictedClockBias(PredictedClockBiasPath);
                sp3ofPredicted        = new Sp3File();
                sp3ofPredicted.Header = sp3.Header;

                foreach (Sp3Section sec in sp3)
                {
                    Sp3Section s       = new Sp3Section();
                    Clockbias  section = ClockBias[sec.Time];
                    foreach (Ephemeris rec in sec)
                    {
                        s.Time = rec.Time;
                        if (section.sat.ContainsKey(rec.Prn) && section.sat[rec.Prn] != null)
                        {
                            rec.ClockBias = section.sat[rec.Prn];
                        }
                        else
                        {
                            rec.ClockBias = 999999.999999;
                        }

                        s.Add(rec.Prn, rec);
                    }
                    sp3ofPredicted.Add(s);
                }
                sp3ofPredicted.Header.Comments.Add("Processd by Gnsser");
                sp3ofPredicted.Header.Comments.Add("Predicted clock bias replace original precise data");
                var       path      = Path.Combine(directory, "P" + r.Name + ".sp3");
                Sp3Writer Sp3Writer = new Sp3Writer(path, sp3ofPredicted);
                sp3.Clear();
            }
            Geo.Utils.FileUtil.OpenDirectory(directory);
        }
Esempio n. 2
0
        /// <summary>
        /// 实时星历改正。
        /// </summary>
        /// <param name="obs"></param>
        /// <param name="maxCorrectionSecond">允许的最大改正秒数,是否该每颗卫星单独考虑</param>
        protected void RTSp3InfoCorrected(RinexEpochObservation obs, double maxCorrectionSecond = 60)//Time time, SatelliteType satType)
        {
            Time time = obs.ReceiverTime;

            if (SSRSp3Section.Count == 0)
            {
                return;
            }

            if (time - SSRSp3Section.GetMaxTime() > maxCorrectionSecond)
            {
                return;
            }

            Sp3Section Sp3Section = new Sp3Section();
            var        keys       = SSRSp3Section.Keys;

            foreach (var key in keys)
            {
                var obj = SSRSp3Section[key];
                foreach (var item in obj)
                {
                    if (!NavFile.Prns.Contains(item.Prn))
                    {
                        continue;
                    }
                    var ss     = new SingleParamNavFileEphService(NavFile);
                    var unkown = NavFile.GetEphemerisParams(item.Prn).Find(b => Math.Abs(b.Time.TickTime.TotalSeconds - time.TickTime.TotalSeconds) < 3 * 3600);
                    if (unkown == null)
                    {
                        continue;
                    }
                    if (ss == null)
                    {
                        continue;
                    }
                    Ephemeris ss1 = ss.Get(item.Prn, time);
                    XYZ       eA  = ss1.XyzDot / ss1.XyzDot.Length;
                    XYZ       eC  = ss1.XYZ.Cross(ss1.XyzDot) / (ss1.XYZ.Cross(ss1.XyzDot)).Length;
                    XYZ       eR  = eA.Cross(eC) / (eA.Cross(eC)).Length;

                    XYZ    deltaO = item.XYZ + item.XyzDot * (time.TickTime.TotalSeconds - item.Time.TickTime.TotalSeconds);
                    double x      = eR.X * deltaO.X + eA.X * deltaO.Y + eC.X * deltaO.Z;
                    double y      = eR.Y * deltaO.X + eA.Y * deltaO.Y + eC.Y * deltaO.Z;
                    double z      = eR.Z * deltaO.X + eA.Z * deltaO.Y + eC.Z * deltaO.Z;
                    if (x * x + y * y + z * z > 100)
                    {
                    }

                    Ephemeris Sp3Record = new Ephemeris();
                    Sp3Record.Prn  = item.Prn;
                    Sp3Record.XYZ  = ss1.XYZ - new XYZ(x, y, z);
                    Sp3Record.Time = time;

                    if (item.Prn.SatelliteType == SatelliteType.R)
                    {
                        Sp3Record.ClockBias = ss1.ClockBias + item.ClockBias;
                    }
                    else
                    {
                        double relativetime = 2 * ss1.XYZ.Dot(ss1.XyzDot) / (GnssConst.LIGHT_SPEED * GnssConst.LIGHT_SPEED);
                        Sp3Record.ClockBias = ss1.ClockBias - ss1.RelativeCorrection - item.ClockBias; //relativetime + key.ClockBias;
                    }
                    Sp3Section.Add(Sp3Record.Prn, Sp3Record);
                }
            }

            if (Sp3Section.Count != 0)
            {
                Sp3Section.Time = time;
                Sp3File.Add(Sp3Section);
            }
            else
            {
                int a = 0;
            }

            if (Sp3File.Count > 11)
            {
                // Sp3File.Header = new Sp3Header();
                Sp3File.Header.EpochInterval = 1;
                //Sp3File.TimePeriod = new BufferedTimePeriod(Sp3File.First.Time, Sp3File.Last.Time, 60);
                if (EphemerisService == null)
                {
                    EphemerisService = new SingleSp3FileEphService(this.Sp3File.GetSatEphemerisCollection(), 10);
                }
                else
                {
                    ((SingleSp3FileEphService)EphemerisService).SetSp3File(Sp3File.GetSatEphemerisCollection());
                }
            }
            if (Sp3File.Count > 20)
            {
                Sp3File.RemoveFirst();
            }
        }
        private void button_export_Click(object sender, EventArgs e)
        {
            bool fillWithZero    = checkBox1.Checked;
            int  intervalSec     = (int)(double.Parse(textBox_interval.Text) * 60);
            var  ModelLength     = (int)(24 * double.Parse(textBox_ModelLength.Text)) * 3600 / intervalSec;
            var  PredictedLength = (int)(24 * double.Parse(textBox_PredictedLength.Text)) * 3600 / intervalSec;
            var  directory       = this.directorySelectionControl1.Path;

            Geo.Utils.FileUtil.CheckOrCreateDirectory(directory);

            var PredictedNumber = int.Parse(textBox_PredictedNumber.Text);

            string[] pathes = this.textBox_Pathes.Lines;
            EphemerisDataSourceFactory fac = new EphemerisDataSourceFactory();

            coll = new SequentialFileEphemerisService(fac, pathes);
            int  allSec = (int)coll.TimePeriod.Span;
            Time end    = coll.TimePeriod.End + intervalSec;

            List <SatelliteNumber> prns = new List <SatelliteNumber> ();

            if (this.IsSelectedPrn.Checked)
            {
                prns = SatelliteNumber.ParsePRNsBySplliter(textBox_satPrns.Text, new char[] { ',' });
            }
            else
            {
                prns = coll.Prns;
            }

            List <double>            list      = new List <double>();
            Dictionary <string, SSE> ListOfSSE = new Dictionary <string, SSE>();
            string approach = null;

            #region 逐个卫星进行钟差预报
            for (int number = 0; number < PredictedNumber; number++)
            {
                sp3ofPredicted = new Sp3File();
                foreach (var prn in prns)
                {
                    int         GlideEpochNumber = int.Parse(this.textBox1_GlideEpochNumber.Text);//滑动历元历元数
                    ArrayMatrix OringalClock     = new ArrayMatrix(ModelLength, 1);
                    ArrayMatrix CompareClock     = new ArrayMatrix(PredictedLength, 1);

                    #region 获取建模,比较数据等
                    Time StartOfModel       = coll.TimePeriod.Start + number * GlideEpochNumber * intervalSec;
                    Time EndOfModel         = StartOfModel + (ModelLength - 1) * intervalSec;
                    Time StartOfPredicted   = EndOfModel + intervalSec;
                    Time EndOfPredicted     = StartOfPredicted + (PredictedLength - 1) * intervalSec;
                    var  OriginalClockData  = coll.Gets(prn, StartOfModel, EndOfModel);
                    var  PredictedClockData = coll.Gets(prn, StartOfPredicted, EndOfPredicted);

                    int  ModelDataNumberIndex     = 0;
                    int  PredictedDataNumberIndex = 0;
                    bool IsNeedFilling            = false;
                    for (Time i = StartOfModel; i <= EndOfModel; i = i + intervalSec)
                    {
                        var findofmodel = OriginalClockData.SingleOrDefault(m => m.Time == i);
                        if (findofmodel == null)
                        {
                            if (!fillWithZero)
                            {
                                continue;
                            }
                            IsNeedFilling = true;
                            findofmodel   = new Ephemeris()
                            {
                                Time = i, Prn = prn
                            };
                        }
                        OringalClock[ModelDataNumberIndex, 0] = findofmodel.ClockBias;
                        ModelDataNumberIndex++;
                    }
                    if (IsNeedFilling)
                    {
                        QuadraticPolynomialModel Filling = new QuadraticPolynomialModel();
                        Filling.FillingCalculate(OringalClock, intervalSec);
                    }
                    for (Time i = StartOfPredicted; i <= EndOfPredicted; i = i + intervalSec)
                    {
                        var findofpredicted = PredictedClockData.SingleOrDefault(m => m.Time == i);
                        if (findofpredicted == null)
                        {
                            if (!fillWithZero)
                            {
                                continue;
                            }

                            findofpredicted = new Ephemeris()
                            {
                                Time = i, Prn = prn
                            };
                        }
                        CompareClock[PredictedDataNumberIndex, 0] = findofpredicted.ClockBias;
                        PredictedDataNumberIndex++;
                    }
                    #endregion
                    ArrayMatrix Data = null;
                    if (radioButton_QP.Checked)
                    {
                        approach = "QP"; QuadraticPolynomialModel QuadraticPolynomialModel = new QuadraticPolynomialModel(); QuadraticPolynomialModel.Calculate(OringalClock, CompareClock, intervalSec); Data = QuadraticPolynomialModel.PredictedData;
                    }
                    if (radioButton_QPT1.Checked)
                    {
                        approach = "QPT1"; QuadraticPolynomialT1 QuadraticPolynomialT1 = new QuadraticPolynomialT1(); QuadraticPolynomialT1.Calculate(OringalClock, CompareClock, intervalSec); list.Add(QuadraticPolynomialT1.PredictedRms); Data = QuadraticPolynomialT1.PredictedData;
                    }
                    if (radioButton_QPT2.Checked)
                    {
                        approach = "QPT2"; QuadraticPolynomialT2 QuadraticPolynomialT2 = new QuadraticPolynomialT2(); QuadraticPolynomialT2.Calculate(OringalClock, CompareClock, intervalSec, prn); list.Add(QuadraticPolynomialT2.PredictedRms); Data = QuadraticPolynomialT2.PredictedData;
                    }
                    if (radioButton_QPT3.Checked)
                    {
                        approach = "QPT3"; QuadraticPolynomialT3 QuadraticPolynomialT3 = new QuadraticPolynomialT3(); QuadraticPolynomialT3.Calculate(OringalClock, CompareClock, intervalSec); list.Add(QuadraticPolynomialT3.PredictedRms); Data = QuadraticPolynomialT3.PredictedData;
                    }
                    if (radioButton_QPT4.Checked)
                    {
                        approach = "QPT4"; QuadraticPolynomialT4 QuadraticPolynomialT4 = new QuadraticPolynomialT4(); QuadraticPolynomialT4.Calculate(OringalClock, CompareClock, intervalSec); list.Add(QuadraticPolynomialT4.PredictedRms); Data = QuadraticPolynomialT4.PredictedData;
                    }
                    if (radioButton_QPGM.Checked)
                    {
                        approach = "QPGM"; QuadraticPolynomialGM QuadraticPolynomialGM = new QuadraticPolynomialGM(); QuadraticPolynomialGM.Calculate(OringalClock, CompareClock, intervalSec); list.Add(QuadraticPolynomialGM.PredictedRms); Data = QuadraticPolynomialGM.PredictedData;
                    }
                    if (radioButton_QPT2GM.Checked)
                    {
                        approach = "QPT2GM"; QuadraticPolynomialT2GM QuadraticPolynomialT2GM = new QuadraticPolynomialT2GM(); QuadraticPolynomialT2GM.Calculate(OringalClock, CompareClock, intervalSec, prn); list.Add(QuadraticPolynomialT2GM.PredictedRms); Data = QuadraticPolynomialT2GM.PredictedData;
                    }
                    if (radioButton_QPT4GM.Checked)
                    {
                        approach = "QPT4GM"; QuadraticPolynomialT4GM QuadraticPolynomialT4GM = new QuadraticPolynomialT4GM(); QuadraticPolynomialT4GM.Calculate(OringalClock, CompareClock, intervalSec); list.Add(QuadraticPolynomialT4GM.PredictedRms); Data = QuadraticPolynomialT4GM.PredictedData;
                    }

                    if (radioButton_LP.Checked)
                    {
                        approach = "LP"; LinearPolynomialModel LinearPolynomialModel = new LinearPolynomialModel(); LinearPolynomialModel.Calculate(OringalClock, CompareClock, intervalSec); list.Add(LinearPolynomialModel.PredictedRms); Data = LinearPolynomialModel.PredictedData;
                    }
                    if (radioButton_DLP.Checked)
                    {
                        approach = "DLP"; DLinearPolynomialModel DLinearPolynomialModel = new DLinearPolynomialModel(); DLinearPolynomialModel.Calculate(OringalClock, CompareClock, intervalSec); list.Add(DLinearPolynomialModel.PredictedRms); Data = DLinearPolynomialModel.PredictedData;
                    }
                    if (radioButton_RobustDLP.Checked)
                    {
                        approach = "RobustDLP";
                        RobustDLinearPolynomial RobustDLinearPolynomial = new RobustDLinearPolynomial();
                        RobustDLinearPolynomial.Calculate(OringalClock, CompareClock, intervalSec);
                        list.Add(RobustDLinearPolynomial.PredictedRms);
                        Data = RobustDLinearPolynomial.PredictedData;
                        SSE a = new SSE();
                        a = GetSSE(RobustDLinearPolynomial);
                        ListOfSSE.Add(prn.ToString() + '-' + number, a);
                    }
                    if (radioButton_RobustLP.Checked)
                    {
                        approach = "RobustLP"; RobustLinearPolynomial RobustLinearPolynomial = new RobustLinearPolynomial(); RobustLinearPolynomial.Calculate(OringalClock, CompareClock, intervalSec); list.Add(RobustLinearPolynomial.PredictedRms); Data = RobustLinearPolynomial.PredictedData;
                    }

                    if (radioButton_GM.Checked)
                    {
                        approach = "GM";
                        ArrayMatrix GMOringalClock1 = new ArrayMatrix(8, 1);
                        for (int GMIndex = 0; GMIndex < 8; GMIndex++)
                        {
                            GMOringalClock1[GMIndex, 0] = OringalClock[ModelLength - (8 - GMIndex), 0];
                        }
                        GreyModel GreyModel1 = new GreyModel();
                        SSE       a          = new SSE();
                        GreyModel1.Calculate(GMOringalClock1, CompareClock, intervalSec);
                        a = GetSSE(GreyModel1);
                        ListOfSSE.Add(prn.ToString() + '-' + number, a);
                        Data = GreyModel1.PredictedData;
                    }
                    if (radioButton_KFAllan.Checked)
                    {
                        approach = "KFAllan"; KalmanAllan KalmanAllan = new KalmanAllan(); KalmanAllan.Calculate(OringalClock, CompareClock, intervalSec); list.Add(KalmanAllan.PredictedRms); Data = KalmanAllan.PredictedData;
                    }
                    if (radioButton_KFHardamard.Checked)
                    {
                        approach = "KFHardamard"; KalmanHardamard KalmanHardamard = new KalmanHardamard(); KalmanHardamard.Calculate(OringalClock, CompareClock, intervalSec); list.Add(KalmanHardamard.PredictedRms); Data = KalmanHardamard.PredictedData;
                    }
                    if (radioButton_KFReHardamard.Checked)
                    {
                        approach = "KFReHardamard"; KalmanRecursionHardamard KalmanRecursionHardamard = new KalmanRecursionHardamard(); KalmanRecursionHardamard.Calculate(OringalClock, CompareClock, intervalSec); list.Add(KalmanRecursionHardamard.PredictedRms); Data = KalmanRecursionHardamard.PredictedData;
                    }
                    if (radioButton_KFReAllan.Checked)
                    {
                        approach = "KFReAllan"; KalmanRecursionAllan KalmanRecursionAllan = new KalmanRecursionAllan(); KalmanRecursionAllan.Calculate(OringalClock, CompareClock, intervalSec); list.Add(KalmanRecursionAllan.PredictedRms); Data = KalmanRecursionAllan.PredictedData;
                    }
                    for (int i0 = 0; i0 < Data.RowCount; i0++)
                    {
                        var sat = new Ephemeris();
                        sat.Prn       = prn;
                        sat.Time      = StartOfPredicted + i0 * intervalSec;
                        sat.ClockBias = Data[i0, 0];
                        if (!(sp3ofPredicted.Contains(sat.Time)))
                        {
                            sp3ofPredicted.Add(sat.Time, new Sp3Section());
                        }
                        sp3ofPredicted[sat.Time].Add(sat.Prn, sat);
                    }
                    sp3ofPredicted.Prns.Add(prn);
                }
                OutputOfPredictedClock(directory, approach, number);
            }
            #endregion
            OutputOfSSE(directory, ListOfSSE, approach);

            Geo.Utils.FileUtil.OpenDirectory(directory);
        }
Esempio n. 4
0
        private void button_read_Click(object sender, EventArgs e)
        {
            bool fillWithZero = checkBox1.Checked;
            var  directory    = this.directorySelectionControl1.Path;

            Geo.Utils.FileUtil.CheckOrCreateDirectory(directory);

            string[] pathes     = this.textBox_Pathes.Lines;
            int      dayOfweekO = 0;

            //sp3Observation = new Sp3File();
            TableTextManager = new ObjectTableManager();


            TableTextManager.OutputDirectory = directory;

            var SatEpochCountTable = TableTextManager.GetOrCreate("GNSSerSatEpochCount" + Path.GetFileNameWithoutExtension(pathes[0]).Substring(0, 12));

            #region  照时间顺序合并
            Time start = Time.MinValue;
            foreach (var pathItem in pathes)
            {
                Sp3Reader r = new Sp3Reader(pathItem);
                sp3 = r.ReadAll();
                var intervalSec = sp3.Header.EpochInterval;

                foreach (Sp3Section sec in sp3)
                {
                    Sp3Section s = new Sp3Section();
                    foreach (var rec in sec)
                    {
                        if (rec.Prn.SatelliteType == SatelliteType.R)
                        {
                            rec.Time = rec.Time + 1;
                        }
                        s.Time = rec.Time; s.Add(rec.Prn, rec);
                    }
                    if (sp3Observation == null || sp3Observation.Count == 0)
                    {
                        sp3Observation                  = new Sp3File();
                        sp3Observation.Header           = sp3.Header;
                        sp3Observation.Header.StartTime = s.Time;
                        sp3Observation.Header.Comments.Add("Processd by Gnsser");
                        sp3Observation.Header.Comments.Add("Collected from real time SSR clock correction");
                        dayOfweekO = sp3Observation.Header.StartTime.GetGpsWeekAndDay();
                    }
                    if (((s.Time.Hour == 0 && s.Time.Minute == 0 && s.Time.Second == 0) || start.GetGpsWeekAndDay() != s.Time.GetGpsWeekAndDay()) && sp3Observation.Count != 0)
                    {
                        var pathObservation = Path.Combine(directory, "Gnsser" + sp3.Name.Substring(0, 12) + dayOfweekO.ToString() + ".sp3");
                        sp3Observation.Header.NumberOfEpochs = sp3Observation.Count;
                        Sp3Writer Sp3WriterObservation = new Sp3Writer(pathObservation, sp3Observation);
                        Sp3WriterObservation.SaveToFile();
                        SatEpochCountTable.NewRow();
                        SatEpochCountTable.AddItem("Day", dayOfweekO);
                        sp3Observation.CheckOrBuildIndexCollection();
                        foreach (var item in sp3Observation.SatEphemerisCollection.Keys)
                        {
                            int a = sp3Observation.SatEphemerisCollection[item].Count;

                            SatEpochCountTable.AddItem(item, a);
                        }
                        SatEpochCountTable.EndRow();

                        sp3Observation.Clear();
                        sp3Observation.SatEphemerisCollection.Clear();
                        sp3Observation.Header.StartTime = s.Time;
                        //sp3Observation.Header.Comments.Add("Processd by Gnsser");
                        //sp3Observation.Header.Comments.Add("Collected from real time SSR clock correction");
                        dayOfweekO = sp3Observation.Header.StartTime.GetGpsWeekAndDay();
                        start      = s.Time;
                    }
                    if (!sp3Observation.Contains(s.Time))
                    {
                        sp3Observation.Add(s);
                    }
                }
            }

            TableTextManager.WriteAllToFileAndCloseStream();

            if (sp3Observation.Count != 0)
            {
                var pathObservation = Path.Combine(directory, "Gnsser" + sp3.Name.Substring(0, 12) + dayOfweekO.ToString() + ".sp3");
                sp3Observation.Header.NumberOfEpochs = sp3Observation.Count;
                Sp3Writer Sp3WriterObservation = new Sp3Writer(pathObservation, sp3Observation);
                Sp3WriterObservation.SaveToFile();
                sp3Observation.Clear();
            }

            #endregion

            Geo.Utils.FileUtil.OpenDirectory(directory);
        }
Esempio n. 5
0
        private void calculate_Click(object sender, EventArgs e)
        {
            bool fillWithZero = checkBox1.Checked;
            var  intervalSec  = double.Parse(textBox_interval.Text) * 60;
            var  directory    = this.directorySelectionControl1.Path;

            Geo.Utils.FileUtil.CheckOrCreateDirectory(directory);
            string[] SSRsp3Pathes = this.textBox_SSRsp3Pathes.Lines;
            string[] NavPathes    = this.textBox_NavPathes.Lines;
            string[] ClockPathes  = this.textBox1.Lines;
            if (SSRsp3Pathes.Length != NavPathes.Length)
            {
                return;
            }
            int fileCount = SSRsp3Pathes.Length;

            if (!System.IO.Directory.Exists(@"D:\Temp\SSR1\"))
            {
                System.IO.Directory.CreateDirectory(@"D:\Temp\SSR1\");
            }
            EpochCountTableTextManager = new ObjectTableManager();


            EpochCountTableTextManager.OutputDirectory = "D:\\Temp\\SSR1\\";

            var SatEpochCountTable = EpochCountTableTextManager.GetOrCreate("BNCSatEpochCount");// + OriginalSSR.Header.Name);

            SatEpochCountTable.NewRow();

            for (int i = 0; i < fileCount; i++)
            {
                #region 读取SSR产品
                Time start0 = Time.MaxValue;
                Time end0   = Time.MinValue;
                OriginalSSRSp3 = new Sp3File();
                OriginalSSRSp3MinusPreciseClockOutput = new Sp3File();
                OriginalSSRSp3PlusNavOutput           = new Sp3File();
                Sp3Reader r = new Sp3Reader(SSRsp3Pathes[i]);
                OriginalSSRSp3 = r.ReadAll();
                OriginalSSRSp3.CheckOrBuildIndexCollection();

                Dictionary <string, int> SatEpochCount = new Dictionary <string, int>();
                foreach (var item in OriginalSSRSp3.Prns)
                {
                    SatEpochCount.Add(item.ToString(), OriginalSSRSp3.SatEphemerisCollection[item].Count);
                }
                SatEpochCountTable.AddItem("Day", start0.GetGpsWeekAndDay());
                foreach (var item in SatEpochCount)
                {
                    SatEpochCountTable.AddItem(item.Key, item.Value);
                }
                SatEpochCountTable.EndRow();

                #endregion

                #region 读取广播星历
                ParamNavFileReader NavReader = new ParamNavFileReader(NavPathes[i]);
                ephemeris = new SingleParamNavFileEphService(NavReader.ReadGnssNavFlie());
                #endregion
                #region 读取钟差文件

                //ClockFileReader reader = new ClockFileReader(ClockPathes[i]);
                //ClockFile = reader.ReadAll();
                //if (ClockFile.ClockCount == 0) return;
                #endregion
                OriginalSSRSp3.CheckOrBuildIndexCollection();
                for (Time time = OriginalSSRSp3.TimePeriod.Start; time <= OriginalSSRSp3.TimePeriod.End; time += 1)
                {
                    Sp3Section Sp3Section = new Sp3Section();
                    Sp3Section.Time = time;
                    foreach (var prn in OriginalSSRSp3.Prns)
                    {
                        var ss1 = OriginalSSRSp3.SatEphemerisCollection[prn].Values.FindLast(b => b.Time <= time);

                        if (!ephemeris.Prns.Contains(prn))
                        {
                            continue;
                        }
                        var ss = ephemeris.Get(prn, time);
                        XYZ eA = ss.XyzDot / ss.XyzDot.Length;
                        XYZ eC = ss.XYZ.Cross(ss.XyzDot) / (ss.XYZ.Cross(ss.XyzDot)).Length;
                        XYZ eR = eA.Cross(eC) / (eA.Cross(eC)).Length;

                        XYZ    deltaO = ss1.XYZ + ss1.XyzDot * (time.Seconds - ss1.Time.Seconds);
                        double x      = eA.X * deltaO.X + eA.X * deltaO.Y + eC.X * deltaO.Z;
                        double y      = eA.Y * deltaO.X + eA.Y * deltaO.Y + eC.Y * deltaO.Z;
                        double z      = eA.Z * deltaO.X + eA.Z * deltaO.Y + eC.Z * deltaO.Z;


                        Ephemeris Sp3Record = new Ephemeris();
                        Sp3Record.Prn = prn;
                        Sp3Record.XYZ = ss.XYZ - new XYZ(x, y, z);
                        if (prn.SatelliteType == SatelliteType.R)
                        {
                            Sp3Record.ClockBias = ss.ClockBias + ss1.ClockBias;
                        }
                        else
                        {
                            Sp3Record.ClockBias = ss.ClockBias - ss.RelativeCorrection + ss1.ClockBias;
                        }
                        Sp3Section.Add(prn, Sp3Record);
                    }
                    OriginalSSRSp3PlusNavOutput.Add(Sp3Section);
                }
                var resultPath = Path.Combine("D:\\Temp\\SSR1\\", OriginalSSRSp3.Name);

                Sp3Writer ClockFileWriter = new Sp3Writer(resultPath, OriginalSSRSp3PlusNavOutput);
                ClockFileWriter.SaveToFile();
            }


            //    List<AtomicClock> OriginalSSRDataSource = new List<AtomicClock>();
            //    List<AtomicClock> ClockFileDataSource = new List<AtomicClock>();

            //    foreach (var key in OriginalSSRSp3.Prns)
            //    {
            //        //OriginalSSRDataSource = OriginalSSR.GetClockItems(key);
            //        ClockFileDataSource = ClockFile.GetClockItems(key);
            //        if (ClockFileDataSource == null) continue;
            //        List<AtomicClock> ErrorResult = new List<AtomicClock>();
            //        List<AtomicClock> SSRPlusNavResult = new List<AtomicClock>();

            //        foreach (var item1 in ClockFileDataSource)
            //        {
            //            AtomicClock item2 = new AtomicClock();
            //            var clk =  OriginalSSRSp3.GetClockItem(item1.Prn.ToString(),item1.Time);
            //            if (item1.ClockBias == 9999999999.0 || clk == null)
            //            {
            //                item1.ClockBias = 9999999999.0;
            //                item2.Time = item1.Time;
            //                item2.Prn = item1.Prn;
            //                item2.Name = item1.Name;
            //                item2.ClockType = item1.ClockType;
            //                item2.ClockBias = 9999999999.0;
            //            }
            //            else
            //            {
            //                var NavItem = ephemeris.Get(item1.Prn, item1.Time);
            //                item2.Time = item1.Time;
            //                item2.Prn = item1.Prn;
            //                item2.Name = item1.Name;
            //                item2.ClockType = item1.ClockType;
            //                item2.ClockBias = NavItem.ClockBias - NavItem.RelativeTime + clk.ClockBias;
            //                item1.ClockBias = item2.ClockBias - item1.ClockBias;
            //            }
            //            SSRPlusNavResult.Add(item2);
            //            ErrorResult.Add(item1);

            //        }
            //        OriginalSSRSp3MinusPreciseClockOutput.Add(key, ErrorResult);
            //        OriginalSSRSp3PlusNavOutput.Add(key, SSRPlusNavResult);

            //    }

            //    double interval = double.Parse(this.textBox_interval.Text);
            //    ClockEstimationFrom = this.dateTimePicker_from.Value;
            //    ClockEstimationTo = this.dateTimePicker_to.Value;


            //    OriginalSSRSp3.Header = new Sp3Header ();
            //    OriginalSSRSp3.Header.AgencyName="Gnsser";
            //    OriginalSSRSp3.Header.EndTime=
            //    .Name = "SSR" + OriginalSSRSp3.Header.Name;
            //    OriginalSSRSp3.Header.CreationDate = DateTime.Now.ToString();
            //    OriginalSSRSp3.Header.CreationAgence = "Gnsser";
            //    OriginalSSRSp3.Header.ANALYSIS_CENTER = "Gnsser";
            //    OriginalSSRSp3.Header.CreationProgram = "Gnsser";
            //    OriginalSSRSp3MinusPreciseClockOutput.Header = OriginalSSRSp3.Header;
            //    OriginalSSRSp3PlusNavOutput.Header = OriginalSSRSp3.Header;

            //    var resutlPath = Path.Combine("D:\\Temp\\SSR1\\", OriginalSSRSp3.Header.Name);
            //    var errorResutlPath = Path.Combine("D:\\Temp\\SSR1\\", "error" + OriginalSSRSp3.Header.Name);

            //    ClockFileWriter ClockFileWriter = new ClockFileWriter(resutlPath, OriginalSSRSp3PlusNavOutput);
            //    ClockFileWriter.SaveToFile();
            //    ClockFileWriter errorClockFileWriter = new ClockFileWriter(errorResutlPath, OriginalSSRSp3MinusPreciseClockOutput);
            //    errorClockFileWriter.SaveToFile();
            //    TableTextManager = new TableObjectManager();


            //    TableTextManager.OutputDirectory = "D:\\Temp\\SSR1\\";

            //    var paramTable = TableTextManager.GetOrCreate(OriginalSSRSp3MinusPreciseClockOutput.Name + "errorSSRSat");
            //    int count = 0;
            //    SatelliteNumber prnIndex = new SatelliteNumber();
            //    foreach (var key in OriginalSSRSp3MinusPreciseClockOutput)
            //    {
            //        if (key.Count > count) { count = key.Count; prnIndex = key[0].Prn; }
            //    }

            //    var standard = OriginalSSRSp3MinusPreciseClockOutput.GetClockItems(prnIndex);
            //    double DoubleDiffer = 0;
            //    foreach (var key in standard)
            //    {
            //        paramTable.NewRow();
            //        paramTable.AddItem("Epoch", key.Time);
            //        foreach (var item1 in OriginalSSRSp3MinusPreciseClockOutput.Names)
            //        {
            //            if (item1 == key.Name.ToString()) continue;

            //            var ss = OriginalSSRSp3MinusPreciseClockOutput.GetClockItem(item1, key.Time);
            //            if (ss == null)
            //                continue;
            //            if (key.ClockBias == 9999999999.0 || ss.ClockBias == 9999999999.0)
            //                DoubleDiffer = 0;
            //            else DoubleDiffer = key.ClockBias - ss.ClockBias;
            //            paramTable.AddItem(ss.Prn + "-" + key.Prn, DoubleDiffer * 1E9);
            //        }
            //        paramTable.EndRow();
            //    }
            //    TableTextManager.WriteAllToFileAndCloseStream();
            //}
            //EpochCountTableTextManager.WriteAllToFileAndCloseStream();
            Geo.Utils.FileUtil.OpenDirectory("D:\\Temp\\SSR1\\");
        }
Esempio n. 6
0
        private void button_read_Click(object sender, EventArgs e)
        {
            bool   fillWithZero    = checkBox1.Checked;
            var    directory       = this.directorySelectionControl1.Path;
            string resultDirectory = Path.Combine(directory, "replace clock result");

            Geo.Utils.FileUtil.CheckOrCreateDirectory(resultDirectory);

            string[] pathes     = this.textBox_Pathes.Lines;
            string   igsSp3Path = this.textBox_IgsSp3Path.Text;
            var      st1        = int.Parse(pathes[0].Substring(pathes[0].Length - 6, 2));
            var      st2        = int.Parse(pathes[1].Substring(pathes[0].Length - 6, 2));

            #region  照单个文件进行输出,不合并

            foreach (var pathItem in pathes)
            {
                string dayOfWeek         = Path.GetFileNameWithoutExtension(pathItem).Substring(5, 5);
                string dayOfWeekfileName = Path.GetFileNameWithoutExtension(igsSp3Path).Substring(3, 5);
                string path = igsSp3Path.Replace(dayOfWeekfileName, dayOfWeek);
                if (!File.Exists(path))
                {
                    //FormUtil.ShowFileNotExistBox(path);
                    continue;
                }

                Sp3AllReader iguRead = new Sp3AllReader(pathItem);
                iguSp3 = iguRead.ReadAll();
                Sp3AllReader igsRead = new Sp3AllReader(path);
                igsSp3 = igsRead.ReadAll();

                var intervalSec = iguSp3.Header.EpochInterval;
                sp3Observation        = new Sp3File();
                sp3Observation.Header = igsSp3.Header;
                foreach (Sp3Section sec in igsSp3)
                {
                    var        item = iguSp3.Get(sec.Time);
                    Sp3Section s    = new Sp3Section();
                    foreach (var rec in sec)
                    {
                        s.Time = rec.Time;
                        if (item != null && item.Contains(rec.Prn))
                        {
                            rec.ClockBias = item[rec.Prn].ClockBias;
                        }
                        else
                        {
                            rec.ClockBias = 0.999999999999;
                        }
                        s.Add(rec.Prn, rec);
                    }
                    sp3Observation.Add(s);
                }

                sp3Observation.Header.Comments.Add("Processd by Gnsser");
                sp3Observation.Header.Comments.Add("Choose clock of IGU-P for igs");
                var pathObservation = Path.Combine(resultDirectory, iguSp3.Name);
                if (File.Exists(pathObservation))
                {
                    File.Delete(pathObservation);
                }
                Sp3Writer Sp3WriterObservation = new Sp3Writer(pathObservation, sp3Observation);
                Sp3WriterObservation.SaveToFile();
                iguSp3.Clear();
            }

            #endregion

            Geo.Utils.FileUtil.OpenDirectory(resultDirectory);
        }
Esempio n. 7
0
        private void button_read_Click(object sender, EventArgs e)
        {
            bool fillWithZero = checkBox1.Checked;
            var  directory    = this.directorySelectionControl1.Path;

            Geo.Utils.FileUtil.CheckOrCreateDirectory(directory);

            string[] pathes = this.textBox_Pathes.Lines;

            var st1 = int.Parse(pathes[0].Substring(pathes[0].Length - 6, 2));
            var st2 = int.Parse(pathes[1].Substring(pathes[0].Length - 6, 2));

            #region  照多个文件进行合并输出
            if (st2 - st1 != 0)
            {
                sp3ofPredicted = new Sp3File(); sp3Observation = new Sp3File(); int indexOfFile = 1; int dayOfweekO = 0; int dayOfweekP = 0;
                foreach (var pathItem in pathes)
                {
                    Sp3AllReader r  = new Sp3AllReader(pathItem);
                    Sp3AllReader rP = new Sp3AllReader(pathItem);
                    sp3  = r.ReadAll();
                    sp3P = rP.ReadAll();
                    var intervalSec = sp3.Header.EpochInterval;

                    Time end1             = sp3.TimePeriod.Start + (st2 - st1) * 3600 - intervalSec;
                    Time end              = sp3.TimePeriod.Start + (st2 - st1 + 24) * 3600 - intervalSec;
                    Time startOfPredicted = sp3.TimePeriod.Start + 24 * 3600 - intervalSec;
                    foreach (Sp3Section sec in sp3)
                    {
                        Sp3Section s = new Sp3Section();
                        foreach (var rec in sec)
                        {
                            s.Time = rec.Time;
                            s.Add(rec.Prn, rec);
                        }
                        if (sec.Time <= end1)
                        {
                            sp3Observation.Add(s);
                        }
                        else if (sec.Time <= end && sec.Time > startOfPredicted)
                        {
                            sp3ofPredicted.Add(s);
                        }
                    }
                    if (indexOfFile % (24 / (st2 - st1)) == 1)
                    {
                        sp3Observation.Header           = sp3.Header;
                        sp3ofPredicted.Header           = sp3P.Header;
                        sp3ofPredicted.Header.StartTime = sp3P.Header.StartTime + 24 * 3600;
                        dayOfweekO = sp3Observation.Header.StartTime.GetGpsWeekAndDay();
                        if (dayOfweekO % 10 == 6)
                        {
                            dayOfweekP = dayOfweekO + 4;
                            sp3ofPredicted.Header.GPSWeek += 1;
                        }
                        else
                        {
                            dayOfweekP = dayOfweekO + 1;
                        }
                    }
                    if (indexOfFile % (24 / (st2 - st1)) == 0)
                    {
                        sp3Observation.Header.Comments.Add("Processd by Gnsser");
                        sp3Observation.Header.Comments.Add("Choose IGU-O from igu");
                        sp3ofPredicted.Header.Comments.Add("Processd by Gnsser");
                        sp3ofPredicted.Header.Comments.Add("Choose IGU-P from igu");
                        var pathObservation = Path.Combine(directory, "IGU-O" + dayOfweekO.ToString() + ".sp3");
                        var pathPredicted   = Path.Combine(directory, "IGU-P" + dayOfweekP.ToString() + ".sp3");
                        sp3Observation.Header.NumberOfEpochs = sp3Observation.Count;
                        sp3ofPredicted.Header.NumberOfEpochs = sp3ofPredicted.Count;
                        Sp3Writer Sp3WriterObservation = new Sp3Writer(pathObservation, sp3Observation);
                        Sp3Writer Sp3WriterPredicted   = new Sp3Writer(pathPredicted, sp3ofPredicted);
                        Sp3WriterObservation.SaveToFile();
                        Sp3WriterPredicted.SaveToFile();
                        sp3Observation.Clear();
                        sp3ofPredicted.Clear();
                    }
                    sp3.Clear();
                    indexOfFile++;
                }
            }


            #endregion
            #region  照单个文件进行输出,不合并
            else
            {
                foreach (var pathItem in pathes)
                {
                    Sp3Reader r = new Sp3Reader(pathItem);
                    sp3 = r.ReadAll();
                    var intervalSec = sp3.Header.EpochInterval;
                    sp3Observation        = new Sp3File();
                    sp3Observation.Header = sp3.Header;
                    sp3ofPredicted        = new Sp3File();
                    sp3ofPredicted.Header = sp3.Header;
                    Time end1 = sp3.TimePeriod.Start + 24 * 3600 - intervalSec;
                    Time end  = sp3.TimePeriod.End;
                    foreach (Sp3Section sec in sp3)
                    {
                        Sp3Section s = new Sp3Section();

                        foreach (var rec in sec)
                        {
                            s.Time = rec.Time;
                            s.Add(rec.Prn, rec);
                        }
                        if (sec.Time < end1)
                        {
                            sp3Observation.Add(s);
                        }
                        else
                        {
                            sp3ofPredicted.Add(s);
                        }
                    }
                    sp3Observation.Header.Comments.Add("Processd by Gnsser");
                    sp3Observation.Header.Comments.Add("Choose IGU-O from igu");
                    sp3ofPredicted.Header.Comments.Add("Processd by Gnsser");
                    sp3ofPredicted.Header.Comments.Add("Choose IGU-P from igu");
                    var       pathObservation      = Path.Combine(directory, "IGU-O-Basedon" + r.Name);
                    var       pathPredicted        = Path.Combine(directory, "IGU-P-Basedon" + r.Name);
                    Sp3Writer Sp3WriterObservation = new Sp3Writer(pathObservation, sp3Observation);
                    Sp3Writer Sp3WriterPredicted   = new Sp3Writer(pathPredicted, sp3ofPredicted);
                    Sp3WriterObservation.SaveToFile();
                    Sp3WriterPredicted.SaveToFile();
                    sp3.Clear();
                }
            }
            #endregion

            Geo.Utils.FileUtil.OpenDirectory(directory);
        }