BundleSettings.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "BundleSettings.h"
 
#include <QDataStream>
#include <QDebug>
#include <QList>
#include <QString>
#include <QtGlobal> // qMax()
#include <QUuid>
#include <QXmlStreamWriter>
#include <QXmlInputSource>
 
#include "BundleObservationSolveSettings.h"
#include "IException.h"
#include "IString.h"
#include "Project.h" // currently used for xml handler
#include "PvlKeyword.h"
#include "PvlObject.h"
#include "SpecialPixel.h"
 
namespace Isis {
 
  BundleSettings::BundleSettings() {
    init();
    BundleObservationSolveSettings defaultSolveSettings;
    m_observationSolveSettings.append(defaultSolveSettings);
  }
 
  void BundleSettings::init() {
    m_validateNetwork = true;
 
    m_solveObservationMode = false;
    m_solveRadius          = false;
    m_updateCubeLabel      = false;
    m_errorPropagation     = false;
    m_createInverseMatrix  = false;
    m_cubeList             =    "";
    m_outlierRejection     = false;
    m_outlierRejectionMultiplier = 3.0;
 
    // Parameter Uncertainties (Weighting)
    // The units are meters for either coordinate type
    m_globalPointCoord1AprioriSigma  = Isis::Null;
    m_globalPointCoord2AprioriSigma = Isis::Null;
    m_globalPointCoord3AprioriSigma    = Isis::Null;
 
    // Convergence Criteria
    m_convergenceCriteria = BundleSettings::Sigma0;
    m_convergenceCriteriaThreshold = 1.0e-10;
    m_convergenceCriteriaMaximumIterations = 50;
 
    // Maximum Likelihood Estimation Options no default in the constructor - must be set.
    m_maximumLikelihood.clear();
 
    // Self Calibration ??? (from ipce only)
 
    // Target Body
    m_solveTargetBody = false;
//    m_solveTargetBodyPolePosition = false;
//    m_solveTargetBodyZeroMeridian = false;
//    m_solveTargetBodyRotationRate = false;
//    m_solveTargetBodyRadiusMethod = None;
 
    // Control Points
    m_cpCoordTypeReports = SurfacePoint::Latitudinal;
    m_cpCoordTypeBundle = SurfacePoint::Latitudinal;
 
    // Output Options
    m_outputFilePrefix = "";
  }
 
 
  BundleSettings::BundleSettings(const BundleSettings &other)
      : m_validateNetwork(other.m_validateNetwork),
        m_cubeList(other.m_cubeList),
        m_solveObservationMode(other.m_solveObservationMode),
        m_solveRadius(other.m_solveRadius),
        m_updateCubeLabel(other.m_updateCubeLabel),
        m_errorPropagation(other.m_errorPropagation),
        m_createInverseMatrix(other.m_createInverseMatrix),
        m_outlierRejection(other.m_outlierRejection),
        m_outlierRejectionMultiplier(other.m_outlierRejectionMultiplier),
        m_globalPointCoord1AprioriSigma(other.m_globalPointCoord1AprioriSigma),
        m_globalPointCoord2AprioriSigma(other.m_globalPointCoord2AprioriSigma),
        m_globalPointCoord3AprioriSigma(other.m_globalPointCoord3AprioriSigma),
        m_observationSolveSettings(other.m_observationSolveSettings),
        m_convergenceCriteria(other.m_convergenceCriteria),
        m_convergenceCriteriaThreshold(other.m_convergenceCriteriaThreshold),
        m_convergenceCriteriaMaximumIterations(other.m_convergenceCriteriaMaximumIterations),
        m_maximumLikelihood(other.m_maximumLikelihood),
        m_solveTargetBody(other.m_solveTargetBody),
        m_bundleTargetBody(other.m_bundleTargetBody),
        m_cpCoordTypeReports(other.m_cpCoordTypeReports),
        m_cpCoordTypeBundle(other.m_cpCoordTypeBundle),
        m_outputFilePrefix(other.m_outputFilePrefix){
  }
 
 
  BundleSettings::~BundleSettings() {
  }
 
 
  BundleSettings &BundleSettings::operator=(const BundleSettings &other) {
    if (&other != this) {
      m_validateNetwork = other.m_validateNetwork;
      m_cubeList = other.m_cubeList;
      m_solveObservationMode = other.m_solveObservationMode;
      m_solveRadius = other.m_solveRadius;
      m_updateCubeLabel = other.m_updateCubeLabel;
      m_errorPropagation = other.m_errorPropagation;
      m_createInverseMatrix = other.m_createInverseMatrix;
      m_outlierRejection = other.m_outlierRejection;
      m_outlierRejectionMultiplier = other.m_outlierRejectionMultiplier;
      m_globalPointCoord1AprioriSigma = other.m_globalPointCoord1AprioriSigma;
      m_globalPointCoord2AprioriSigma = other.m_globalPointCoord2AprioriSigma;
      m_globalPointCoord3AprioriSigma = other.m_globalPointCoord3AprioriSigma;
      m_observationSolveSettings = other.m_observationSolveSettings;
      m_convergenceCriteria = other.m_convergenceCriteria;
      m_convergenceCriteriaThreshold = other.m_convergenceCriteriaThreshold;
      m_convergenceCriteriaMaximumIterations = other.m_convergenceCriteriaMaximumIterations;
      m_solveTargetBody = other.m_solveTargetBody;
      m_bundleTargetBody = other.m_bundleTargetBody;
      m_cpCoordTypeReports = other.m_cpCoordTypeReports;
      m_cpCoordTypeBundle = other.m_cpCoordTypeBundle;
      m_maximumLikelihood = other.m_maximumLikelihood;
      m_outputFilePrefix = other.m_outputFilePrefix;
    }
    return *this;
  }
 
 
  void BundleSettings::setValidateNetwork(bool validate) {
    m_validateNetwork = validate;
  }
 
 
  bool BundleSettings::validateNetwork() const {
    return m_validateNetwork;
  }
 
 
  void BundleSettings::setCubeList(QString cubeList)    {
    m_cubeList = cubeList;
  }
 
 
  QString BundleSettings::cubeList() const {
    return m_cubeList;
  }
 
 
  // =============================================================================================//
  // ======================== Solve Options ======================================================//
  // =============================================================================================//
 
