SVNumXRef.cpp
Go to the documentation of this file.
1 //==============================================================================
2 //
3 // This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
4 //
5 // The GNSSTk is free software; you can redistribute it and/or modify
6 // it under the terms of the GNU Lesser General Public License as published
7 // by the Free Software Foundation; either version 3.0 of the License, or
8 // any later version.
9 //
10 // The GNSSTk is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with GNSSTk; if not, write to the Free Software Foundation,
17 // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 //
19 // This software was developed by Applied Research Laboratories at the
20 // University of Texas at Austin.
21 // Copyright 2004-2022, The Board of Regents of The University of Texas System
22 //
23 //==============================================================================
24 
25 //==============================================================================
26 //
27 // This software was developed by Applied Research Laboratories at the
28 // University of Texas at Austin, under contract to an agency or agencies
29 // within the U.S. Department of Defense. The U.S. Government retains all
30 // rights to use, duplicate, distribute, disclose, or release this software.
31 //
32 // Pursuant to DoD Directive 523024
33 //
34 // DISTRIBUTION STATEMENT A: This software has been approved for public
35 // release, distribution is unlimited.
36 //
37 //==============================================================================
38 
39 /* SVNumXRefMap.cpp
40 *
41 * Applied Research Laboratories, The University of Texas at Austin
42 *
43 */
44 #include "SVNumXRef.hpp"
45 #include "CivilTime.hpp"
46 #include "TimeString.hpp"
47 
48 #include <iostream>
49 #include <stdio.h>
50 #include <sstream>
51 
52 using namespace std;
53 using namespace gnsstk;
54 
55 SVNumXRef::SVNumXRef( )
56 {
57  NtoBMap.insert( make_pair( 1, I ));
58  NtoBMap.insert( make_pair( 2, I ));
59  NtoBMap.insert( make_pair( 3, I ));
60  NtoBMap.insert( make_pair( 4, I ));
61  NtoBMap.insert( make_pair( 5, I ));
62  NtoBMap.insert( make_pair( 6, I ));
63  // no NAVSTAR 07, I-7 was a launch failure
64  NtoBMap.insert( make_pair( 8, I ));
65  NtoBMap.insert( make_pair( 9, I ));
66  NtoBMap.insert( make_pair( 10, I ));
67  NtoBMap.insert( make_pair( 11, I ));
68  // no NAVSTAR 12, was never launched
69  NtoBMap.insert( make_pair( 13, II ));
70  NtoBMap.insert( make_pair( 14, II ));
71  NtoBMap.insert( make_pair( 15, II ));
72  NtoBMap.insert( make_pair( 16, II ));
73  NtoBMap.insert( make_pair( 17, II ));
74  NtoBMap.insert( make_pair( 18, II ));
75  NtoBMap.insert( make_pair( 19, II ));
76  NtoBMap.insert( make_pair( 20, II ));
77  NtoBMap.insert( make_pair( 21, II ));
78  NtoBMap.insert( make_pair( 22,IIA ));
79  NtoBMap.insert( make_pair( 23,IIA ));
80  NtoBMap.insert( make_pair( 24,IIA ));
81  NtoBMap.insert( make_pair( 25,IIA ));
82  NtoBMap.insert( make_pair( 26,IIA ));
83  NtoBMap.insert( make_pair( 27,IIA ));
84  NtoBMap.insert( make_pair( 28,IIA ));
85  NtoBMap.insert( make_pair( 29,IIA ));
86  NtoBMap.insert( make_pair( 30,IIA ));
87  NtoBMap.insert( make_pair( 31,IIA ));
88  NtoBMap.insert( make_pair( 32,IIA ));
89  NtoBMap.insert( make_pair( 33,IIA ));
90  NtoBMap.insert( make_pair( 34,IIA ));
91  NtoBMap.insert( make_pair( 35,IIA ));
92  NtoBMap.insert( make_pair( 36,IIA ));
93  NtoBMap.insert( make_pair( 37,IIA ));
94  NtoBMap.insert( make_pair( 38,IIA ));
95  NtoBMap.insert( make_pair( 39,IIA ));
96  NtoBMap.insert( make_pair( 40,IIA ));
97  NtoBMap.insert( make_pair( 41,IIR ));
98  // no NAVSTAR 42, IIR-1 was a launch failure
99  NtoBMap.insert( make_pair( 43,IIR ));
100  NtoBMap.insert( make_pair( 44,IIR ));
101  NtoBMap.insert( make_pair( 45,IIR ));
102  NtoBMap.insert( make_pair( 46,IIR ));
103  NtoBMap.insert( make_pair( 47,IIR ));
104  NtoBMap.insert( make_pair( 48,IIR_M));
105  NtoBMap.insert( make_pair( 49,IIR_M));
106  NtoBMap.insert( make_pair( 50,IIR_M));
107  NtoBMap.insert( make_pair( 51,IIR ));
108  NtoBMap.insert( make_pair( 52,IIR_M));
109  NtoBMap.insert( make_pair( 53,IIR_M));
110  NtoBMap.insert( make_pair( 54,IIR ));
111  NtoBMap.insert( make_pair( 55,IIR_M));
112  NtoBMap.insert( make_pair( 56,IIR ));
113  NtoBMap.insert( make_pair( 57,IIR_M));
114  NtoBMap.insert( make_pair( 58,IIR_M));
115  NtoBMap.insert( make_pair( 59,IIR ));
116  NtoBMap.insert( make_pair( 60,IIR ));
117  NtoBMap.insert( make_pair( 61,IIR ));
118  NtoBMap.insert( make_pair( 62,IIF ));
119  NtoBMap.insert( make_pair( 63,IIF ));
120  NtoBMap.insert( make_pair( 64,IIF ));
121  NtoBMap.insert( make_pair( 65,IIF ));
122  NtoBMap.insert( make_pair( 66,IIF ));
123  NtoBMap.insert( make_pair( 67,IIF ));
124  NtoBMap.insert( make_pair( 68,IIF ));
125  NtoBMap.insert( make_pair( 69,IIF ));
126  NtoBMap.insert( make_pair( 70,IIF ));
127  NtoBMap.insert( make_pair( 71,IIF ));
128  NtoBMap.insert( make_pair( 72,IIF ));
129  NtoBMap.insert( make_pair( 73,IIF ));
130  NtoBMap.insert( make_pair( 74,III ));
131  NtoBMap.insert( make_pair( 75,III ));
132  NtoBMap.insert( make_pair( 76,III ));
133  NtoBMap.insert( make_pair( 77,III ));
134 
135  // Note: This table start with Block I values
136  // Set up NAVSTAR -> PRN ID relationship
137  // NAVSTAR ID first, PRN ID second
138  NtoPMap.insert( std::pair<const int, XRefNode>( 1, XRefNode( 4,
139  CivilTime( 1978, 2, 22, 0, 0, 0.0, TimeSystem::GPS),
140  CivilTime( 1985, 7, 17, 17, 30, 0.0, TimeSystem::GPS))));
141  NtoPMap.insert( std::pair<const int, XRefNode>( 2, XRefNode( 7,
142  CivilTime( 1978, 6, 13, 0, 0, 0.0, TimeSystem::GPS),
143  CivilTime( 1988, 2, 12, 23, 59, 59.9, TimeSystem::GPS))));
144  NtoPMap.insert( std::pair<const int, XRefNode>( 3, XRefNode( 6,
145  CivilTime( 1978, 10, 6, 0, 0, 0.0, TimeSystem::GPS),
146  CivilTime( 1992, 5, 18, 23, 41, 0.0, TimeSystem::GPS))));
147  NtoPMap.insert( std::pair<const int, XRefNode>( 4, XRefNode( 8,
148  CivilTime( 1978, 12, 10, 0, 0, 0.0, TimeSystem::GPS),
149  CivilTime( 1990, 5, 31, 23, 59, 59.9, TimeSystem::GPS))));
150  NtoPMap.insert( std::pair<const int, XRefNode>( 5, XRefNode( 5,
151  CivilTime( 1980, 2, 9, 0, 0, 0.0, TimeSystem::GPS),
152  CivilTime( 1984, 5, 11, 23, 59, 59.9, TimeSystem::GPS))));
153  NtoPMap.insert( std::pair<const int, XRefNode>( 6, XRefNode( 9,
154  CivilTime( 1980, 4, 26, 0, 0, 0.0, TimeSystem::GPS),
155  CivilTime( 1991, 3, 6, 3, 42, 0.0, TimeSystem::GPS))));
156  // no NAVSTAR 07, I-7 was a launch failure
157  NtoPMap.insert( std::pair<const int, XRefNode>( 8, XRefNode( 11,
158  CivilTime( 1983, 7, 14, 0, 0, 0.0, TimeSystem::GPS),
159  CivilTime( 1993, 5, 4, 0, 20, 0.0, TimeSystem::GPS))));
160  NtoPMap.insert( std::pair<const int, XRefNode>( 9, XRefNode( 13,
161  CivilTime( 1984, 6, 13, 0, 0, 0.0, TimeSystem::GPS),
162  CivilTime( 1993, 5, 4, 18, 17, 0.0, TimeSystem::GPS))));
163  NtoPMap.insert( std::pair<const int, XRefNode>( 10, XRefNode( 12,
164  CivilTime( 1984, 9, 8, 0, 0, 0.0, TimeSystem::GPS),
165  CivilTime( 1996, 3, 26, 23, 59, 59.9, TimeSystem::GPS))));
166  NtoPMap.insert( std::pair<const int, XRefNode>( 11, XRefNode( 3,
167  CivilTime( 1985, 10, 30, 0, 0, 0.0, TimeSystem::GPS),
168  CivilTime( 1994, 4, 14, 21, 0, 0.0, TimeSystem::GPS))));
169  // no NAVSTAR 12, was never launched
170  NtoPMap.insert( std::pair<const int, XRefNode>( 13, XRefNode( 2,
171  CivilTime( 1989, 6, 10, 0, 0, 0.0, TimeSystem::GPS),
172  CivilTime( 2004, 5, 12, 17, 1, 0.0, TimeSystem::GPS))));
173  NtoPMap.insert( std::pair<const int, XRefNode>( 14, XRefNode( 14,
174  CivilTime( 1989, 2, 14, 0, 0, 0.0, TimeSystem::GPS),
175  CivilTime( 2000, 4, 14, 13, 47, 0.0, TimeSystem::GPS))));
176  NtoPMap.insert( std::pair<const int, XRefNode>( 15, XRefNode( 15,
177  CivilTime( 1990, 10, 1, 0, 0, 0.0, TimeSystem::GPS),
178  CivilTime( 2007, 3, 15, 23, 59, 59.9, TimeSystem::GPS))));
179  NtoPMap.insert( std::pair<const int, XRefNode>( 16, XRefNode( 16,
180  CivilTime( 1989, 8, 18, 0, 0, 0.0, TimeSystem::GPS),
181  CivilTime( 2000, 10, 13, 0, 45, 0.0, TimeSystem::GPS))));
182  NtoPMap.insert( std::pair<const int, XRefNode>( 17, XRefNode( 17,
183  CivilTime( 1989, 12, 11, 0, 0, 0.0, TimeSystem::GPS),
184  CivilTime( 2005, 2, 23, 22, 0, 0.0, TimeSystem::GPS))));
185  NtoPMap.insert( std::pair<const int, XRefNode>( 18, XRefNode( 18,
186  CivilTime( 1990, 1, 24, 0, 0, 0.0, TimeSystem::GPS),
187  CivilTime( 2000, 8, 18, 7, 42, 0.0, TimeSystem::GPS))));
188  NtoPMap.insert( std::pair<const int, XRefNode>( 19, XRefNode( 19,
189  CivilTime( 1989, 10, 21, 0, 0, 0.0, TimeSystem::GPS),
190  CivilTime( 2001, 9, 11, 22, 0, 0.0, TimeSystem::GPS))));
191  NtoPMap.insert( std::pair<const int, XRefNode>( 20, XRefNode( 20,
192  CivilTime( 1990, 3, 26, 0, 0, 0.0, TimeSystem::GPS),
193  CivilTime( 1996, 12, 13, 23, 59, 59.9, TimeSystem::GPS))));
194  NtoPMap.insert( std::pair<const int, XRefNode>( 21, XRefNode( 21,
195  CivilTime( 1990, 8, 2, 0, 0, 0.0, TimeSystem::GPS),
196  CivilTime( 2003, 1, 27, 22, 0, 0.0, TimeSystem::GPS))));
197  NtoPMap.insert( std::pair<const int, XRefNode>( 22, XRefNode( 22,
198  CivilTime( 1993, 2, 3, 0, 0, 0.0, TimeSystem::GPS),
199  CivilTime( 2003, 8, 6, 22, 0, 0.0, TimeSystem::GPS))));
200  NtoPMap.insert( std::pair<const int, XRefNode>( 23, XRefNode( 23,
201  CivilTime( 1990, 11, 26, 0, 0, 0.0, TimeSystem::GPS),
202  CivilTime( 2004, 2, 13, 22, 0, 0.0, TimeSystem::GPS))));
203  // NANU #2016008 (end) - SVN 23 Decommissioned
204  NtoPMap.insert( std::pair<const int, XRefNode>( 23, XRefNode( 32,
205  CivilTime( 2006, 12, 1, 0, 0, 0.0, TimeSystem::GPS),
206  CivilTime( 2016, 1, 25, 20, 0, 0.0, TimeSystem::GPS))));
207  NtoPMap.insert( std::pair<const int, XRefNode>( 24, XRefNode( 24,
208  CivilTime( 1991, 7, 4, 0, 0, 0.0, TimeSystem::GPS),
209  CivilTime( 2011, 9, 30, 23, 59, 59.9, TimeSystem::GPS))));
210  NtoPMap.insert( std::pair<const int, XRefNode>( 25, XRefNode( 25,
211  CivilTime( 1992, 2, 23, 0, 0, 0.0, TimeSystem::GPS),
212  CivilTime( 2009, 12, 18, 22, 28, 0.0, TimeSystem::GPS))));
213  // NANU 2015005 (end) - extended due to additional data.
214  NtoPMap.insert( std::pair<const int, XRefNode>( 26, XRefNode( 26,
215  CivilTime( 1992, 7, 7, 0, 0, 0.0, TimeSystem::GPS),
216  CivilTime( 2015, 1, 20, 23, 59, 59.9, TimeSystem::GPS))));
217  // NANU # (start). NANU 2012061 (end)
218  // NANU #(start). NANU 2011059 (end).
219  NtoPMap.insert( std::pair<const int, XRefNode>( 27, XRefNode( 27,
220  CivilTime( 1992, 9, 9, 0, 0, 0.0, TimeSystem::GPS),
221  CivilTime( 2011, 8, 10, 23, 59, 59.9, TimeSystem::GPS))));
222  // NANU 2011105 (start). NANU 2012063 (end)
223  NtoPMap.insert( std::pair<const int, XRefNode>( 27, XRefNode( 27,
224  CivilTime( 2011, 12, 16, 22, 38, 0.0, TimeSystem::GPS),
225  CivilTime( 2012, 10, 6, 23, 59, 59.9, TimeSystem::GPS))));
226  // NANU 2013074 (start). NANU 2013080 (end)
227  NtoPMap.insert( std::pair<const int, XRefNode>( 27, XRefNode( 30,
228  CivilTime( 2013, 12, 3, 0, 0, 0.0, TimeSystem::GPS),
229  CivilTime( 2013, 12, 17, 23, 59, 59.9, TimeSystem::GPS))));
230  // NANU 2015010 (start). NANU 2013019 (end) plus actual received data.
231  NtoPMap.insert( std::pair<const int, XRefNode>( 27, XRefNode( 26,
232  CivilTime( 2015, 2, 26, 0, 0, 0.0, TimeSystem::GPS),
233  CivilTime( 2015, 3, 16, 23, 59, 59.9, TimeSystem::GPS))));
234  NtoPMap.insert( std::pair<const int, XRefNode>( 28, XRefNode( 28,
235  CivilTime( 1992, 4, 10, 0, 0, 0.0, TimeSystem::GPS),
236  CivilTime( 1997, 8, 15, 23, 59, 59.9, TimeSystem::GPS))));
237  NtoPMap.insert( std::pair<const int, XRefNode>( 29, XRefNode( 29,
238  CivilTime( 1992, 12, 18, 0, 0, 0.0, TimeSystem::GPS),
239  CivilTime( 2007, 10, 23, 23, 59, 59.9, TimeSystem::GPS))));
240  NtoPMap.insert( std::pair<const int, XRefNode>( 30, XRefNode( 30,
241  CivilTime( 1996, 9, 12, 0, 0, 0.0, TimeSystem::GPS),
242  CivilTime( 2011, 8, 4, 23, 59, 59.9, TimeSystem::GPS))));
243  NtoPMap.insert( std::pair<const int, XRefNode>( 31, XRefNode( 31,
244  CivilTime( 1993, 3, 30, 0, 0, 0.0, TimeSystem::GPS),
245  CivilTime( 2005, 10, 24, 23, 59, 59.9, TimeSystem::GPS))));
246  NtoPMap.insert( std::pair<const int, XRefNode>( 32, XRefNode( 1,
247  CivilTime( 1992, 11, 22, 0, 0, 0.0, TimeSystem::GPS),
248  CivilTime( 2008, 3, 17, 22, 0, 0.0, TimeSystem::GPS))));
249  // NANU 2012018 (start). NANU 2012024 (end)
250  NtoPMap.insert( std::pair<const int, XRefNode>( 32, XRefNode( 24,
251  CivilTime( 2012, 3, 14, 0, 0, 0.0, TimeSystem::GPS),
252  CivilTime( 2012, 4, 24, 23, 59, 59.9, TimeSystem::GPS))));
253  // NANU 2013049 (start). NANU 2013054 (end)
254  NtoPMap.insert( std::pair<const int, XRefNode>( 32, XRefNode( 30,
255  CivilTime( 2013, 8, 22, 0, 0, 0.0, TimeSystem::GPS),
256  CivilTime( 2013, 9, 18, 23, 59, 59.9, TimeSystem::GPS))));
257  // NANU 2015007 (start). NANU 2015101 (end) plus actual received data
258  NtoPMap.insert( std::pair<const int, XRefNode>( 32, XRefNode( 26,
259  CivilTime( 2015, 2, 5, 0, 0, 0.0, TimeSystem::GPS),
260  CivilTime( 2015, 2, 24, 23, 59, 59.9, TimeSystem::GPS))));
261  // NANU 2014063 (end).
262  // NANU claimed 8/2 end date. SV continued to broadcast until 8/18/2014.
263  NtoPMap.insert( std::pair<const int, XRefNode>( 33, XRefNode( 3,
264  CivilTime( 1996, 3, 28, 0, 0, 0.0, TimeSystem::GPS),
265  CivilTime( 2014, 8, 18 , 23, 59, 59.9, TimeSystem::GPS))));
266  // NANU 2015091 (end)
267  NtoPMap.insert( std::pair<const int, XRefNode>( 34, XRefNode( 4,
268  CivilTime( 1993, 10, 26, 0, 0, 0.0, TimeSystem::GPS),
269  CivilTime( 2015, 11, 9, 22, 0, 0.0, TimeSystem::GPS))));
270  // NANU 2016072 (start)
271  NtoPMap.insert( std::pair<const int, XRefNode>( 34, XRefNode( 4,
272  CivilTime( 2016, 12, 9, 0, 0, 0.0, TimeSystem::GPS),
273  CivilTime( 2017, 1, 3, 16, 0, 0.0, TimeSystem::GPS))));
274  // NANU 2018010 (start)
275  // NANU 2019xxx (DECOM)
276  // Last transmission observed on 3/9/2020 at 1929Z
277  NtoPMap.insert( std::pair<const int, XRefNode>( 34, XRefNode( 18,
278  CivilTime( 2018, 3, 8, 0, 0, 0.0, TimeSystem::GPS),
279  CivilTime( 2020, 3, 9, 22, 0, 0.0, TimeSystem::GPS))));
280 
281  NtoPMap.insert( std::pair<const int, XRefNode>( 35, XRefNode( 5,
282  CivilTime( 1993, 8, 30, 0, 0, 0.0, TimeSystem::GPS),
283  CivilTime( 2009, 3, 26, 20, 31, 0.0, TimeSystem::GPS))));
284  NtoPMap.insert( std::pair<const int, XRefNode>( 35, XRefNode( 1,
285  CivilTime( 2011, 6, 1, 0, 0, 0.0, TimeSystem::GPS),
286  CivilTime( 2011, 7, 12, 23, 59, 59.9, TimeSystem::GPS))));
287  // See PRN 30 notes below for how we arrived at the end time.
288  NtoPMap.insert( std::pair<const int, XRefNode>( 35, XRefNode( 30,
289  CivilTime( 2011, 8, 6, 20, 0, 0.0, TimeSystem::GPS),
290  CivilTime( 2013, 5, 1, 22, 00, 0.0, TimeSystem::GPS))));
291  // NANU 2013029 (start), NANU 2013049 (end-IMPLIED)
292  // Note: NANU 2013029 says Approximately 5/8/13 SVN 49 will continue
293 
294  // broadcasting as PRN 30. Signal evidence indicates that SVN 49 used PRN 27 until
295  // about 5/9/2013 1600 Therefore. In the meantime SOME SVN was transmitting
296  // PRN 30 through 5/6/2013 2000+. Therefore, we've added an "extension" to the
297  // SVN 35 decommissioning and moved the SVN49/PRN30 start time.
298 
299  NtoPMap.insert( std::pair<const int, XRefNode>( 35, XRefNode( 30,
300  CivilTime( 2013, 5, 2, 0, 0, 0.0, TimeSystem::GPS),
301  CivilTime( 2013, 5, 6, 22, 00, 0.0, TimeSystem::GPS))));
302 
303  NtoPMap.insert( std::pair<const int, XRefNode>( 35, XRefNode( 3,
304  CivilTime( 2014, 9, 5, 0, 0, 0.0, TimeSystem::GPS),
305  CivilTime( 2014, 10, 22, 0, 00, 0.0, TimeSystem::GPS))));
306 
307  // NANU 2014015/2014019 (end)
308  // NANU claimed 2/21 end date. SV continued to broadcast until 3/3/2014.
309  NtoPMap.insert( std::pair<const int, XRefNode>( 36, XRefNode( 6,
310  CivilTime( 1995, 3, 10, 0, 0, 0.0, TimeSystem::GPS),
311  CivilTime( 2014, 3, 3, 23, 59, 59.9, TimeSystem::GPS))));
312  // NANU 2015080 (start)
313  NtoPMap.insert( std::pair<const int, XRefNode>( 36, XRefNode( 10,
314  CivilTime( 2015, 9, 16, 0, 0, 0.0, TimeSystem::GPS),
315  CivilTime( 2015, 10, 26, 23, 59, 59.9, TimeSystem::GPS))));
316  // NANU 2017070 (start), NANU 2018122 (stop)
317  NtoPMap.insert( std::pair<const int, XRefNode>( 36, XRefNode( 4,
318  CivilTime( 2017, 7, 15, 0, 0, 0.0, TimeSystem::GPS),
319  CivilTime( 2017, 11, 29, 23, 59, 59.9, TimeSystem::GPS))));
320  // NANU 2018042 (start)
321  NtoPMap.insert( std::pair<const int, XRefNode>( 36, XRefNode( 4,
322  CivilTime( 2018, 10, 10, 0, 0, 0.0, TimeSystem::GPS),
323  CivilTime( 2019, 1, 3, 23, 59, 59.9, TimeSystem::GPS))));
324  // NANU 2019104 (start), NANU 2019159 & observation (end)
325  NtoPMap.insert( std::pair<const int, XRefNode>( 36, XRefNode( 4,
326  CivilTime( 2019, 7, 18, 0, 0, 0.0, TimeSystem::GPS),
327  CivilTime( 2019, 10, 07, 23, 59, 59.9, TimeSystem::GPS))));
328 
329  NtoPMap.insert( std::pair<const int, XRefNode>( 37, XRefNode( 7,
330  CivilTime( 1993, 5, 13, 0, 0, 0.0, TimeSystem::GPS),
331  CivilTime( 2007, 7, 20, 23, 59, 59.9, TimeSystem::GPS))));
332  NtoPMap.insert( std::pair<const int, XRefNode>( 37, XRefNode( 1,
333  CivilTime( 2008, 10, 23, 0, 0, 0.0, TimeSystem::GPS),
334  CivilTime( 2009, 1, 6, 23, 59, 59.9, TimeSystem::GPS))));
335  // NANU 2012024 (start). NANU 201249 (end)
336  NtoPMap.insert( std::pair<const int, XRefNode>( 37, XRefNode( 24,
337  CivilTime( 2012, 4, 25, 0, 0, 0.0, TimeSystem::GPS),
338  CivilTime( 2012, 8, 7, 23, 59, 59.9, TimeSystem::GPS))));
339  // NANU 2013054 (start). NANU 2013074 (end)
340  NtoPMap.insert( std::pair<const int, XRefNode>( 37, XRefNode( 30,
341  CivilTime( 2013, 9, 19, 0, 0, 0.0, TimeSystem::GPS),
342  CivilTime( 2013, 12, 2, 23, 59, 59.9, TimeSystem::GPS))));
343  // NANU 2015021 (end)
344  NtoPMap.insert( std::pair<const int, XRefNode>( 38, XRefNode( 8,
345  CivilTime( 1997, 11, 6, 0, 0, 0.0, TimeSystem::GPS),
346  CivilTime( 2015, 4, 13, 23, 59, 59.9, TimeSystem::GPS))));
347  // NANU 2017042 (start), NANU 2017070 (end)
348  NtoPMap.insert( std::pair<const int, XRefNode>( 38, XRefNode( 4,
349  CivilTime( 2017, 5, 13, 0, 0, 0.0, TimeSystem::GPS),
350  CivilTime( 2017, 7, 14, 23, 59, 59.9, TimeSystem::GPS))));
351  // NANU 2014046 (end)
352  // NANU claimed 5/19 end date. SV continued tp broadcast until 5/27/2014.
353  NtoPMap.insert( std::pair<const int, XRefNode>( 39, XRefNode( 9,
354  CivilTime( 1993, 6, 26, 0, 0, 0.0, TimeSystem::GPS),
355  CivilTime( 2014, 5, 27, 23, 59, 59.9, TimeSystem::GPS))));
356  // NANU 2014050 (start)
357  NtoPMap.insert( std::pair<const int, XRefNode>( 39, XRefNode( 9,
358  CivilTime( 2014, 6, 13, 0, 0, 0.0, TimeSystem::GPS),
359  CivilTime( 2014, 8, 1, 23, 59, 59.9, TimeSystem::GPS))));
360  NtoPMap.insert( std::pair<const int, XRefNode>( 40, XRefNode( 10,
361  CivilTime( 1996, 7, 16, 0, 0, 0.0, TimeSystem::GPS),
362  CivilTime( 2015, 8, 3, 23, 59, 59.9, TimeSystem::GPS))));
363  // NANU 2020034 DECOM on 07/09/2020. Last Transmission observed shortly before 1600 on 7/27/20
364  NtoPMap.insert( std::pair<const int, XRefNode>( 41, XRefNode( 14,
365  CivilTime( 2000, 11, 10, 0, 0, 0.0, TimeSystem::GPS),
366  CivilTime( 2020, 7, 27, 16, 0, 0.0, TimeSystem::GPS))));
367  // no NAVSTAR 42, IIR-1 was a launch failure
368  NtoPMap.insert( std::pair<const int, XRefNode>( 43, XRefNode( 13,
369  CivilTime( 1997, 7, 23, 0, 0, 0.0, TimeSystem::GPS),
370  CommonTime::END_OF_TIME )));
371  NtoPMap.insert( std::pair<const int, XRefNode>( 44, XRefNode( 28,
372  CivilTime( 2000, 7, 16, 0, 0, 0.0, TimeSystem::GPS),
373  CommonTime::END_OF_TIME )));
374  NtoPMap.insert( std::pair<const int, XRefNode>( 45, XRefNode( 21,
375  CivilTime( 2003, 3, 31, 0, 0, 0.0, TimeSystem::GPS),
376  CommonTime::END_OF_TIME )));
377  NtoPMap.insert( std::pair<const int, XRefNode>( 46, XRefNode( 11,
378  CivilTime( 1999, 10, 7, 0, 0, 0.0, TimeSystem::GPS),
379  CommonTime::END_OF_TIME )));
380  NtoPMap.insert( std::pair<const int, XRefNode>( 47, XRefNode( 22,
381  CivilTime( 2003, 12, 21, 0, 0, 0.0, TimeSystem::GPS),
382  CommonTime::END_OF_TIME )));
383  NtoPMap.insert( std::pair<const int, XRefNode>( 48, XRefNode( 7,
384  CivilTime( 2008, 3, 15, 0, 0, 0.0, TimeSystem::GPS),
385  CommonTime::END_OF_TIME )));
386  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 1,
387  CivilTime( 2009, 3, 24, 0, 0, 0.0, TimeSystem::GPS),
388  CivilTime( 2011, 5, 6, 16, 0, 0.0, TimeSystem::GPS))));
389  // NANU 2012003 (start). NANU 2012018 (end)
390  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 24,
391  CivilTime( 2012, 2, 1, 0, 0, 0.0, TimeSystem::GPS),
392  CivilTime( 2012, 3, 13, 23, 59, 59.9, TimeSystem::GPS))));
393  // NANU 2012049 (start). NANU # (end)
394  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 24,
395  CivilTime( 2012, 8, 8, 0, 0, 0.0, TimeSystem::GPS),
396  CivilTime( 2012, 8, 22, 23, 59, 59.9, TimeSystem::GPS))));
397  // NANU 2012064 (start).
398  // We don't know exactly WHEN this relationship stopped. NANU 2013021 states when
399  // it resumes.
400  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 27,
401  CivilTime( 2012, 10, 18, 0, 0, 0.0, TimeSystem::GPS),
402  CivilTime( 2012, 12, 31, 23, 59, 59.9, TimeSystem::GPS))));
403  // NANU 2013021 (start), 2013031 (end-IMPLIED)
404  // See PRN30/SVN49 notes below for how we derived this end time.
405  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 27,
406  CivilTime( 2013, 3, 27, 0, 0, 0.0, TimeSystem::GPS),
407  CivilTime( 2013, 5, 9, 16, 44, 59.9, TimeSystem::GPS))));
408  // NANU 2013029 (start), 2013049 (end-IMPLIED)
409  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 30,
410  CivilTime( 2013, 5, 9, 16, 45, 0.0, TimeSystem::GPS),
411  CivilTime( 2013, 8, 21, 23, 59, 59.9, TimeSystem::GPS))));
412  // NANU 2013080 (start), 2014018 (end-IMPLIED)
413  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 30,
414  CivilTime( 2013, 12, 18, 0, 0, 0.0, TimeSystem::GPS),
415  CivilTime( 2014, 2, 20, 23, 59, 0.0, TimeSystem::GPS))));
416  // NANU 2014032 (start), 2014045 (end-IMPLIED)
417  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 6,
418  CivilTime( 2014, 4, 3, 0, 0, 0.0, TimeSystem::GPS),
419  CivilTime( 2014, 5, 15, 23, 59, 59.9, TimeSystem::GPS))));
420  // NANU 2015032 (start)
421  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 8,
422  CivilTime( 2015, 4, 30, 0, 0, 0.0, TimeSystem::GPS),
423  CivilTime( 2015, 7, 1, 16, 0, 0.0, TimeSystem::GPS))));
424  // NANU 2016009 (general/start)
425  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 4,
426  CivilTime( 2016, 2, 4, 0, 0, 0.0, TimeSystem::GPS),
427  CivilTime( 2016, 12, 5, 15, 10, 0.0, TimeSystem::GPS))));
428  // NANU 2017001 (start), NANU 2017042 (end)
429  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 4,
430  CivilTime( 2017, 1, 5, 0, 0, 0.0, TimeSystem::GPS),
431  CivilTime( 2017, 5, 12, 23, 59, 59.9, TimeSystem::GPS))));
432 
433  // NANU 2017122 (start), NANU 2018042 (end)
434  NtoPMap.insert( std::pair<const int, XRefNode>( 49, XRefNode( 4,
435  CivilTime( 2017, 12, 1, 0, 0, 0.0, TimeSystem::GPS),
436  CivilTime( 2018, 9, 28, 23, 59, 59.9, TimeSystem::GPS))));
437 
438  NtoPMap.insert( std::pair<const int, XRefNode>( 50, XRefNode( 5,
439  CivilTime( 2009, 8, 27, 0, 0, 0.0, TimeSystem::GPS),
440  CommonTime::END_OF_TIME )));
441  NtoPMap.insert( std::pair<const int, XRefNode>( 51, XRefNode( 20,
442  CivilTime( 2000, 5, 11, 0, 0, 0.0, TimeSystem::GPS),
443  CommonTime::END_OF_TIME )));
444  NtoPMap.insert( std::pair<const int, XRefNode>( 52, XRefNode( 31,
445  CivilTime( 2006, 9, 25, 0, 0, 0.0, TimeSystem::GPS),
446  CommonTime::END_OF_TIME )));
447  NtoPMap.insert( std::pair<const int, XRefNode>( 53, XRefNode( 17,
448  CivilTime( 2005, 9, 26, 0, 0, 0.0, TimeSystem::GPS),
449  CommonTime::END_OF_TIME )));
450  // NANU2018009 (end)
451  NtoPMap.insert( std::pair<const int, XRefNode>( 54, XRefNode( 18,
452  CivilTime( 2001, 1, 30, 0, 0, 0.0, TimeSystem::GPS),
453  CivilTime( 2018, 3, 5, 22, 0, 0.0, TimeSystem::GPS))));
454  NtoPMap.insert( std::pair<const int, XRefNode>( 55, XRefNode( 15,
455  CivilTime( 2007, 10, 17, 0, 0, 0.0, TimeSystem::GPS),
456  CommonTime::END_OF_TIME )));
457  NtoPMap.insert( std::pair<const int, XRefNode>( 56, XRefNode( 16,
458  CivilTime( 2003, 1, 29, 0, 0, 0.0, TimeSystem::GPS),
459  CommonTime::END_OF_TIME )));
460  NtoPMap.insert( std::pair<const int, XRefNode>( 57, XRefNode( 29,
461  CivilTime( 2007, 12, 21, 0, 0, 0.0, TimeSystem::GPS),
462  CommonTime::END_OF_TIME )));
463  NtoPMap.insert( std::pair<const int, XRefNode>( 58, XRefNode( 12,
464  CivilTime( 2006, 11, 17, 0, 0, 0.0, TimeSystem::GPS),
465  CommonTime::END_OF_TIME )));
466  NtoPMap.insert( std::pair<const int, XRefNode>( 59, XRefNode( 19,
467  CivilTime( 2004, 3, 20, 0, 0, 0.0, TimeSystem::GPS),
468  CommonTime::END_OF_TIME )));
469  // NANU 2020012 DECOM (3/11/20)
470  // Last transmission observed on 6/9/2020 between 1600-1800
471  NtoPMap.insert( std::pair<const int, XRefNode>( 60, XRefNode( 23,
472  CivilTime( 2004, 6, 23, 0, 0, 0.0, TimeSystem::GPS),
473  CivilTime( 2020, 6, 9, 17, 59, 59.9, TimeSystem::GPS))));
474  NtoPMap.insert( std::pair<const int, XRefNode>( 61, XRefNode( 2,
475  CivilTime( 2004, 6, 6, 0, 0, 0.0, TimeSystem::GPS),
476  CommonTime::END_OF_TIME )));
477  NtoPMap.insert( std::pair<const int, XRefNode>( 62, XRefNode( 25,
478  CivilTime( 2010, 5, 28, 3, 0, 0.0, TimeSystem::GPS),
479  CommonTime::END_OF_TIME )));
480  NtoPMap.insert( std::pair<const int, XRefNode>( 63, XRefNode( 1,
481  CivilTime( 2011, 7, 20, 9, 36, 36.0, TimeSystem::GPS),
482  CommonTime::END_OF_TIME )));
483  // NANU 2014018
484  NtoPMap.insert( std::pair<const int, XRefNode>( 64, XRefNode( 30,
485  CivilTime( 2014, 2, 21, 0, 0, 0.0, TimeSystem::GPS),
486  CommonTime::END_OF_TIME )));
487 
488  NtoPMap.insert( std::pair<const int, XRefNode>( 65, XRefNode( 24,
489  CivilTime( 2012, 10, 4, 0, 0, 0.0, TimeSystem::GPS),
490  CommonTime::END_OF_TIME )));
491 
492  NtoPMap.insert( std::pair<const int, XRefNode>( 66, XRefNode( 27,
493  CivilTime( 2013, 5, 15, 0, 0, 0.0, TimeSystem::GPS),
494  CommonTime::END_OF_TIME )));
495  //NANU 2014045 (start)
496  NtoPMap.insert( std::pair<const int, XRefNode>( 67, XRefNode( 6,
497  CivilTime( 2014, 5, 17, 0, 0, 0.0, TimeSystem::GPS),
498  CommonTime::END_OF_TIME )));
499  //
500  NtoPMap.insert( std::pair<const int, XRefNode>( 68, XRefNode( 9,
501  CivilTime( 2014, 8, 2, 0, 0, 0.0, TimeSystem::GPS),
502  CommonTime::END_OF_TIME )));
503 
504  NtoPMap.insert( std::pair<const int, XRefNode>( 69, XRefNode( 3,
505  CivilTime( 2014, 10, 29, 0, 0, 0.0, TimeSystem::GPS),
506  CommonTime::END_OF_TIME )));
507  // NANU 2016011 LAUNCH
508  NtoPMap.insert( std::pair<const int, XRefNode>( 70, XRefNode( 32,
509  CivilTime( 2016, 2, 5, 13, 30, 0.0, TimeSystem::GPS),
510  CommonTime::END_OF_TIME )));
511  //NANU 2015019 LAUNCH
512  NtoPMap.insert( std::pair<const int, XRefNode>( 71, XRefNode( 26,
513  CivilTime( 2015, 3, 25, 18, 36, 0.0, TimeSystem::GPS),
514  CommonTime::END_OF_TIME )));
515  //NANU 2015068 LAUNCH
516  NtoPMap.insert( std::pair<const int, XRefNode>( 72, XRefNode( 8,
517  CivilTime( 2015, 7, 15, 0, 0, 0.0, TimeSystem::GPS),
518  CommonTime::END_OF_TIME )));
519  //Added before NANU was sent.
520  NtoPMap.insert( std::pair<const int, XRefNode>( 73, XRefNode( 10,
521  CivilTime( 2015, 10, 31, 16, 23, 0.0, TimeSystem::GPS),
522  CommonTime::END_OF_TIME )));
523  //NANU 2019001 LAUNCH
524  //End date is end of On-orbit checkout
525  NtoPMap.insert( std::pair<const int, XRefNode>( 74, XRefNode( 4,
526  CivilTime( 2019, 1, 8, 23, 0, 0.0, TimeSystem::GPS),
527  CivilTime( 2019, 7, 12, 20, 0, 0.0, TimeSystem::GPS))));
528  //NANU 2019159 (and supported CGSIC e-mail)
529  NtoPMap.insert( std::pair<const int, XRefNode>( 74, XRefNode( 4,
530  CivilTime( 2019, 10, 21, 20, 00, 0.0, TimeSystem::GPS),
531  CommonTime::END_OF_TIME )));
532  //NANU 2020011 LAUNCH
533  // First transmission observed on 3/12 at 2236Z
534  NtoPMap.insert( std::pair<const int, XRefNode>( 75, XRefNode( 18,
535  CivilTime( 2020, 3, 12, 22, 30, 0.0, TimeSystem::GPS),
536  CommonTime::END_OF_TIME )));
537  //NANU 2020033 LAUNCH
538  // First transmission observed on 7/14
539  NtoPMap.insert( std::pair<const int, XRefNode>( 76, XRefNode( 23,
540  CivilTime( 2020, 7, 14, 0, 0, 0.0, TimeSystem::GPS),
541  CommonTime::END_OF_TIME )));
542  //NANU 2020077 LAUNCH
543  // First transmission observed on 11/17/2020 at 0551 (nav msg collection)
544  // Backed time off a little to account for possible earlier obs data.
545  NtoPMap.insert( std::pair<const int, XRefNode>( 77, XRefNode( 14,
546  CivilTime( 2020, 11, 17, 5, 30, 0.0, TimeSystem::GPS),
547  CommonTime::END_OF_TIME )));
548 
549  //Iterate through the data to produce the PtoNMap
550  multimap<int,XRefNode>::const_iterator itate;
551  //Iterates through Navstar by PRN map for each relationship building the corresponding map
552  for (itate=NtoPMap.begin(); itate != NtoPMap.end(); itate++)
553  {
554  std::pair<const int, gnsstk::XRefNode> values = *itate;
555  //Grabs the values to then insert into PtoN
556  int navNum = values.first;
557  int prnNum = values.second.getPRNNum();
558  TimeRange valid = values.second.getTimeRange();
559  //Insert to tree
560  PtoNMap.insert( std::pair<const int, XRefNode>( prnNum, XRefNode( navNum, valid )));
561  }
562 
563 }
564 
565 int SVNumXRef::getNAVSTAR( const int PRNID, const gnsstk::CommonTime dt ) const
566 {
567  SVNumXRefPair p = PtoNMap.equal_range( PRNID );
568  for (SVNumXRefListCI ci=p.first; ci != p.second; ++ci )
569  {
570  if (ci->second.isApplicable( dt )) return ci->second.getNAVSTARNum();
571  }
572 
573  // We didn't find a NAVSTAR # for this PRN ID and date, so throw an
574  // exception.
575  char textOut[80];
576  sprintf(textOut,"No NAVSTAR # found associated with PRN ID %d at requested date: %s.",
577  PRNID,printTime(dt,"%02m/%02d/%04Y").c_str() );
578  std::string sout = textOut;
579  NoNAVSTARNumberFound noFound( sout );
580  GNSSTK_THROW(noFound);
581  return 0;
582 }
583 
584 bool SVNumXRef::NAVSTARIDAvailable( const int PRNID, const gnsstk::CommonTime dt ) const
585 {
586  SVNumXRefPair p = PtoNMap.equal_range( PRNID );
587  for (SVNumXRefListCI ci=p.first; ci != p.second; ++ci )
588  {
589  if (ci->second.isApplicable( dt )) return true;
590  }
591  return false;
592 }
593 
594 bool SVNumXRef::NAVSTARIDActive( const int NAVSTARID, const gnsstk::CommonTime dt ) const
595 {
596  return PRNIDAvailable ( NAVSTARID, dt) ;
597 }
598 
599 SVNumXRef::BlockType SVNumXRef::getBlockType( const int NAVSTARID ) const
600 {
601  map<int,BlockType>::const_iterator i;
602  i = NtoBMap.find( NAVSTARID );
603  if (i!=NtoBMap.end()) return(i->second);
604 
605  // We didn't find a BlockType for this NAVSTAR #, so throw an
606  // exception.
607  char textOut[80];
608  sprintf(textOut,"No BlockType found associated with NAVSTAR Num %d.",
609  NAVSTARID);
610  std::string sout = textOut;
611  NoNAVSTARNumberFound noFound( sout );
612  GNSSTK_THROW(noFound);
613  return SVNumXRef::BlockType();
614 }
615 
616 std::string SVNumXRef::getBlockTypeString( const int NAVSTARID ) const
617 {
618  std::map<int,BlockType>::const_iterator i;
619  i = NtoBMap.find( NAVSTARID );
620  if (i!=NtoBMap.end())
621  {
622  BlockType bt = i->second;
623  switch( bt )
624  {
625  case I: return("Block I"); break;
626  case II: return("Block II"); break;
627  case IIA: return("Block IIA"); break;
628  case IIR: return("Block IIR"); break;
629  case IIR_M: return("Block IIR_M"); break;
630  case IIF: return("Block IIF"); break;
631  case III: return("GPS III"); break;
632  }
633  }
634  return "unknown";
635 }
636 
637 int SVNumXRef::getPRNID( const int NAVSTARID, const gnsstk::CommonTime dt ) const
638 {
639  NAVNumXRefPair p = NtoPMap.equal_range( NAVSTARID );
640  for (NAVNumXRefCI ci=p.first; ci != p.second; ++ci )
641  {
642  if (ci->second.isApplicable( dt )) return ci->second.getPRNNum();
643  }
644 
645  // We didn't find a PRN ID for this NAVSTAR # and date, so throw an
646  // exception.
647  char textOut[80];
648  sprintf(textOut,"No PRN ID found associated with NAVSTAR Num %d at requested date: %s.",
649  NAVSTARID,printTime(dt,"%02m/%02d/%04Y").c_str() );
650  std::string sout = textOut;
651  NoNAVSTARNumberFound noFound( sout );
652  GNSSTK_THROW(noFound);
653  return 0;
654 }
655 
656 bool SVNumXRef::PRNIDAvailable( const int NAVSTARID, const gnsstk::CommonTime dt ) const
657 {
658  NAVNumXRefPair p = NtoPMap.equal_range( NAVSTARID );
659  for (NAVNumXRefCI ci=p.first; ci != p.second; ++ci )
660  {
661  if (ci->second.isApplicable( dt )) return true;
662  }
663  return false;
664 }
665 
666 bool SVNumXRef::BlockTypeAvailable( const int NAVSTARID ) const
667 {
668  map<int,BlockType>::const_iterator i;
669  i = NtoBMap.find( NAVSTARID );
670  if (i!=NtoBMap.end()) return true;
671  return false;
672 }
673 
674 //----------Dumps out a List of and ALSO checks for Overlaps is overlap is set to true
675 //----------Navstar #s---PRN---start time---end time---
676 //----------PRN---Navstar #s---start time---end time---
677 void SVNumXRef::dump(std::ostream& out) const
678 {
679  //iterate through the data
680  multimap<int,XRefNode>::const_iterator it;
681  bool pastCurrent = false;
682  //header
683  std::string start_end_h = " START"
684  " END\n";
685  std::string svn_h = " SVN PRN MM/DD/YYYY DOY HH:MM:SS"
686  " MM/DD/YYYY DOY HH:MM:SS\n";
687  out << start_end_h << svn_h;
688  //Iterates through Navstar by PRN
689  for (it=NtoPMap.begin(); it != NtoPMap.end(); it++)
690  {
691  std::pair<const int, gnsstk::XRefNode> mm = *it;
692  out << " " << setw(2) << mm.first
693  << " " << mm.second.toString() << endl;
694  }
695  out << "\n\n\n";
696  //iterate through the data
697  multimap<int,XRefNode>::const_iterator iter;
698  //resest pastCurrent
699  pastCurrent = false;
700  //header
701  std::string prn_h = " PRN SVN MM/DD/YYYY DOY HH:MM:SS"
702  " MM/DD/YYYY DOY HH:MM:SS\n";
703  out << start_end_h << prn_h;
704  //Iterates through PRN by Navstar
705  for (iter = PtoNMap.begin(); iter != PtoNMap.end(); iter++)
706  {
707  std::pair<const int, gnsstk::XRefNode> pp = *iter;
708  out << " " << setw(2) << pp.first
709  << " " << pp.second.toString() <<endl;
710  }
711 }
712 
713 //-------------- Methods for XRefNode -----------------
714 XRefNode::XRefNode( const int NumArg,
715  const gnsstk::TimeRange tr )
716 {
717  Num = NumArg;
718  valid = tr;
719 }
720 
721 XRefNode::XRefNode( const int NumArg,
722  const gnsstk::CommonTime begDT,
723  const gnsstk::CommonTime endDT )
724 {
725  Num = NumArg;
726  valid = TimeRange( begDT, endDT );
727 }
728 
729 bool XRefNode::isApplicable( gnsstk::CommonTime dt ) const
730 {
731  if (valid.inRange(dt)) return true;
732  return false;
733 }
734 
735 std::string XRefNode::toString() const
736 {
737  std::string sout;
738  std::string tform = "%02m/%02d/%4Y %03j %02H:%02M:%05.2f";
739  //create stringstream to convert Num to a string to concatinate to sout
740  std::stringstream ss;
741  ss << setfill('0') << setw(2) << Num;
742  ss << " " << printTime( valid.getStart(), tform );
743  ss << " ";
744  if( valid.getEnd() == CommonTime::END_OF_TIME)
745  ss << "End of Time";
746  else
747  ss << printTime( valid.getEnd(), tform );
748 
749  return ss.str();
750 }
751 
752 // Returns true if there are no overlaps, and false otherwise
753 bool SVNumXRef::isConsistent() const
754 {
755  bool retVal = true;
756  // Defining iterators
757  multimap<int, XRefNode>::const_iterator cit1;
758  multimap<int, XRefNode>::const_iterator cit2;
759  // loops through the multimap
760  for (cit1 = NtoPMap.begin(); cit1 != NtoPMap.end(); cit1++)
761  {
762  cit2 = cit1;
763  cit2++; // cit2 always starts the nested loop one higher than cit1
764  for (; cit2 != NtoPMap.end(); cit2++)
765  {
766  int key1 = cit1->first; // keys represent the SVN numbers
767  int key2 = cit2->first;
768  const XRefNode xr1 = cit1->second; // these const xr variables represent the XRefNode so we can access the begin and end times
769  const XRefNode xr2 = cit2->second; // of each SVN/PRN pair
770  int val1 = xr1.getPRNNum(); // vals represent the PRN numbers
771  int val2 = xr2.getPRNNum();
772 
773  if ((key1 == key2) || (val1 == val2)) // checks initial condition for an overlap; if neither are true, there is no overlap
774  {
775  const TimeRange& tr1 = xr1.getTimeRange();
776  const TimeRange& tr2 = xr2.getTimeRange();
777  if (tr1.overlaps(tr2))
778  {
779  retVal = false;
780  string tform("%02m/%02d/%04Y %02H:%02M:%02S");
781  std::cout << "Overlap between SVN"
782  << setw(2) << key1 << "/PRN"
783  << setw(2) << val1 << " at "
784  << tr1.printf(tform) << endl;
785  std::cout << " and SVN"
786  << setw(2) << key2 << "/PRN"
787  << setw(2) << val2 << " at "
788  << tr2.printf(tform) << endl;
789  }
790  }
791  }
792  }
793  return retVal; // if we reach this point, we know there are no overlaps
794 }
gnsstk::dump
void dump(vector< SatPass > &SatPassList, ostream &os, bool rev, bool dbug)
Definition: SatPassUtilities.cpp:59
gnsstk::SVNumXRefPair
std::pair< SVNumXRefListCI, SVNumXRefListCI > SVNumXRefPair
Definition: SVNumXRef.hpp:137
gnsstk::SVNumXRefListCI
std::multimap< int, XRefNode >::const_iterator SVNumXRefListCI
Definition: SVNumXRef.hpp:136
gnsstk::TimeRange::overlaps
bool overlaps(const TimeRange &right) const
Definition: TimeRange.cpp:221
gnsstk::TimeRange::printf
std::string printf(const std::string formatArg="%02m/%02d/%02y %02H:%02M:%02S") const
Definition: TimeRange.cpp:376
gnsstk
For Sinex::InputHistory.
Definition: BasicFramework.cpp:50
gnsstk::TimeRange
Definition: TimeRange.hpp:59
gnsstk::NAVNumXRefCI
std::multimap< int, XRefNode >::const_iterator NAVNumXRefCI
Definition: SVNumXRef.hpp:138
gnsstk::NAVNumXRefPair
std::pair< NAVNumXRefCI, NAVNumXRefCI > NAVNumXRefPair
Definition: SVNumXRef.hpp:139
SVNumXRef.hpp
gnsstk::CommonTime
Definition: CommonTime.hpp:84
gnsstk::XRefNode::getPRNNum
int getPRNNum() const
Definition: SVNumXRef.hpp:178
example6.valid
valid
Definition: example6.py:20
gnsstk::XRefNode::getTimeRange
gnsstk::TimeRange getTimeRange() const
Definition: SVNumXRef.hpp:181
CivilTime.hpp
gnsstk::END_OF_TIME
const Epoch END_OF_TIME(CommonTime::END_OF_TIME)
Latest Representable Epoch.
gnsstk::CivilTime
Definition: CivilTime.hpp:55
gnsstk::printTime
std::string printTime(const CommonTime &t, const std::string &fmt)
Definition: TimeString.cpp:64
std
Definition: Angle.hpp:142
GNSSTK_THROW
#define GNSSTK_THROW(exc)
Definition: Exception.hpp:366
gnsstk::XRefNode
Definition: SVNumXRef.hpp:115
gnsstk::SVNumXRef::BlockType
BlockType
Definition: SVNumXRef.hpp:145
TimeString.hpp

gnsstk
Author(s):
autogenerated on Wed Oct 25 2023 02:40:41