RACRotation_T.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 #include "RACRotation.hpp"
40 #include "Xvt.hpp"
41 #include "Triple.hpp"
42 #include "GNSSconstants.hpp"
43 #include "GPS_URA.hpp"
44 #include "Position.hpp"
45 #include "TestUtil.hpp"
46 #include <iostream>
47 #include <fstream>
48 
49 using namespace gnsstk;
50 using namespace std;
51 
52 /* Tests should be cleaned to use a == or != operator for the Triple class, once one is added.*/
53 class RACRotation_T
54 {
55  public:
56  RACRotation_T(){eps = 1e-12;}// Default Constructor, set the precision value
57  ~RACRotation_T() {} // Default Desructor
58 
59  /* First test case. SV at GPS orbit altitude at 0 deg N, 0 deg E
60  Heading due N at 4 km/sec
61  Resulting RAC matrix: [ 1 0 0]
62  [ 0 0 1]
63  [ 0 -1 0] */
64  int tripleFirstTest (void)
65  {
66  TestUtil testFramework( "RACRotation", "convertToRAC", __FILE__, __LINE__ );
67  std::string failMesg;
68 
69  double GPSAlt = 26000000;
70  Triple XYZ, rotatedXYZ;
71  Triple SVPos( GPSAlt, 0, 0);
72  Triple SVVel( 0, 0, 4000 );
73  RACRotation rot( SVPos, SVVel );
74 
75  // OK, now give it test vectors to rotate
76  XYZ = Triple( 1.0, 1.0, 1.0);
77  rotatedXYZ = rot.convertToRAC( XYZ );
78  //Compare results
79 
80  failMesg = "Was the X value rotated properly?";
81  testFramework.assert(1 == rotatedXYZ[0], failMesg, __LINE__);
82 
83  failMesg = "Was the Y value rotated properly?";
84  testFramework.assert(1 == rotatedXYZ[1], failMesg, __LINE__);
85 
86  failMesg = "Was the Z value rotated properly?";
87  testFramework.assert(-1 == rotatedXYZ[2], failMesg, __LINE__);
88 
89 
90  XYZ = Triple( -1.0, -1.0, -1.0);
91  rotatedXYZ = rot.convertToRAC( XYZ );
92 
93  failMesg = "Was the X value rotated properly?";
94  testFramework.assert(-1 == rotatedXYZ[0], failMesg, __LINE__);
95 
96  failMesg = "Was the Y value rotated properly?";
97  testFramework.assert(-1 == rotatedXYZ[1], failMesg, __LINE__);
98 
99  failMesg = "Was the Z value rotated properly?";
100  testFramework.assert(1 == rotatedXYZ[2], failMesg, __LINE__);
101 
102 
103  XYZ = Triple( 0.0, 0.0, -1.0);
104  rotatedXYZ = rot.convertToRAC( XYZ );
105 
106  failMesg = "Was the X value rotated properly?";
107  testFramework.assert(0 == rotatedXYZ[0], failMesg, __LINE__);
108 
109  failMesg = "Was the Y value rotated properly?";
110  testFramework.assert(-1 == rotatedXYZ[1], failMesg, __LINE__);
111 
112  failMesg = "Was the Z value rotated properly?";
113  testFramework.assert(0 == rotatedXYZ[2], failMesg, __LINE__);
114 
115 
116  XYZ = Triple( 0.0, -1.0, 0.0);
117  rotatedXYZ = rot.convertToRAC( XYZ );
118 
119  failMesg = "Was the X value rotated properly?";
120  testFramework.assert(0 == rotatedXYZ[0], failMesg, __LINE__);
121 
122  failMesg = "Was the Y value rotated properly?";
123  testFramework.assert(0 == rotatedXYZ[1], failMesg, __LINE__);
124 
125  failMesg = "Was the Z value rotated properly?";
126  testFramework.assert(1 == rotatedXYZ[2], failMesg, __LINE__);
127 
128  return testFramework.countFails();
129  }
130 
131  /* Second test case. SV at GPS orbit altitude at 0 deg N, 90 deg E
132  Heading due S at 4 km/sec
133  Resulting RAC matrix: [ 0 1 0]
134  [ 0 0 -1]
135  [ -1 0 0] */
136  int tripleSecondTest (void)
137  {
138  TestUtil testFramework( "RACRotation", "convertToRAC", __FILE__, __LINE__ );
139  std::string failMesg;
140 
141  double GPSAlt = 26000000;
142  Triple XYZ, rotatedXYZ;
143  Triple SVPos2( 0, GPSAlt, 0);
144  Triple SVVel2( 0, 0, -4000 );
145 
146  RACRotation rot2( SVPos2, SVVel2 );
147 
148  // OK, now give it an "error vector" that 1 m in each component
149  XYZ = Triple( 1.0, 1.0, 1.0);
150  rotatedXYZ = rot2.convertToRAC( XYZ );
151 
152  failMesg = "Was the X value rotated properly?";
153  testFramework.assert(1 == rotatedXYZ[0], failMesg, __LINE__);
154 
155  failMesg = "Was the Y value rotated properly?";
156  testFramework.assert(-1 == rotatedXYZ[1], failMesg, __LINE__);
157 
158  failMesg = "Was the Z value rotated properly?";
159  testFramework.assert(-1 == rotatedXYZ[2], failMesg, __LINE__);
160 
161  XYZ = Triple( -1.0, -1.0, -1.0);
162  rotatedXYZ = rot2.convertToRAC( XYZ );
163 
164  failMesg = "Was the X value rotated properly?";
165  testFramework.assert(-1 == rotatedXYZ[0], failMesg, __LINE__);
166 
167  failMesg = "Was the Y value rotated properly?";
168  testFramework.assert(1 == rotatedXYZ[1], failMesg, __LINE__);
169 
170  failMesg = "Was the Z value rotated properly?";
171  testFramework.assert(1 == rotatedXYZ[2], failMesg, __LINE__);
172 
173  XYZ = Triple( 0.0, 0.0, -1.0);
174  rotatedXYZ = rot2.convertToRAC( XYZ );
175 
176  failMesg = "Was the X value rotated properly?";
177  testFramework.assert(0 == rotatedXYZ[0], failMesg, __LINE__);
178 
179  failMesg = "Was the Y value rotated properly?";
180  testFramework.assert(1 == rotatedXYZ[1], failMesg, __LINE__);
181 
182  failMesg = "Was the Z value rotated properly?";
183  testFramework.assert(0 == rotatedXYZ[2], failMesg, __LINE__);
184 
185  XYZ = Triple( 0.0, -1.0, 0.0);
186  rotatedXYZ = rot2.convertToRAC( XYZ );
187 
188  failMesg = "Was the X value rotated properly?";
189  testFramework.assert(-1 == rotatedXYZ[0], failMesg, __LINE__);
190 
191  failMesg = "Was the Y value rotated properly?";
192  testFramework.assert(0 == rotatedXYZ[1], failMesg, __LINE__);
193 
194  failMesg = "Was the Z value rotated properly?";
195  testFramework.assert(0 == rotatedXYZ[2], failMesg, __LINE__);
196 
197  return testFramework.countFails();
198  }
199 
200  /* Third test case. SV at GPS orbit altitude at 90 deg N, X deg E
201  Heading parallel to the Y axis at 4 km/sec
202  Resulting RAC matrix: [ 0 0 1]
203  [ 0 1 0]
204  [ -1 0 0] */
205  int tripleThirdTest (void)
206  {
207  TestUtil testFramework( "RACRotation", "convertToRAC", __FILE__, __LINE__ );
208  std::string failMesg;
209 
210  double GPSAlt = 26000000;
211  Triple XYZ, rotatedXYZ;
212  Triple SVPos3( 0, 0, GPSAlt);
213  Triple SVVel3( 0, 4000, 0 );
214 
215  RACRotation rot3( SVPos3, SVVel3 );
216 
217  // OK, now give it an "error vector" that 1 m in each component
218  XYZ = Triple( 1.0, 1.0, 1.0);
219  rotatedXYZ = rot3.convertToRAC( XYZ );
220 
221  failMesg = "Was the X value rotated properly?";
222  testFramework.assert(1 == rotatedXYZ[0], failMesg, __LINE__);
223 
224  failMesg = "Was the Y value rotated properly?";
225  testFramework.assert(1 == rotatedXYZ[1], failMesg, __LINE__);
226 
227  failMesg = "Was the Z value rotated properly?";
228  testFramework.assert(-1 == rotatedXYZ[2], failMesg, __LINE__);
229 
230  XYZ = Triple( -1.0, -1.0, -1.0);
231  rotatedXYZ = rot3.convertToRAC( XYZ );
232 
233  failMesg = "Was the X value rotated properly?";
234  testFramework.assert(-1 == rotatedXYZ[0], failMesg, __LINE__);
235 
236  failMesg = "Was the Y value rotated properly?";
237  testFramework.assert(-1 == rotatedXYZ[1], failMesg, __LINE__);
238 
239  failMesg = "Was the Z value rotated properly?";
240  testFramework.assert(1 == rotatedXYZ[2], failMesg, __LINE__);
241 
242  XYZ = Triple( 0.0, 0.0, -1.0);
243  rotatedXYZ = rot3.convertToRAC( XYZ );
244 
245  failMesg = "Was the X value rotated properly?";
246  testFramework.assert(-1 == rotatedXYZ[0], failMesg, __LINE__);
247 
248  failMesg = "Was the Y value rotated properly?";
249  testFramework.assert(0 == rotatedXYZ[1], failMesg, __LINE__);
250 
251  failMesg = "Was the Z value rotated properly?";
252  testFramework.assert(0 == rotatedXYZ[2], failMesg, __LINE__);
253 
254  XYZ = Triple( 0.0, -1.0, 0.0);
255  rotatedXYZ = rot3.convertToRAC( XYZ );
256 
257  failMesg = "Was the X value rotated properly?";
258  testFramework.assert(0 == rotatedXYZ[0], failMesg, __LINE__);
259 
260  failMesg = "Was the Y value rotated properly?";
261  testFramework.assert(-1 == rotatedXYZ[1], failMesg, __LINE__);
262 
263  failMesg = "Was the Z value rotated properly?";
264  testFramework.assert(0 == rotatedXYZ[2], failMesg, __LINE__);
265 
266  return testFramework.countFails();
267  }
268 
269  /* Fourth test case. SV at GPS orbit altitude at 45 deg N, 45 deg E
270  Heading 4 km/sec to the NW.
271  Resulting RAC matrix: [ 1/2 1/2 1/sqrt(2) ]
272  [ -3/(2*sqrt(3)) 1/(2*sqrt(3)) sqrt(2)/(2*sqrt(3))]
273  [ 0 -sqrt(2)/sqrt(3) 1/sqrt(3) ] */
274  int tripleFourthTest (void)
275  {
276  TestUtil testFramework( "RACRotation", "convertToRAC", __FILE__, __LINE__ );
277  std::string failMesg;
278 
279  double GPSAlt = 26000000;
280  Triple XYZ, rotatedXYZ;
281  // Spherical: R = 26M m, phi = 45 deg N, theta = 45 deg E
282  // x = r sin phi cos theta
283  // y = r sin phi sin theta
284  // z = r cos phi
285  double thetaphi = 45.0 * ( PI / 180.0 );
286  double x4 = GPSAlt * sin(thetaphi) * cos(thetaphi);
287  double y4 = GPSAlt * sin(thetaphi) * sin(thetaphi);
288  double z4 = GPSAlt * cos(thetaphi);
289  Triple SVPos4( x4, y4, z4 );
290 
291  // Spherical: R = 4000 m/sec, phi = 45 deg E, theta = 135 deg E
292  // x = r sin phi cos theta
293  // y = r sin phi sin theta
294  // z = r cos phi
295  double theta = 135.0 * (PI/180.0);
296  double phi = 45.0 * (PI/180.0);
297  double xv4 = 4000 * sin(phi) * cos(theta);
298  double yv4 = 4000 * sin(phi) * sin(theta);
299  double zv4 = 4000 * cos(phi);
300  Triple SVVel4( xv4, yv4, zv4 );
301 
302  RACRotation rot4( SVPos4, SVVel4 );
303 
304  // OK, now give it an "error vector" that 1 m in each component
305  XYZ = Triple( 1.0, 1.0, 1.0);
306  rotatedXYZ = rot4.convertToRAC( XYZ );
307 
308  double x = 1.0 + 1.0/sqrt(2.0);
309  double y = (-2.0+sqrt(2.0))/(2.0*sqrt(3.0));
310  double z = (1.0 - sqrt(2.0))/sqrt(3.0);
311 
312  failMesg = "Was the X value rotated properly?";
313  testFramework.assert(fabs(x - rotatedXYZ[0]) < eps, failMesg, __LINE__);
314 
315  failMesg = "Was the Y value rotated properly?";
316  testFramework.assert(fabs(y - rotatedXYZ[1]) < eps, failMesg, __LINE__);
317 
318  failMesg = "Was the Z value rotated properly?";
319  testFramework.assert(fabs(z - rotatedXYZ[2]) < eps, failMesg, __LINE__);
320 
321  XYZ = Triple( -1.0, -1.0, -1.0);
322  rotatedXYZ = rot4.convertToRAC( XYZ );
323 
324  x = -1.0 - 1.0/sqrt(2.0);
325  y = -(-2.0+sqrt(2.0))/(2.0*sqrt(3.0));
326  z = -(1.0 - sqrt(2.0))/sqrt(3.0);
327 
328  failMesg = "Was the X value rotated properly?";
329  testFramework.assert(fabs(x - rotatedXYZ[0]) < eps, failMesg, __LINE__);
330 
331  failMesg = "Was the Y value rotated properly?";
332  testFramework.assert(fabs(y - rotatedXYZ[1]) < eps, failMesg, __LINE__);
333 
334  failMesg = "Was the Z value rotated properly?";
335  testFramework.assert(fabs(z - rotatedXYZ[2]) < eps, failMesg, __LINE__);
336 
337  XYZ = Triple( 0.0, 0.0, -1.0);
338  rotatedXYZ = rot4.convertToRAC( XYZ );
339 
340  x = -1.0/sqrt(2.0);
341  y = -sqrt(2.0)/(2.0*sqrt(3.0));
342  z = -1.0/sqrt(3.0);
343 
344  failMesg = "Was the X value rotated properly?";
345  testFramework.assert(fabs(x - rotatedXYZ[0]) < eps, failMesg, __LINE__);
346 
347  failMesg = "Was the Y value rotated properly?";
348  testFramework.assert(fabs(y - rotatedXYZ[1]) < eps, failMesg, __LINE__);
349 
350  failMesg = "Was the Z value rotated properly?";
351  testFramework.assert(fabs(z - rotatedXYZ[2]) < eps, failMesg, __LINE__);
352 
353  XYZ = Triple( 0.0, -1.0, 0.0);
354  rotatedXYZ = rot4.convertToRAC( XYZ );
355 
356  x = -0.5;
357  y = -1.0/(2.0*sqrt(3.0));
358  z = sqrt(2.0)/sqrt(3.0);
359 
360  failMesg = "Was the X value rotated properly?";
361  testFramework.assert(fabs(x - rotatedXYZ[0]) < eps, failMesg, __LINE__);
362 
363  failMesg = "Was the Y value rotated properly?";
364  testFramework.assert(fabs(y - rotatedXYZ[1]) < eps, failMesg, __LINE__);
365 
366  failMesg = "Was the Z value rotated properly?";
367  testFramework.assert(fabs(z - rotatedXYZ[2]) < eps, failMesg, __LINE__);
368 
369  return testFramework.countFails();
370  }
371 
372  /* Repeat first test case using the Xvt signatures of
373  the RACRotation class.
374  Resulting RAC matrix: [ 1 0 0]
375  [ 0 0 1]
376  [ 0 -1 0] */
377  int xvtTest (void)
378  {
379  TestUtil testFramework( "RACRotation", "convertToRAC", __FILE__, __LINE__ );
380  std::string failMesg;
381 
382  double GPSAlt = 26000000;
383  Triple XYZ, rotatedXYZ;
384  Xvt refPoint;
385  refPoint.x = Position( GPSAlt, 0, 0 );
386  refPoint.v = Triple( 0, 0, 4000 );
387  refPoint.clkbias = 0.0;
388  refPoint.clkdrift = 0.0;
389  refPoint.relcorr = 0.0;
390 
391  RACRotation rot5( refPoint );
392 
393  // OK, now set up unit vectors in radius and velocity to
394  // see if the results align properly.
395  Xvt testPoint;
396  testPoint.x = Position( 1.0, 0.0, 0.0 );
397  testPoint.v = Triple( 0.0, 0.0, 1.0 );
398  testPoint.clkbias = 0.0;
399  testPoint.clkdrift = 0.0;
400  testPoint.relcorr = 0.0;
401 
402  Xvt rotatedTestPoint = rot5.convertToRAC( testPoint );
403 
404  failMesg = "Were the position values stored properly?";
405  testFramework.assert(Position(1,0,0) == (gnsstk::Position)rotatedTestPoint.x, failMesg, __LINE__);
406 
407  failMesg = "Were the velocity values stored properly?";
408  testFramework.assert(Triple(0,1,0) == rotatedTestPoint.v, failMesg, __LINE__);
409 
410  failMesg = "Was the first velocity value stored properly?";
411  testFramework.assert(0 == rotatedTestPoint.v[0], failMesg, __LINE__);
412 
413  failMesg = "Was the second velocity value stored properly?";
414  testFramework.assert(1 == rotatedTestPoint.v[1], failMesg, __LINE__);
415 
416  failMesg = "Was the third velocity value stored properly?";
417  testFramework.assert(0 == rotatedTestPoint.v[2], failMesg, __LINE__);
418 
419  failMesg = "Was the clock bias value stored properly?";
420  testFramework.assert(0.0 == rotatedTestPoint.clkbias, failMesg, __LINE__);
421 
422  failMesg = "Was the clock drift value stored properly?";
423  testFramework.assert(0.0 == rotatedTestPoint.clkdrift, failMesg, __LINE__);
424 
425  failMesg = "Was the relativity correction value stored properly?";
426  testFramework.assert(0.0 == rotatedTestPoint.relcorr, failMesg, __LINE__);
427 
428  // Using more comlpex test vectors.
429  testPoint.x = Position( 0.0, 0.5, -0.5);
430  testPoint.v = Triple( 1.0, -1.0, 1.0);
431  testPoint.clkbias = 0.0;
432  testPoint.clkdrift = 0.0;
433  testPoint.relcorr = 0.0;
434 
435  rotatedTestPoint = rot5.convertToRAC( testPoint );
436 
437  failMesg = "Were the position values stored properly?";
438  testFramework.assert(Position(0, -0.5, -0.5) == (gnsstk::Position)rotatedTestPoint.x, failMesg, __LINE__);
439 
440  failMesg = "Were the velocity values stored properly?";
441  testFramework.assert(Triple(1.0, 1.0, 1.0) == rotatedTestPoint.v, failMesg, __LINE__);
442 
443  failMesg = "Was the first velocity value stored properly?";
444  testFramework.assert(1 == rotatedTestPoint.v[0], failMesg, __LINE__);
445 
446  failMesg = "Was the second velocity value stored properly?";
447  testFramework.assert(1 == rotatedTestPoint.v[1], failMesg, __LINE__);
448 
449  failMesg = "Was the third velocity value stored properly?";
450  testFramework.assert(1 == rotatedTestPoint.v[2], failMesg, __LINE__);
451 
452  failMesg = "Was the clock bias value stored properly?";
453  testFramework.assert(0.0 == rotatedTestPoint.clkbias, failMesg, __LINE__);
454 
455  failMesg = "Was the clock drift value stored properly?";
456  testFramework.assert(0.0 == rotatedTestPoint.clkdrift, failMesg, __LINE__);
457 
458  failMesg = "Was the relativity correction value stored properly?";
459  testFramework.assert(0.0 == rotatedTestPoint.relcorr, failMesg, __LINE__);
460 
461  // The conversions should still accept any Triples
462  XYZ = Triple( 1.0, 1.0, -1.0);
463  rotatedXYZ = rot5.convertToRAC( XYZ );
464 
465  failMesg = "Was the Triple converted properly?";
466  testFramework.assert(Triple(1,-1,-1) == rotatedXYZ, failMesg, __LINE__);
467 
468  failMesg = "Was the x value rotated properly?";
469  testFramework.assert(1 == rotatedXYZ[0], failMesg, __LINE__);
470 
471  failMesg = "Was the y value rotated properly?";
472  testFramework.assert(-1 == rotatedXYZ[1], failMesg, __LINE__);
473 
474  failMesg = "Was the z correction value rotated properly?";
475  testFramework.assert(-1 == rotatedXYZ[2], failMesg, __LINE__);
476 
477  return testFramework.countFails();
478  }
479  private:
480  double eps;
481 };
482 
483 int main() //Main function to initialize and run all tests above
484 {
485  int check, errorCounter = 0;
486  RACRotation_T testClass;
487 
488  check = testClass.tripleFirstTest();
489  errorCounter += check;
490 
491  check = testClass.tripleSecondTest();
492  errorCounter += check;
493 
494  check = testClass.tripleThirdTest();
495  errorCounter += check;
496 
497  check = testClass.tripleFourthTest();
498  errorCounter += check;
499 
500  check = testClass.xvtTest();
501  errorCounter += check;
502 
503  std::cout << "Total Failures for " << __FILE__ << ": " << errorCounter << std::endl;
504 
505  return errorCounter; //Return the total number of errors
506 }
RACRotation_T::~RACRotation_T
~RACRotation_T()
Definition: RACRotation_T.cpp:57
gnsstk::TestUtil::countFails
int countFails(void)
Definition: TestUtil.hpp:771
gnsstk::TestUtil::assert
void assert(bool testExpression, const std::string &testMsg, const int lineNumber)
Definition: TestUtil.hpp:607
Xvt.hpp
RACRotation_T::tripleSecondTest
int tripleSecondTest(void)
Definition: RACRotation_T.cpp:136
GPS_URA.hpp
RACRotation_T::RACRotation_T
RACRotation_T()
Definition: RACRotation_T.cpp:56
Position.hpp
gnsstk::PI
const double PI
GPS value of PI; also specified by GAL.
Definition: GNSSconstants.hpp:62
gnsstk::Xvt::v
Triple v
satellite velocity in ECEF Cartesian, meters/second
Definition: Xvt.hpp:152
GNSSconstants.hpp
RACRotation_T::eps
double eps
Definition: RACRotation_T.cpp:480
gnsstk::Triple
Definition: Triple.hpp:68
gnsstk
For Sinex::InputHistory.
Definition: BasicFramework.cpp:50
gnsstk::RACRotation::convertToRAC
gnsstk::Vector< double > convertToRAC(const gnsstk::Vector< double > &inV)
Definition: RACRotation.cpp:99
std::sin
double sin(gnsstk::Angle x)
Definition: Angle.hpp:144
gnsstk::Xvt::relcorr
double relcorr
relativity correction (standard 2R.V/c^2 term), seconds
Definition: Xvt.hpp:155
gnsstk::Xvt::x
Triple x
Sat position ECEF Cartesian (X,Y,Z) meters.
Definition: Xvt.hpp:151
TestUtil.hpp
y
page HOWTO subpage DoxygenGuide Documenting Your Code page DoxygenGuide Documenting Your Code todo Flesh out this document section doctips Tips for Documenting When defining make sure that the prototype is identical between the cpp and hpp including both the namespaces and the parameter names for you have std::string as the return type in the hpp file and string as the return type in the cpp Doxygen may get confused and autolink to the cpp version with no documentation If you don t use the same parameter names between the cpp and hpp that will also confuse Doxygen Don t put type information in return or param documentation It doesn t really add anything and will often cause Doxygen to complain and not produce the documentation< br > use note Do not put a comma after a param name unless you mean to document multiple parameters< br/> the output stream</code >< br/> y
Definition: DOCUMENTING.dox:15
RACRotation_T::xvtTest
int xvtTest(void)
Definition: RACRotation_T.cpp:377
RACRotation_T::tripleFourthTest
int tripleFourthTest(void)
Definition: RACRotation_T.cpp:274
RACRotation.hpp
gnsstk::Xvt::clkdrift
double clkdrift
satellite clock drift in seconds/second
Definition: Xvt.hpp:154
gnsstk::Xvt
Definition: Xvt.hpp:60
std::cos
double cos(gnsstk::Angle x)
Definition: Angle.hpp:146
std
Definition: Angle.hpp:142
main
int main()
Definition: RACRotation_T.cpp:483
Triple.hpp
gnsstk::Position
Definition: Position.hpp:136
gnsstk::RACRotation
Definition: RACRotation.hpp:55
gnsstk::Xvt::clkbias
double clkbias
Sat clock correction in seconds.
Definition: Xvt.hpp:153
RACRotation_T::tripleFirstTest
int tripleFirstTest(void)
Definition: RACRotation_T.cpp:64
gnsstk::TestUtil
Definition: TestUtil.hpp:265
RACRotation_T
Definition: RACRotation_T.cpp:53
RACRotation_T::tripleThirdTest
int tripleThirdTest(void)
Definition: RACRotation_T.cpp:205

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