  void BundleSettings::setSolveOptions(bool solveObservationMode,
                                       bool updateCubeLabel,
                                       bool errorPropagation,
                                       bool solveRadius,
                                       SurfacePoint::CoordinateType coordTypeBundle,
                                       SurfacePoint::CoordinateType coordTypeReports,
                                       double globalPointCoord1AprioriSigma,
                                       double globalPointCoord2AprioriSigma,
                                       double globalPointCoord3AprioriSigma) {
    m_solveObservationMode = solveObservationMode;
    m_solveRadius = solveRadius;
    m_updateCubeLabel = updateCubeLabel;
    m_errorPropagation = errorPropagation;
    m_cpCoordTypeReports = coordTypeReports;
    m_cpCoordTypeBundle = coordTypeBundle;
    // m_cpCoordTypeBundle = SurfacePoint::Latitudinal;
 
    if (globalPointCoord1AprioriSigma > 0.0) { // otherwise, we leave as default Isis::Null
      m_globalPointCoord1AprioriSigma = globalPointCoord1AprioriSigma;
    }
    else {
      m_globalPointCoord1AprioriSigma = Isis::Null;
    }
 
    if (globalPointCoord2AprioriSigma > 0.0) {
      m_globalPointCoord2AprioriSigma = globalPointCoord2AprioriSigma;
    }
    else {
      m_globalPointCoord2AprioriSigma = Isis::Null;
    }
 
    // This is ugly.  *** TODO *** Revisit this section to try to find a cleaner solution.
    // I think we will have to do similar checking other places.
    // See pvlObject, save,   (DAC 03-29-2017)
    if (coordTypeBundle == SurfacePoint::Latitudinal) {
      if (m_solveRadius && globalPointCoord3AprioriSigma > 0.0) {
        m_globalPointCoord3AprioriSigma = globalPointCoord3AprioriSigma;
      }
      else {
      m_globalPointCoord3AprioriSigma = Isis::Null;
      }
    }
    else if (coordTypeBundle == SurfacePoint::Rectangular) {
      if (globalPointCoord3AprioriSigma > 0.0) {
        m_globalPointCoord3AprioriSigma = globalPointCoord3AprioriSigma;
      }
      else {
      m_globalPointCoord3AprioriSigma = Isis::Null;
      }
    }
  }
 
 
  void BundleSettings::setOutlierRejection(bool outlierRejection, double multiplier) {
    m_outlierRejection = outlierRejection;
    if (m_outlierRejection) {
      m_outlierRejectionMultiplier = multiplier;
    }
    else {
      m_outlierRejectionMultiplier = 3.0;
    }
  }
 
 
  void BundleSettings::setObservationSolveOptions(
      QList<BundleObservationSolveSettings> obsSolveSettingsList) {
    m_observationSolveSettings = obsSolveSettingsList;
  }
 
 
  SurfacePoint::CoordinateType BundleSettings::controlPointCoordTypeReports() const {
    return (m_cpCoordTypeReports);
  }
 
 
  SurfacePoint::CoordinateType BundleSettings::controlPointCoordTypeBundle() const {
    return (m_cpCoordTypeBundle);
  }
 
 
  bool BundleSettings::createInverseMatrix() const {
    return (m_errorPropagation && m_createInverseMatrix);
  }
 
 
  bool BundleSettings::outlierRejection() const {
    return m_outlierRejection;
  }
 
 
  bool BundleSettings::solveObservationMode() const {
    return m_solveObservationMode;
  }
 
 
  bool BundleSettings::solveRadius() const {
    return m_solveRadius;
  }
 
 
  bool BundleSettings::updateCubeLabel() const {
    return m_updateCubeLabel;
  }
 
 
  bool BundleSettings::errorPropagation() const {
    return m_errorPropagation;
  }
 
 
  void BundleSettings::setCreateInverseMatrix(bool createMatrixFile) {
    m_createInverseMatrix = createMatrixFile;
  }
 
 
  double BundleSettings::outlierRejectionMultiplier() const {
    return m_outlierRejectionMultiplier;
  }
 
 
  double BundleSettings::globalPointCoord1AprioriSigma() const {
    return m_globalPointCoord1AprioriSigma;
  }
 
 
  double BundleSettings::globalPointCoord2AprioriSigma() const {
    return m_globalPointCoord2AprioriSigma;
  }
 
 
  double BundleSettings::globalPointCoord3AprioriSigma() const {
    return m_globalPointCoord3AprioriSigma;
  }
 
 
  int BundleSettings::numberSolveSettings() const {
     return m_observationSolveSettings.size();
  }
 
 
  BundleObservationSolveSettings
      BundleSettings::observationSolveSettings(QString observationNumber) const {
 
    BundleObservationSolveSettings defaultSolveSettings;
 
    for (int i = 0; i < numberSolveSettings(); i++) {
      if (m_observationSolveSettings[i].observationNumbers().contains(observationNumber)) {
        return m_observationSolveSettings[i];
      }
    }
    return defaultSolveSettings;
  }
 
 
  BundleObservationSolveSettings
      BundleSettings::observationSolveSettings(int n) const {
 
    if (n >= 0 && n < numberSolveSettings()) {
      return m_observationSolveSettings[n];
    }
    QString msg = "Unable to find BundleObservationSolveSettings with index = ["
                  + toString(n) + "].";
    throw IException(IException::Unknown, msg, _FILEINFO_);
  }
 
 
  QList<BundleObservationSolveSettings> BundleSettings::observationSolveSettings() const {
    return m_observationSolveSettings;
  }
 
 
  // =============================================================================================//
  // ======================== Convergence Criteria ===============================================//
  // =============================================================================================//
 
