private static void ParseSingleFile()
        {
            var path  = Path.Combine(@"f:\GIT\Geodesy\Rinex3Parser\TestFiles\", "cibg0880.16o");
            var path2 = Path.Combine(Environment.CurrentDirectory, "rnxheader.txt");

            sw1 = new StreamWriter("123.321");
            var z    = new Dictionary <SatelliteSystem, int[]>();
            var vals = Enum.GetValues(typeof(BdsSatellite));

            z.Add(SatelliteSystem.Bds, vals.Cast <int>().ToArray());
            var filter = new NavigationFilter(new DateTime(2016, 04, 29, 08, 0, 0), new DateTime(2016, 04, 29, 9, 0, 0),
                                              z);

            //var rinexObsParser = new RinexObsParser(path, ParseType.StoreAndRaise);
            var rinexObsParser = new RinexObsWithFilter(path, ParseType.StoreAndRaise,
                                                        new ObservationFilter(null, null,
                                                                              SatelliteSystem.Qzss | SatelliteSystem.Glo | SatelliteSystem.Gps | SatelliteSystem.Bds |
                                                                              SatelliteSystem.Sbas, null));

            rinexObsParser.ObsDataEvents   += ObsParserObsDataEvents;
            rinexObsParser.HeaderInfoEvent += ObsParserHeaderInfoEvent;
            rinexObsParser.Parse();
            sw1.Flush();
            sw1.Dispose();
        }
        public void Check_Glo_Excluded_On_Pure_Glo_File()
        {
            var obsFilter = new ObservationFilter(null, null, SatelliteSystem.Glo, null);

            var parser = new RinexObsWithFilter("pure_glo.16o", ParseType.StoreData, obsFilter);

            parser.Parse();

            Assert.IsTrue(parser.RinexType == RinexType.Obs);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.SatelliteSystem == SatelliteSystem.Glo);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.GnssTimeSystem == GnssTimeSystem.Glo);

            var headerMetadata = parser.ObsHeader.ObsHeaderData;

            Assert.IsTrue(headerMetadata.ObsMetaData.ContainsKey(SatelliteSystem.Glo));

            var observedGpsSatellites = parser.GetObservedSatellites();

            Assert.IsTrue(observedGpsSatellites.ContainsKey(SatelliteSystem.Glo),
                          "!observedGpsSatellites.ContainsKey(SatelliteSystem.Glo)");
            Assert.IsTrue(!observedGpsSatellites[SatelliteSystem.Glo].Any(),
                          "!observedGpsSatellites[SatelliteSystem.Glo].Any()");

            var observedGpsSatellites2 = parser.GetSatellitesObservations <GloSatellite>();

            Assert.IsTrue(observedGpsSatellites2.Count == 0, "observedGpsSatellites2.Count == 0");
        }
        public void Check_Invalid_Filter_No_Exception()
        {
            var start = new DateTime(2016, 3, 28, 0, 32, 0);
            var end   = new DateTime(2016, 3, 28, 0, 35, 30);


            var obsFilter = new ObservationFilter(start, end, SatelliteSystem.Qzss | SatelliteSystem.Sbas,
                                                  new Dictionary <SatelliteSystem, int[]>
            {
                { SatelliteSystem.Gal, new[] { (int)GpsSatellite.G05, (int)GpsSatellite.G15 } },
            });

            var parser = new RinexObsWithFilter("valid_mixed.16o", ParseType.StoreData, obsFilter);

            parser.Parse();

            Assert.IsTrue(parser.RinexType == RinexType.Obs);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.SatelliteSystem == SatelliteSystem.Mixed);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.GnssTimeSystem == GnssTimeSystem.Gps);

            Assert.IsTrue(parser.ObservationRecords.Count == 8, "Temporal test");

            var observedGpsSatellites = parser.GetObservedSatellites();

            Assert.IsTrue(
                !observedGpsSatellites[SatelliteSystem.Sbas].Any() && !observedGpsSatellites[SatelliteSystem.Qzss].Any(),
                "!observedGpsSatellites[SatelliteSystem.Sbas].Any() && !observedGpsSatellites[SatelliteSystem.Qzss].Any()");

            Assert.IsTrue(observedGpsSatellites.ContainsKey(SatelliteSystem.Gal),
                          "!observedGpsSatellites.ContainsKey(SatelliteSystem.Glo)");
            CollectionAssert.IsSubsetOf(new[] { (int)GalSatellite.E12 },
                                        observedGpsSatellites[SatelliteSystem.Gal].ToArray(), "gal IsNotSubsetOf");
        }
        public void Check_Temporal_Filter()
        {
            var start = new DateTime(2016, 3, 28, 0, 32, 0);
            var end   = new DateTime(2016, 3, 28, 0, 35, 30);

            var obsFilter = new ObservationFilter(start, end, null, null);
            var parser    = new RinexObsWithFilter("valid_mixed.16o", ParseType.StoreData, obsFilter);

            parser.Parse();

            Assert.IsTrue(parser.RinexType == RinexType.Obs);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.SatelliteSystem == SatelliteSystem.Mixed);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.GnssTimeSystem == GnssTimeSystem.Gps);

            Assert.IsTrue(parser.ObservationRecords.Count == 8);

            var firstObs  = parser.ObservationRecords.First();
            var appxStart = firstObs.Key.ApproximateDateTime;

            Assert.AreEqual(start, appxStart);

            var lastObs = parser.ObservationRecords.Last();
            var appxEnd = lastObs.Key.ApproximateDateTime;

            Assert.AreEqual(end, appxEnd);
        }
        public void Check_Excluded_Glo_R01_R11_On_Pure_Glo_File()
        {
            var obsFilter = new ObservationFilter(null, null, null, new Dictionary <SatelliteSystem, int[]>
            {
                { SatelliteSystem.Glo, new[] { (int)GloSatellite.R01, (int)GloSatellite.R11 } }
            });

            var parser = new RinexObsWithFilter("pure_glo.16o", ParseType.StoreData, obsFilter);

            parser.Parse();

            Assert.IsTrue(parser.RinexType == RinexType.Obs);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.SatelliteSystem == SatelliteSystem.Glo);
            Assert.IsTrue(parser.ObsHeader.ObsHeaderData.GnssTimeSystem == GnssTimeSystem.Glo);

            Assert.IsTrue(parser.ObservationRecords.Count == 19, "parser.ObservationRecords.Count == 19");

            var headerMetadata = parser.ObsHeader.ObsHeaderData;

            Assert.IsTrue(headerMetadata.ObsMetaData.ContainsKey(SatelliteSystem.Glo));

            var observedGpsSatellites = parser.GetObservedSatellites();

            Assert.IsTrue(observedGpsSatellites.ContainsKey(SatelliteSystem.Glo),
                          "!observedGpsSatellites.ContainsKey(SatelliteSystem.Glo)");
            CollectionAssert.IsNotSubsetOf(new[] { (int)GloSatellite.R01, (int)GloSatellite.R11 },
                                           observedGpsSatellites[SatelliteSystem.Glo].ToArray(), "glo IsNotSubsetOf");
        }