gtsam
Loading...
Searching...
No Matches
CarrierPhaseFactor.h
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2
3 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
4 * Atlanta, Georgia 30332-0415
5 * All Rights Reserved
6 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
7
8 * See LICENSE for the license information
9
10 * -------------------------------------------------------------------------- */
11
17#pragma once
18
19#include <gtsam/geometry/Point3.h>
20#include <gtsam/geometry/Pose3.h>
21#include <gtsam/navigation/GnssCommon.h>
22#include <gtsam/nonlinear/NoiseModelFactorN.h>
23#include <gtsam/nonlinear/NonlinearFactor.h>
24
25#include <optional>
26#include <string>
27
28namespace gtsam {
29
40using CarrierPhaseBase = GnssMeasurementBase;
41
57class GTSAM_EXPORT CarrierPhaseFactor
58 : public NoiseModelFactorT<Vector1, Point3, double, double>,
59 private CarrierPhaseBase {
60 private:
61 typedef NoiseModelFactorT<Vector1, Point3, double, double> Base;
62
63 public:
64 using Base::evaluateError;
65
66 typedef std::shared_ptr<CarrierPhaseFactor> shared_ptr;
67 typedef CarrierPhaseFactor This;
68
70 CarrierPhaseFactor()
71 : CarrierPhaseBase{0.0, Point3(0, 0, 0), 0.0} {}
72
73 virtual ~CarrierPhaseFactor() = default;
74
86 CarrierPhaseFactor(
87 Key receiverPositionKey, Key receiverClockBiasKey, Key ambiguityKey,
88 double measuredCarrierPhaseMeters, const Point3& satellitePosition,
89 double satelliteClockBias = 0.0,
90 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
91
93 gtsam::NonlinearFactor::shared_ptr clone() const override {
94 return std::static_pointer_cast<gtsam::NonlinearFactor>(
95 gtsam::NonlinearFactor::shared_ptr(new This(*this)));
96 }
97
99 void print(const std::string& s = "", const KeyFormatter& keyFormatter =
100 DefaultKeyFormatter) const override;
101
103 bool equals(const NonlinearFactor& expected,
104 double tol = 1e-9) const override;
105
107 Vector1 evaluateError(const Point3& receiverPosition,
108 const double& receiverClockBias,
109 const double& ambiguity,
110 OptionalMatrixType HreceiverPos,
111 OptionalMatrixType HreceiverClockBias,
112 OptionalMatrixType Hambiguity) const override;
113
114 private:
115#if GTSAM_ENABLE_BOOST_SERIALIZATION
116 friend class boost::serialization::access;
117 template <class ARCHIVE>
118 void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
119 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
120 ar& BOOST_SERIALIZATION_NVP(measurement_);
121 ar& BOOST_SERIALIZATION_NVP(satPos_);
122 ar& BOOST_SERIALIZATION_NVP(satClkBias_);
123 }
124#endif
125};
126
128template <>
129struct traits<CarrierPhaseFactor> : public Testable<CarrierPhaseFactor> {};
130
158class GTSAM_EXPORT UndifferencedCarrierPhaseFactor
159 : public NoiseModelFactorN<Point3, double, double, double, double>,
160 private CarrierPhaseBase {
161 private:
162 typedef NoiseModelFactorN<Point3, double, double, double, double> Base;
163 double tropoMap_ = 0.0;
164 double ionoCoeff_ = 1.0;
165 double lambda_ = 1.0;
166
167 public:
168 using Base::evaluateError;
169 typedef std::shared_ptr<UndifferencedCarrierPhaseFactor> shared_ptr;
170 typedef UndifferencedCarrierPhaseFactor This;
171
172 UndifferencedCarrierPhaseFactor() : CarrierPhaseBase{0.0, Point3(0, 0, 0), 0.0} {}
173 virtual ~UndifferencedCarrierPhaseFactor() = default;
174
189 UndifferencedCarrierPhaseFactor(
190 Key receiverPositionKey, Key receiverClockBiasKey, Key tropoZenithWetKey,
191 Key slantIonoKey, Key ambiguityKey, double measuredCarrierPhaseMeters,
192 const Point3& satellitePosition, double tropoWetMapping,
193 double ionoCoefficient, double lambda_, double satelliteClockBias = 0.0,
194 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
195
196 gtsam::NonlinearFactor::shared_ptr clone() const override {
197 return std::static_pointer_cast<gtsam::NonlinearFactor>(
198 gtsam::NonlinearFactor::shared_ptr(new This(*this)));
199 }
200
201 void print(const std::string& s = "", const KeyFormatter& keyFormatter =
202 DefaultKeyFormatter) const override;
203 bool equals(const NonlinearFactor& expected,
204 double tol = 1e-9) const override;
205
206 Vector evaluateError(const Point3& receiverPosition,
207 const double& receiverClockBias,
208 const double& tropoZenithWet, const double& slantIono,
209 const double& ambiguity, OptionalMatrixType HreceiverPos,
210 OptionalMatrixType HreceiverClockBias,
211 OptionalMatrixType HtropoZenithWet,
212 OptionalMatrixType HslantIono,
213 OptionalMatrixType Hambiguity) const override;
214
215 inline double tropoMapping() const { return tropoMap_; }
216 inline double ionoCoefficient() const { return ionoCoeff_; }
217 inline double wavelength() const { return lambda_; }
218
219 private:
220#if GTSAM_ENABLE_BOOST_SERIALIZATION
221 friend class boost::serialization::access;
222 template <class ARCHIVE>
223 void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
224 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
225 ar& BOOST_SERIALIZATION_NVP(measurement_);
226 ar& BOOST_SERIALIZATION_NVP(satPos_);
227 ar& BOOST_SERIALIZATION_NVP(satClkBias_);
228 ar& BOOST_SERIALIZATION_NVP(tropoMap_);
229 ar& BOOST_SERIALIZATION_NVP(ionoCoeff_);
230 ar& BOOST_SERIALIZATION_NVP(lambda_);
231 }
232#endif
233};
234
236template <>
237struct traits<UndifferencedCarrierPhaseFactor>
238 : public Testable<UndifferencedCarrierPhaseFactor> {};
239
249class GTSAM_EXPORT UndifferencedCarrierPhaseFactorArm
250 : public NoiseModelFactorN<Pose3, double, double, double, double>,
251 private CarrierPhaseBase {
252 private:
253 typedef NoiseModelFactorN<Pose3, double, double, double, double> Base;
254 gnss::LeverArm arm_;
255 double tropoMap_ = 0.0;
256 double ionoCoeff_ = 1.0;
257 double lambda_ = 1.0;
258
259 public:
260 using Base::evaluateError;
261 typedef std::shared_ptr<UndifferencedCarrierPhaseFactorArm> shared_ptr;
262 typedef UndifferencedCarrierPhaseFactorArm This;
263
264 UndifferencedCarrierPhaseFactorArm()
265 : CarrierPhaseBase{0.0, Point3(0, 0, 0), 0.0} {}
266 virtual ~UndifferencedCarrierPhaseFactorArm() = default;
267
269 UndifferencedCarrierPhaseFactorArm(
270 Key poseKey, Key receiverClockBiasKey, Key tropoZenithWetKey,
271 Key slantIonoKey, Key ambiguityKey, double measuredCarrierPhaseMeters,
272 const Point3& satellitePosition, const Point3& leverArm,
273 double tropoWetMapping, double ionoCoefficient, double lambda_,
274 double satelliteClockBias = 0.0,
275 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
276
278 UndifferencedCarrierPhaseFactorArm(
279 Key poseKey, Key receiverClockBiasKey, Key tropoZenithWetKey,
280 Key slantIonoKey, Key ambiguityKey, double measuredCarrierPhaseMeters,
281 const Point3& satellitePosition, const Point3& leverArm,
282 const Pose3& ecef_T_nav, double tropoWetMapping, double ionoCoefficient,
283 double lambda_, double satelliteClockBias = 0.0,
284 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
285
286 gtsam::NonlinearFactor::shared_ptr clone() const override {
287 return std::static_pointer_cast<gtsam::NonlinearFactor>(
288 gtsam::NonlinearFactor::shared_ptr(new This(*this)));
289 }
290
291 void print(const std::string& s = "", const KeyFormatter& keyFormatter =
292 DefaultKeyFormatter) const override;
293 bool equals(const NonlinearFactor& expected,
294 double tol = 1e-9) const override;
295
296 Vector evaluateError(const Pose3& pose, const double& receiverClockBias,
297 const double& tropoZenithWet, const double& slantIono,
298 const double& ambiguity, OptionalMatrixType H_pose,
299 OptionalMatrixType HreceiverClockBias,
300 OptionalMatrixType HtropoZenithWet,
301 OptionalMatrixType HslantIono,
302 OptionalMatrixType Hambiguity) const override;
303
304 inline const Point3& leverArm() const { return arm_.b; }
305 inline const std::optional<Pose3>& ecefTnav() const { return arm_.ecef_T_nav; }
306 inline double tropoMapping() const { return tropoMap_; }
307 inline double ionoCoefficient() const { return ionoCoeff_; }
308 inline double wavelength() const { return lambda_; }
309
310 private:
311#if GTSAM_ENABLE_BOOST_SERIALIZATION
312 friend class boost::serialization::access;
313 template <class ARCHIVE>
314 void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
315 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
316 ar& BOOST_SERIALIZATION_NVP(measurement_);
317 ar& BOOST_SERIALIZATION_NVP(satPos_);
318 ar& BOOST_SERIALIZATION_NVP(satClkBias_);
319 ar& boost::serialization::make_nvp("bL_", arm_.b);
320 ar& boost::serialization::make_nvp("ecef_T_nav_", arm_.ecef_T_nav);
321 ar& BOOST_SERIALIZATION_NVP(tropoMap_);
322 ar& BOOST_SERIALIZATION_NVP(ionoCoeff_);
323 ar& BOOST_SERIALIZATION_NVP(lambda_);
324 }
325#endif
326};
327
329template <>
330struct traits<UndifferencedCarrierPhaseFactorArm>
331 : public Testable<UndifferencedCarrierPhaseFactorArm> {};
332
351class GTSAM_EXPORT CarrierPhaseFactorArm
352 : public NoiseModelFactorT<Vector1, Pose3, double, double>,
353 private CarrierPhaseBase {
354 private:
355 typedef NoiseModelFactorT<Vector1, Pose3, double, double> Base;
356
357 gnss::LeverArm arm_;
358
359 public:
360 using Base::evaluateError;
361
362 typedef std::shared_ptr<CarrierPhaseFactorArm> shared_ptr;
363 typedef CarrierPhaseFactorArm This;
364
366 CarrierPhaseFactorArm() : CarrierPhaseBase{0.0, Point3(0, 0, 0), 0.0} {}
367
368 virtual ~CarrierPhaseFactorArm() = default;
369
373 CarrierPhaseFactorArm(
374 Key poseKey, Key receiverClockBiasKey, Key ambiguityKey,
375 double measuredCarrierPhaseMeters, const Point3& satellitePosition,
376 const Point3& leverArm, double satelliteClockBias = 0.0,
377 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
378
382 CarrierPhaseFactorArm(
383 Key poseKey, Key receiverClockBiasKey, Key ambiguityKey,
384 double measuredCarrierPhaseMeters, const Point3& satellitePosition,
385 const Point3& leverArm, const Pose3& ecef_T_nav,
386 double satelliteClockBias = 0.0,
387 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
388
390 gtsam::NonlinearFactor::shared_ptr clone() const override {
391 return std::static_pointer_cast<gtsam::NonlinearFactor>(
392 gtsam::NonlinearFactor::shared_ptr(new This(*this)));
393 }
394
396 void print(const std::string& s = "", const KeyFormatter& keyFormatter =
397 DefaultKeyFormatter) const override;
398
400 bool equals(const NonlinearFactor& expected,
401 double tol = 1e-9) const override;
402
404 Vector1 evaluateError(const Pose3& pose,
405 const double& receiverClockBias,
406 const double& ambiguity,
407 OptionalMatrixType H_pose,
408 OptionalMatrixType HreceiverClockBias,
409 OptionalMatrixType Hambiguity) const override;
410
412 inline const Point3& leverArm() const { return arm_.b; }
413
415 inline const std::optional<Pose3>& ecefTnav() const { return arm_.ecef_T_nav; }
416
417 private:
418#if GTSAM_ENABLE_BOOST_SERIALIZATION
419 friend class boost::serialization::access;
420 template <class ARCHIVE>
421 void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
422 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
423 ar& BOOST_SERIALIZATION_NVP(measurement_);
424 ar& BOOST_SERIALIZATION_NVP(satPos_);
425 ar& BOOST_SERIALIZATION_NVP(satClkBias_);
426 ar& boost::serialization::make_nvp("bL_", arm_.b);
427 ar& boost::serialization::make_nvp("ecef_T_nav_", arm_.ecef_T_nav);
428 }
429#endif
430};
431
433template <>
434struct traits<CarrierPhaseFactorArm>
435 : public Testable<CarrierPhaseFactorArm> {};
436
468class GTSAM_EXPORT DoubleDifferenceCarrierPhaseFactor
469 : public NoiseModelFactorT<Vector1, Point3, double, double> {
470 private:
471 typedef NoiseModelFactorT<Vector1, Point3, double, double> Base;
472
473 gnss::DoubleDifferenceData dd_;
474 double lam_ = 0;
475
476 public:
477 // Expose the convenience evaluateError overloads from NoiseModelFactorN
478 // (e.g. the no-Jacobian and Matrix& variants used in tests).
479 using Base::evaluateError;
480 typedef std::shared_ptr<DoubleDifferenceCarrierPhaseFactor> shared_ptr;
481 typedef DoubleDifferenceCarrierPhaseFactor This;
482
483 DoubleDifferenceCarrierPhaseFactor() = default;
484
485 virtual ~DoubleDifferenceCarrierPhaseFactor() = default;
486
487 DoubleDifferenceCarrierPhaseFactor(
488 Key positionKey, Key ambRefKey, Key ambTargetKey,
489 double cpRovRefMeters, double cpBaseRefMeters,
490 double cpRovTargetMeters, double cpBaseTargetMeters,
491 const Point3& satRefRov, const Point3& satTargetRov,
492 const Point3& satRefBase, const Point3& satTargetBase,
493 const Point3& basePos, double lam,
494 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
495
496 gtsam::NonlinearFactor::shared_ptr clone() const override {
497 return std::static_pointer_cast<gtsam::NonlinearFactor>(
498 gtsam::NonlinearFactor::shared_ptr(new This(*this)));
499 }
500
501 void print(const std::string& s = "", const KeyFormatter& keyFormatter =
502 DefaultKeyFormatter) const override;
503
504 bool equals(const NonlinearFactor& expected,
505 double tol = 1e-9) const override;
506
507 Vector1 evaluateError(const Point3& pos, const double& ambRef,
508 const double& ambTarget, OptionalMatrixType Hpos,
509 OptionalMatrixType HambRef,
510 OptionalMatrixType HambTarget) const override;
511
512 private:
513#if GTSAM_ENABLE_BOOST_SERIALIZATION
514 friend class boost::serialization::access;
515 template <class ARCHIVE>
516 void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
517 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
518 ar& boost::serialization::make_nvp("cpRovRef_", dd_.rovRef);
519 ar& boost::serialization::make_nvp("cpBaseRef_", dd_.baseRef);
520 ar& boost::serialization::make_nvp("cpRovTarget_", dd_.rovTarget);
521 ar& boost::serialization::make_nvp("cpBaseTarget_", dd_.baseTarget);
522 ar& boost::serialization::make_nvp("satRefRov_", dd_.satRefRov);
523 ar& boost::serialization::make_nvp("satTargetRov_", dd_.satTargetRov);
524 ar& boost::serialization::make_nvp("satRefBase_", dd_.satRefBase);
525 ar& boost::serialization::make_nvp("satTargetBase_", dd_.satTargetBase);
526 ar& boost::serialization::make_nvp("basePos_", dd_.basePos);
527 ar& BOOST_SERIALIZATION_NVP(lam_);
528 }
529#endif
530};
531
532template <>
533struct traits<DoubleDifferenceCarrierPhaseFactor>
534 : public Testable<DoubleDifferenceCarrierPhaseFactor> {};
535
544class GTSAM_EXPORT DoubleDifferenceCarrierPhaseFactorArm
545 : public NoiseModelFactorT<Vector1, Pose3, double, double> {
546 private:
547 typedef NoiseModelFactorT<Vector1, Pose3, double, double> Base;
548
549 gnss::DoubleDifferenceData dd_;
550 double lam_ = 0;
551 gnss::LeverArm arm_;
552
553 public:
554 // Expose the convenience evaluateError overloads from NoiseModelFactorN
555 // (e.g. the no-Jacobian and Matrix& variants used in tests).
556 using Base::evaluateError;
557 typedef std::shared_ptr<DoubleDifferenceCarrierPhaseFactorArm> shared_ptr;
558 typedef DoubleDifferenceCarrierPhaseFactorArm This;
559
560 DoubleDifferenceCarrierPhaseFactorArm() = default;
561
562 virtual ~DoubleDifferenceCarrierPhaseFactorArm() = default;
563
564 DoubleDifferenceCarrierPhaseFactorArm(
565 Key poseKey, Key ambRefKey, Key ambTargetKey,
566 double cpRovRefMeters, double cpBaseRefMeters,
567 double cpRovTargetMeters, double cpBaseTargetMeters,
568 const Point3& satRefRov, const Point3& satTargetRov,
569 const Point3& satRefBase, const Point3& satTargetBase,
570 const Point3& basePos, double lam,
571 const Point3& leverArm,
572 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
573
574 DoubleDifferenceCarrierPhaseFactorArm(
575 Key poseKey, Key ambRefKey, Key ambTargetKey,
576 double cpRovRefMeters, double cpBaseRefMeters,
577 double cpRovTargetMeters, double cpBaseTargetMeters,
578 const Point3& satRefRov, const Point3& satTargetRov,
579 const Point3& satRefBase, const Point3& satTargetBase,
580 const Point3& basePos, double lam,
581 const Point3& leverArm, const Pose3& ecef_T_nav,
582 const SharedNoiseModel& model = noiseModel::Unit::Create(1));
583
584 gtsam::NonlinearFactor::shared_ptr clone() const override {
585 return std::static_pointer_cast<gtsam::NonlinearFactor>(
586 gtsam::NonlinearFactor::shared_ptr(new This(*this)));
587 }
588
589 void print(const std::string& s = "", const KeyFormatter& keyFormatter =
590 DefaultKeyFormatter) const override;
591
592 bool equals(const NonlinearFactor& expected,
593 double tol = 1e-9) const override;
594
595 Vector1 evaluateError(const Pose3& pose, const double& ambRef,
596 const double& ambTarget, OptionalMatrixType H_pose,
597 OptionalMatrixType HambRef,
598 OptionalMatrixType HambTarget) const override;
599
600 inline const Point3& leverArm() const { return arm_.b; }
601 inline const std::optional<Pose3>& ecefTnav() const { return arm_.ecef_T_nav; }
602
603 private:
604#if GTSAM_ENABLE_BOOST_SERIALIZATION
605 friend class boost::serialization::access;
606 template <class ARCHIVE>
607 void serialize(ARCHIVE& ar, const unsigned int /*version*/) {
608 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
609 ar& boost::serialization::make_nvp("cpRovRef_", dd_.rovRef);
610 ar& boost::serialization::make_nvp("cpBaseRef_", dd_.baseRef);
611 ar& boost::serialization::make_nvp("cpRovTarget_", dd_.rovTarget);
612 ar& boost::serialization::make_nvp("cpBaseTarget_", dd_.baseTarget);
613 ar& boost::serialization::make_nvp("satRefRov_", dd_.satRefRov);
614 ar& boost::serialization::make_nvp("satTargetRov_", dd_.satTargetRov);
615 ar& boost::serialization::make_nvp("satRefBase_", dd_.satRefBase);
616 ar& boost::serialization::make_nvp("satTargetBase_", dd_.satTargetBase);
617 ar& boost::serialization::make_nvp("basePos_", dd_.basePos);
618 ar& BOOST_SERIALIZATION_NVP(lam_);
619 ar& boost::serialization::make_nvp("bL_", arm_.b);
620 ar& boost::serialization::make_nvp("ecef_T_nav_", arm_.ecef_T_nav);
621 }
622#endif
623};
624
625template <>
626struct traits<DoubleDifferenceCarrierPhaseFactorArm>
627 : public Testable<DoubleDifferenceCarrierPhaseFactorArm> {};
628
629} // namespace gtsam
Point3.h
3D Point
Pose3.h
3D Pose manifold SO(3) x R^3 and group SE(3)
GnssCommon.h
Shared constants and utilities for GNSS factors.
NoiseModelFactorN.h
Base class for noise model factors with N variables.
NonlinearFactor.h
Non-linear factor base classes.
gtsam
Global functions in a separate testing namespace.
Definition chartTesting.h:28
gtsam::DefaultKeyFormatter
KeyFormatter DefaultKeyFormatter
Assign default key formatter.
Definition Key.cpp:30
gtsam::CarrierPhaseBase
GnssMeasurementBase CarrierPhaseBase
Base class storing common members for carrier phase factors.
Definition CarrierPhaseFactor.h:40
gtsam::OptionalMatrixType
Matrix * OptionalMatrixType
This typedef will be used everywhere boost::optional<Matrix&> reference was used previously.
Definition NonlinearFactor.h:57
gtsam::NoiseModelFactorN
NoiseModelFactorT< Vector, ValueTypes... > NoiseModelFactorN
Noise model factor with N value types and dynamic-sized error vector.
Definition NoiseModelFactorN.h:561
gtsam::Point3
Vector3 Point3
As of GTSAM 4, in order to make GTSAM more lean, it is now possible to just typedef Point3 to Vector3...
Definition Point3.h:38
gtsam::print
void print(const Matrix &A, const string &s, ostream &stream)
print without optional string, must specify cout yourself
Definition Matrix.cpp:143
gtsam::KeyFormatter
std::function< std::string(Key)> KeyFormatter
Typedef for a function to format a key, i.e. to convert it to a string.
Definition Key.h:35
gtsam::SharedNoiseModel
noiseModel::Base::shared_ptr SharedNoiseModel
Aliases.
Definition NoiseModel.h:846
gtsam::Key
std::uint64_t Key
Integer nonlinear key type.
Definition types.h:43
gtsam::traits
A manifold defines a space in which there is a notion of a linear tangent space that can be centered ...
Definition Group.h:37
gtsam::equals
Template to create a binary predicate.
Definition Testable.h:112
gtsam::Testable
A helper that implements the traits interface for GTSAM types.
Definition Testable.h:152
gtsam::Pose3
A 3D pose (R,t) : (Rot3,Point3).
Definition Pose3.h:42
gtsam::noiseModel::Unit::Create
static shared_ptr Create(size_t dim)
Create a unit covariance noise model.
Definition NoiseModel.h:673
gtsam::CarrierPhaseFactor
Undifferenced GNSS carrier phase factor for point positioning.
Definition CarrierPhaseFactor.h:59
gtsam::CarrierPhaseFactor::CarrierPhaseFactor
CarrierPhaseFactor()
default constructor - only use for serialization
Definition CarrierPhaseFactor.h:70
gtsam::CarrierPhaseFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Definition CarrierPhaseFactor.h:93
gtsam::UndifferencedCarrierPhaseFactor
Undifferenced (raw) PPP carrier phase factor.
Definition CarrierPhaseFactor.h:160
gtsam::UndifferencedCarrierPhaseFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition CarrierPhaseFactor.h:196
gtsam::UndifferencedCarrierPhaseFactorArm
Undifferenced (raw) PPP carrier phase factor with lever-arm correction.
Definition CarrierPhaseFactor.h:251
gtsam::UndifferencedCarrierPhaseFactorArm::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition CarrierPhaseFactor.h:286
gtsam::CarrierPhaseFactorArm
Carrier phase factor with lever arm correction.
Definition CarrierPhaseFactor.h:353
gtsam::CarrierPhaseFactorArm::ecefTnav
const std::optional< Pose3 > & ecefTnav() const
return the optional ecef_T_nav transform
Definition CarrierPhaseFactor.h:415
gtsam::CarrierPhaseFactorArm::leverArm
const Point3 & leverArm() const
return the lever arm
Definition CarrierPhaseFactor.h:412
gtsam::CarrierPhaseFactorArm::CarrierPhaseFactorArm
CarrierPhaseFactorArm()
default constructor - only use for serialization
Definition CarrierPhaseFactor.h:366
gtsam::CarrierPhaseFactorArm::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Definition CarrierPhaseFactor.h:390
gtsam::DoubleDifferenceCarrierPhaseFactor
Double-difference carrier phase factor.
Definition CarrierPhaseFactor.h:469
gtsam::DoubleDifferenceCarrierPhaseFactor::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition CarrierPhaseFactor.h:496
gtsam::DoubleDifferenceCarrierPhaseFactorArm
Double-difference carrier phase factor with lever arm correction.
Definition CarrierPhaseFactor.h:545
gtsam::DoubleDifferenceCarrierPhaseFactorArm::clone
gtsam::NonlinearFactor::shared_ptr clone() const override
Creates a shared_ptr clone of the factor - needs to be specialized to allow for subclasses.
Definition CarrierPhaseFactor.h:584
gtsam::GnssMeasurementBase
Base class storing common members for GNSS measurement factors.
Definition GnssCommon.h:25
gtsam::gnss::DoubleDifferenceData
Shared geometry data for double-difference factors.
Definition GnssCommon.h:74
gtsam::gnss::DoubleDifferenceData::satRefRov
Point3 satRefRov
Ref satellite ECEF at rover time [m].
Definition GnssCommon.h:79
gtsam::gnss::DoubleDifferenceData::satRefBase
Point3 satRefBase
Ref satellite ECEF at base time [m].
Definition GnssCommon.h:81
gtsam::gnss::DoubleDifferenceData::satTargetBase
Point3 satTargetBase
Target satellite ECEF at base time [m].
Definition GnssCommon.h:82
gtsam::gnss::DoubleDifferenceData::baseRef
double baseRef
Base observation for ref satellite [m].
Definition GnssCommon.h:76
gtsam::gnss::DoubleDifferenceData::basePos
Point3 basePos
Base station ECEF position [m].
Definition GnssCommon.h:83
gtsam::gnss::DoubleDifferenceData::satTargetRov
Point3 satTargetRov
Target satellite ECEF at rover time [m].
Definition GnssCommon.h:80
gtsam::gnss::DoubleDifferenceData::baseTarget
double baseTarget
Base observation for target satellite [m].
Definition GnssCommon.h:78
gtsam::gnss::DoubleDifferenceData::rovTarget
double rovTarget
Rover observation for target satellite [m].
Definition GnssCommon.h:77
gtsam::gnss::DoubleDifferenceData::rovRef
double rovRef
Rover observation for ref satellite [m].
Definition GnssCommon.h:75
gtsam::gnss::LeverArm
Lever-arm helper for GNSS factors that key on a body Pose3.
Definition GnssCommon.h:119
gtsam::gnss::LeverArm::b
Point3 b
Lever arm in body frame [m].
Definition GnssCommon.h:120
gtsam::gnss::LeverArm::ecef_T_nav
std::optional< Pose3 > ecef_T_nav
Optional ECEF-from-nav transform.
Definition GnssCommon.h:121
gtsam::NoiseModelFactorT< Vector1, Point3, double, double >::NoiseModelFactorT
NoiseModelFactorT()
Definition NoiseModelFactorN.h:257
gtsam::NoiseModelFactorT< Vector1, Point3, double, double >::evaluateError
virtual Vector1 evaluateError(const ValueTypes &... x, OptionalMatrixTypeT< ValueTypes >... H) const=0
gtsam::NonlinearFactor
Nonlinear factor base class.
Definition NonlinearFactor.h:70