  BundleSettings::ConvergenceCriteria
      BundleSettings::stringToConvergenceCriteria(QString criteria) {
    if (criteria.compare("SIGMA0", Qt::CaseInsensitive) == 0) {
      return BundleSettings::Sigma0;
    }
    else if (criteria.compare("PARAMETERCORRECTIONS", Qt::CaseInsensitive) == 0) {
      return BundleSettings::ParameterCorrections;
    }
    else throw IException(IException::Programmer,
                          "Unknown bundle convergence criteria [" + criteria + "].",
                          _FILEINFO_);
  }
 
 
  QString BundleSettings::convergenceCriteriaToString(
              BundleSettings::ConvergenceCriteria criteria) {
    if (criteria == Sigma0)                    return "Sigma0";
    else if (criteria == ParameterCorrections) return "ParameterCorrections";
    else  throw IException(IException::Programmer,
                           "Unknown convergence criteria enum [" + toString(criteria) + "].",
                           _FILEINFO_);
  }
 
 
  void BundleSettings::setConvergenceCriteria(BundleSettings::ConvergenceCriteria criteria,
                                              double threshold,
                                              int maximumIterations) {
    m_convergenceCriteria = criteria;
    m_convergenceCriteriaThreshold = threshold;
    m_convergenceCriteriaMaximumIterations = maximumIterations;
  }
 
 
  BundleSettings::ConvergenceCriteria BundleSettings::convergenceCriteria() const {
    return m_convergenceCriteria;
  }
 
 
  double BundleSettings::convergenceCriteriaThreshold() const {
    return m_convergenceCriteriaThreshold;
  }
 
 
  int BundleSettings::convergenceCriteriaMaximumIterations() const {
    return m_convergenceCriteriaMaximumIterations;
  }
 
 
 
