Object/Developer/_bundle_target_body_8h_source.html

#ifndef BundleTargetBody_h

#define BundleTargetBody_h


/* SPDX-License-Identifier: CC0-1.0 */


#include <set>


#include <QSharedPointer>

#include <QStringList>


#include <boost/numeric/ublas/vector.hpp>


#include "Angle.h"

#include "Distance.h"

#include "Latitude.h"

#include "LinearAlgebra.h"

#include "Longitude.h"


namespace Isis {


  class BundleSettings;

  class PvlObject;

  class Target;


  class BundleTargetBody {


    public:

      // constructors

      BundleTargetBody();                            // default

      BundleTargetBody(Target *target);

      BundleTargetBody(const BundleTargetBody &src); // copy

      virtual ~BundleTargetBody();


      BundleTargetBody &operator=(const BundleTargetBody &src);


      enum TargetRadiiSolveMethod {

        None = 0,

        Mean = 1,

        All  = 2

      };


      enum TargetSolveCodes { PoleRA              = 0,

                              VelocityPoleRA      = 1,

                              AccelerationPoleRA  = 2,

                              PoleDec             = 3,

                              VelocityPoleDec     = 4,

                              AccelerationPoleDec = 5,

                              PM                  = 6,

                              VelocityPM          = 7,

                              AccelerationPM      = 8,

                              TriaxialRadiusA     = 9,

                              TriaxialRadiusB     = 10,

                              TriaxialRadiusC     = 11,

                              MeanRadius          = 12

                            };


      void setSolveSettings(std::set<int> targetParameterSolveCodes,

                            Angle aprioriPoleRA, Angle sigmaPoleRA, Angle aprioriVelocityPoleRA,

                            Angle sigmaVelocityPoleRA, Angle aprioriPoleDec, Angle sigmaPoleDec,

                            Angle aprioriVelocityPoleDec, Angle sigmaVelocityPoleDec,

                            Angle aprioriPM, Angle sigmaPM, Angle aprioriVelocityPM,

                            Angle sigmaVelocityPM, TargetRadiiSolveMethod solveRadiiMethod,

                            Distance aprioriRadiusA, Distance sigmaRadiusA, Distance aprioriRadiusB,

                            Distance sigmaRadiusB, Distance aprioriRadiusC, Distance sigmaRadiusC,

                            Distance aprioriMeanRadius, Distance sigmaMeanRadius);


      static TargetRadiiSolveMethod stringToTargetRadiiOption(QString option);

      static QString targetRadiiOptionToString(TargetRadiiSolveMethod targetRadiiSolveMethod);


      bool readFromPvl(PvlObject &tbPvlObject);


      // mutators

      //


      // accessors

      LinearAlgebra::Vector &parameterWeights();

      LinearAlgebra::Vector &parameterCorrections();

      LinearAlgebra::Vector &parameterSolution();

      LinearAlgebra::Vector &aprioriSigmas();

      LinearAlgebra::Vector &adjustedSigmas();


      std::vector<Angle> poleRaCoefs();

      std::vector<Angle> poleDecCoefs();

      std::vector<Angle> pmCoefs();


      std::vector<Distance> radii();

      Distance meanRadius();


      // string format methods

      QString formatBundleOutputString(bool errorPropagation);

      QStringList parameterList();

      // TODO implement

      QString formatValue(double value, int fieldWidth, int precision) const;

      QString formatAprioriSigmaString(int type, int fieldWidth, int precision) const;

      QString formatPolePositionAprioriSigmaString(int fieldWidth, int precision) const;

      QString formatW0AprioriSigmaString(int fieldWidth, int precision) const;

      QString formatWDotAprioriSigmaString(int fieldWidth, int precision) const;

      QString formatRadiusAprioriSigmaString(int fieldWidth, int precision) const;

      QString formatPolePositionAdjustedSigmaString(int fieldWidth, int precision) const;

      QString formatW0AdjustedSigmaString(int fieldWidth, int precision) const;

      QString formatWDotAdjustedSigmaString(int fieldWidth, int precision) const;

      QString formatRadiusAdjustedSigmaString(int fieldWidth, int precision) const;


      virtual bool solvePoleRA();

      virtual bool solvePoleRAVelocity();

      virtual bool solvePoleRAAcceleration();

      virtual bool solvePoleDec();

      virtual bool solvePoleDecVelocity();

      virtual bool solvePoleDecAcceleration();

      virtual bool solvePM();

      virtual bool solvePMVelocity();

      virtual bool solvePMAcceleration();

      virtual bool solveTriaxialRadii();

      virtual bool solveMeanRadius();


//      int numberPoleParameters();

//      int numberW0Parameters();

//      int numberWDotParameters();

      int numberRadiusParameters();

      virtual int numberParameters();


      void applyParameterCorrections(LinearAlgebra::Vector corrections);


      double vtpv();


      Distance localRadius(const Latitude &lat, const Longitude &lon);


    private:

      TargetRadiiSolveMethod m_solveTargetBodyRadiusMethod;

      Distance m_aprioriRadiusA;

      Distance m_sigmaRadiusA;

      Distance m_aprioriRadiusB;

      Distance m_sigmaRadiusB;

      Distance m_aprioriRadiusC;

      Distance m_sigmaRadiusC;

      Distance m_aprioriMeanRadius;

      Distance m_sigmaMeanRadius;


      std::vector<Distance> m_radii;

      Distance m_meanRadius;


      std::vector<Angle> m_raPole;

      std::vector<Angle> m_decPole;

      std::vector<Angle> m_pm ;


      std::set<int> m_parameterSolveCodes;

      QStringList m_parameterNamesList;


      LinearAlgebra::Vector m_weights;

      LinearAlgebra::Vector m_corrections;

      LinearAlgebra::Vector m_solution;

      LinearAlgebra::Vector m_aprioriSigmas;

      LinearAlgebra::Vector m_adjustedSigmas;

  };


  typedef QSharedPointer<BundleTargetBody> BundleTargetBodyQsp;

}


#endif // BundleTargetBody_h