  // =============================================================================================//
  // ======================== Parameter Uncertainties (Weighting) ================================//
  // =============================================================================================//
//   void BundleSettings::setGlobalLatitudeAprioriSigma(double sigma) {
//     m_globalLatitudeAprioriSigma = sigma;
//   }
//
//
//
//   void BundleSettings::setGlobalLongitudeAprioriSigma(double sigma) {
//     m_globalLongitudeAprioriSigma = sigma;
//   }
//
//
//
//   void BundleSettings::setGlobalRadiiAprioriSigma(double sigma) {
//     m_globalRadiusAprioriSigma = sigma;
//   }
 
 
  // =============================================================================================//
  // ======================== Maximum Likelihood Estimation Options ==============================//
  // =============================================================================================//
 
 
  void BundleSettings::addMaximumLikelihoodEstimatorModel(MaximumLikelihoodWFunctions::Model model,
                                                          double maxModelCQuantile) {
 
    if (m_maximumLikelihood.size() == 0 && model > MaximumLikelihoodWFunctions::HuberModified) {
      QString msg = "For bundle adjustments with multiple maximum likelihood estimators, the first "
                    "model must be of type HUBER or HUBER_MODIFIED.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    m_maximumLikelihood.append(qMakePair(model, maxModelCQuantile));
  }
 
 
  QList< QPair< MaximumLikelihoodWFunctions::Model, double > >
      BundleSettings::maximumLikelihoodEstimatorModels() const {
    return m_maximumLikelihood;
  }
 
 
  // =============================================================================================//
  // ======================== Self Calibration ??? (from ipce only) =========================//
  // =============================================================================================//
 
  // =============================================================================================//
  // ======================== Target Body ??? (from ipce only) ==============================//
  // =============================================================================================//
 
  void BundleSettings::setBundleTargetBody(BundleTargetBodyQsp bundleTargetBody) {
    m_bundleTargetBody = bundleTargetBody;
  }
 
 
  BundleTargetBodyQsp BundleSettings::bundleTargetBody() const {
    return m_bundleTargetBody;
  }
 
 
//  bool BundleSettings::solveTargetBodyPolePosition() const {
//    return m_solveTargetBodyPolePosition;
//  }
 
 
  int BundleSettings::numberTargetBodyParameters() const {
    if (!m_bundleTargetBody)
      return 0;
 
    return m_bundleTargetBody->numberParameters();
  }
 
 
  bool BundleSettings::solveTargetBody() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    else {
      return (m_bundleTargetBody->numberParameters() > 0);
    }
  }
 
 
  bool BundleSettings::solvePoleRA() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleRA();
  }
 
 
  bool BundleSettings::solvePoleRAVelocity() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleRAVelocity();
  }
 
 
  bool BundleSettings::solvePoleDec() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleDec();
  }
 
 
  bool BundleSettings::solvePoleDecVelocity() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleDecVelocity();
  }
 
 
  bool BundleSettings::solvePM() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePM();
  }
 
 
  bool BundleSettings::solvePMVelocity() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePMVelocity();
  }
 
 
  bool BundleSettings::solvePMAcceleration() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePMAcceleration();
  }
 
 
  bool BundleSettings::solveTriaxialRadii() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solveTriaxialRadii();
  }
 
 
  bool BundleSettings::solveMeanRadius() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solveMeanRadius();
  }
 
 
//  void BundleSettings::setTargetBodySolveOptions(bool solveTargetBodyPolePosition,
//                                                 double aprioriRaPole, double sigmaRaPole,
//                                                 double aprioriDecPole, double sigmaDecPole,
//                                                 bool solveTargetBodyZeroMeridian,
//                                                 double aprioriW0, double sigmaW0,
//                                                 bool solveTargetBodyRotationRate,
//                                                 double aprioriWDot, double sigmaWDot,
//                                                 TargetRadiiSolveMethod solveRadiiMethod,
//                                                 double aprioriRadiusA, double sigmaRadiusA,
//                                                 double aprioriRadiusB, double sigmaRadiusB,
//                                                 double aprioriRadiusC, double sigmaRadiusC,
//                                                 double aprioriMeanRadius, double sigmaMeanRadius) {
 
 
//    m_solveTargetBody = true;
//    m_solveTargetBodyPolePosition = solveTargetBodyPolePosition;
//    m_aprioriRaPole = aprioriRaPole;
//    m_sigmaRaPole = sigmaRaPole;
//    m_aprioriDecPole = aprioriDecPole;
//    m_sigmaDecPole = sigmaDecPole;
//    m_solveTargetBodyZeroMeridian =solveTargetBodyZeroMeridian;
//    m_aprioriW0 = aprioriW0;
//    m_sigmaW0 = sigmaW0;
//    m_solveTargetBodyRotationRate = solveTargetBodyRotationRate;
//    m_aprioriWDot = aprioriWDot;
//    m_sigmaWDot = sigmaWDot;
//    m_solveTargetBodyRadiusMethod = solveRadiiMethod;
//    m_aprioriRadiusA = aprioriRadiusA;
//    m_sigmaRadiusA = sigmaRadiusA;
//    m_aprioriRadiusB = aprioriRadiusB;
//    m_sigmaRadiusB = sigmaRadiusB;
//    m_aprioriRadiusC = aprioriRadiusC;
//    m_sigmaRadiusC = sigmaRadiusC;
//    m_aprioriMeanRadius = aprioriMeanRadius;
//    m_sigmaMeanRadius = sigmaMeanRadius;
 
//    m_bundleTargetBody->setSolveSettings(solveTargetBodyPolePosition, aprioriRaPole, sigmaRaPole,
//                                         aprioriDecPole, sigmaDecPole, solveTargetBodyZeroMeridian,
//                                         aprioriW0, sigmaW0, solveTargetBodyRotationRate,
//                                         aprioriWDot, sigmaWDot, solveRadiiMethod, aprioriRadiusA,
//                                         sigmaRadiusA, aprioriRadiusB, sigmaRadiusB, aprioriRadiusC,
//                                         sigmaRadiusC, aprioriMeanRadius, sigmaMeanRadius);
//  }
 
 
  // =============================================================================================//
  // ========================= Output Options (from Jigsaw only) ================================//
  // =============================================================================================//
  void BundleSettings::setOutputFilePrefix(QString outputFilePrefix) {
    m_outputFilePrefix = outputFilePrefix;
  }
 
 
  QString BundleSettings::outputFilePrefix() const {
    return m_outputFilePrefix;
  }
 
 
  void BundleSettings::save(QXmlStreamWriter &stream, const Project *project) const {
    stream.writeStartElement("bundleSettings");
 
    stream.writeStartElement("globalSettings");
 
    stream.writeTextElement("validateNetwork", toString(validateNetwork()));
 
    stream.writeStartElement("solveOptions");
    stream.writeAttribute("solveObservationMode", toString(solveObservationMode()));
    stream.writeAttribute("solveRadius", toString(solveRadius()));
    stream.writeAttribute("controlPointCoordTypeReports", toString(controlPointCoordTypeReports()));
    stream.writeAttribute("controlPointCoordTypeBundle", toString(controlPointCoordTypeBundle()));
    stream.writeAttribute("updateCubeLabel", toString(updateCubeLabel()));
    stream.writeAttribute("errorPropagation", toString(errorPropagation()));
    stream.writeAttribute("createInverseMatrix", toString(createInverseMatrix()));
    stream.writeEndElement();
 
    stream.writeStartElement("aprioriSigmas");
    if (IsSpecial(globalPointCoord1AprioriSigma())) {
      stream.writeAttribute("pointCoord1", "N/A");
    }
    else {
      stream.writeAttribute("pointCoord1", toString(globalPointCoord1AprioriSigma()));
    }
    if (IsSpecial(globalPointCoord2AprioriSigma())) {
      stream.writeAttribute("pointCoord2", "N/A");
    }
    else {
      stream.writeAttribute("pointCoord2", toString(globalPointCoord2AprioriSigma()));
    }
    if (IsSpecial(globalPointCoord3AprioriSigma())) {
      stream.writeAttribute("pointCoord3", "N/A");
    }
    else {
      stream.writeAttribute("pointCoord3", toString(globalPointCoord3AprioriSigma()));
    }
    stream.writeEndElement();
 
    stream.writeStartElement("outlierRejectionOptions");
    stream.writeAttribute("rejection", toString(outlierRejection()));
    if (outlierRejection()) {
      stream.writeAttribute("multiplier", toString(outlierRejectionMultiplier()));
    }
    else {
      stream.writeAttribute("multiplier", "N/A");
    }
    stream.writeEndElement();
 
    stream.writeStartElement("convergenceCriteriaOptions");
    stream.writeAttribute("convergenceCriteria",
                          convergenceCriteriaToString(convergenceCriteria()));
    stream.writeAttribute("threshold",
                          toString(convergenceCriteriaThreshold()));
    stream.writeAttribute("maximumIterations",
                          toString(convergenceCriteriaMaximumIterations()));
    stream.writeEndElement();
 
    stream.writeStartElement("maximumLikelihoodEstimation");
    for (int i = 0; i < m_maximumLikelihood.size(); i++) {
      stream.writeStartElement("model");
      stream.writeAttribute("type",
                          MaximumLikelihoodWFunctions::modelToString(m_maximumLikelihood[i].first));
      stream.writeAttribute("quantile", toString(m_maximumLikelihood[i].second));
      stream.writeEndElement();
    }
    stream.writeEndElement();
 
    stream.writeStartElement("outputFileOptions");
    stream.writeAttribute("fileNamePrefix", outputFilePrefix());
    stream.writeEndElement();
 
    stream.writeEndElement(); // end global settings
 
    if (!m_observationSolveSettings.isEmpty()) {
      stream.writeStartElement("observationSolveSettingsList");
      for (int i = 0; i < m_observationSolveSettings.size(); i++) {
        m_observationSolveSettings[i].save(stream, project);
      }
      stream.writeEndElement();
    }
    else {
      // throw error??? should not write if no observation settings...
    }
    stream.writeEndElement();
  }
 
  void BundleSettings::readBundleSettings(QXmlStreamReader *xmlReader) {
    init();
    Q_ASSERT(xmlReader->name() == "bundleSettings");
    while (xmlReader->readNextStartElement()) {
      if (xmlReader->qualifiedName() == "globalSettings") {
        while (xmlReader->readNextStartElement()) {
          if (xmlReader->qualifiedName() == "validateNetwork") {
            QString validateNetwork = xmlReader->readElementText();
            if (!validateNetwork.isEmpty()) {
              m_validateNetwork = toBool(validateNetwork);
            }       
          }
          else if (xmlReader->qualifiedName() == "solveOptions") {
            QStringRef solveObservationMode = xmlReader->attributes().value("solveObservationMode");
            if (!solveObservationMode.isEmpty()) {
              m_solveObservationMode = toBool(solveObservationMode.toString());
            }
            QStringRef solveRadius = xmlReader->attributes().value("solveRadius");
            if (!solveRadius.isEmpty()) {
              m_solveRadius = toBool(solveRadius.toString());
            }
            QStringRef controlPointCoordTypeReports = xmlReader->attributes().value("controlPointCoordTypeReports");
            if (!controlPointCoordTypeReports.isEmpty()) {
              if (controlPointCoordTypeReports == "0") {
                m_cpCoordTypeReports = SurfacePoint::Latitudinal;
              }
              else if (controlPointCoordTypeReports == "1") {
                m_cpCoordTypeReports = SurfacePoint::Rectangular;
              }           
            }
            QStringRef controlPointCoordTypeBundle = xmlReader->attributes().value("controlPointCoordTypeBundle");
            if (!controlPointCoordTypeBundle.isEmpty()) {
              if (controlPointCoordTypeBundle == "0") {
                m_cpCoordTypeBundle = SurfacePoint::Latitudinal;
              }
              else if (controlPointCoordTypeBundle == "1") {
                m_cpCoordTypeBundle = SurfacePoint::Rectangular;
              }   
            }
            QStringRef updateCubeLabel = xmlReader->attributes().value("updateCubeLabel");
            if (!updateCubeLabel.isEmpty()) {
              m_updateCubeLabel = toBool(updateCubeLabel.toString());
            }
            QStringRef errorPropagation = xmlReader->attributes().value("errorPropagation");
            if (!errorPropagation.isEmpty()) {
              m_errorPropagation = toBool(errorPropagation.toString());
            }
            QStringRef createInverseMatrix = xmlReader->attributes().value("createInverseMatrix");
            if (!createInverseMatrix.isEmpty()) {
              m_createInverseMatrix = toBool(createInverseMatrix.toString());
            }
            xmlReader->skipCurrentElement();
          }
          else if (xmlReader->qualifiedName() == "aprioriSigmas") {
            QStringRef globalPointCoord1AprioriSigma = xmlReader->attributes().value("pointCoord1");
            if (!globalPointCoord1AprioriSigma.isEmpty()) {
              if (globalPointCoord1AprioriSigma == "N/A") {
                m_globalPointCoord1AprioriSigma = Isis::Null;
              }
              else {
                m_globalPointCoord1AprioriSigma = globalPointCoord1AprioriSigma.toDouble();
              }
            }
            QStringRef globalPointCoord2AprioriSigma = xmlReader->attributes().value("pointCoord2");
            if (!globalPointCoord2AprioriSigma.isEmpty()) {
              if (globalPointCoord2AprioriSigma == "N/A") {
                m_globalPointCoord2AprioriSigma = Isis::Null;
              }
              else {
                m_globalPointCoord2AprioriSigma = globalPointCoord2AprioriSigma.toDouble();
              }
            }
            QStringRef globalPointCoord3AprioriSigma = xmlReader->attributes().value("radius");
            if (!globalPointCoord3AprioriSigma.isEmpty()) {
              if (globalPointCoord3AprioriSigma == "N/A") {
                m_globalPointCoord3AprioriSigma = Isis::Null;
              }
              else {
                m_globalPointCoord3AprioriSigma = globalPointCoord3AprioriSigma.toDouble();
              }
            }
            xmlReader->skipCurrentElement();
          }
          else if (xmlReader->qualifiedName() == "outlierRejectionOptions") {
            QStringRef outlierRejection = xmlReader->attributes().value("rejection");
            if (!outlierRejection.isEmpty()) {
              m_outlierRejection = toBool(outlierRejection.toString());
            }
            QStringRef outlierRejectionMultiplier = xmlReader->attributes().value("multiplier");
            if (!outlierRejectionMultiplier.isEmpty()) {
              if (outlierRejectionMultiplier != "N/A") {
                m_outlierRejectionMultiplier = outlierRejectionMultiplier.toDouble();
              }
              else {
                m_outlierRejectionMultiplier = 3.0;
              }
            }
            xmlReader->skipCurrentElement();
          }
          else if (xmlReader->qualifiedName() == "convergenceCriteriaOptions") {
            QStringRef convergenceCriteria = xmlReader->attributes().value("convergenceCriteria");
            if (!convergenceCriteria.isEmpty()) {
              m_convergenceCriteria = stringToConvergenceCriteria(convergenceCriteria.toString());
            }
            QStringRef threshold = xmlReader->attributes().value("threshold");
            if (!threshold.isEmpty()) {
              m_convergenceCriteriaThreshold = threshold.toDouble();
            }
            QStringRef maximumIterations = xmlReader->attributes().value("maximumIterations");
            if (!maximumIterations.isEmpty()) {
              m_convergenceCriteriaMaximumIterations = maximumIterations.toInt();
            }
            xmlReader->skipCurrentElement();
          }
          else if (xmlReader->qualifiedName() == "maximumLikelihoodEstimation") {
            while (xmlReader->readNextStartElement()) {
              if (xmlReader->qualifiedName() == "model") {
                QStringRef type = xmlReader->attributes().value("type");
                QStringRef quantile = xmlReader->attributes().value("quantile");
                if (!type.isEmpty() && !quantile.isEmpty()) {
                  m_maximumLikelihood.append(qMakePair(MaximumLikelihoodWFunctions::stringToModel(type.toString()), quantile.toDouble()));
                }
                xmlReader->skipCurrentElement();
              }
              else {
                xmlReader->skipCurrentElement();
              }
            }
          }
          else if (xmlReader->qualifiedName() == "outputFileOptions") {
            QStringRef fileNamePrefix = xmlReader->attributes().value("fileNamePrefix");
            if (!fileNamePrefix.isEmpty()) {
              m_outputFilePrefix = fileNamePrefix.toString();
            }
            xmlReader->skipCurrentElement();
          }
          else {
            xmlReader->skipCurrentElement();
          }
        }
      }
      else if (xmlReader->qualifiedName() == "observationSolveSettingsList") {
        m_observationSolveSettings.clear();
        while (xmlReader->readNextStartElement()) {
          if (xmlReader->qualifiedName() == "bundleObservationSolveSettings") {
            BundleObservationSolveSettings *settings = new BundleObservationSolveSettings(xmlReader);
            m_observationSolveSettings.append(*settings);
          }
          else {
            xmlReader->skipCurrentElement();
          }
        }
      }
      else {
        xmlReader->skipCurrentElement();
      }
    }
  }
}