.. _method-nlssol_sqp:

""""""""""
nlssol_sqp
""""""""""


Sequential Quadratic Program for nonlinear least squares



**Topics**


sequential_quadratic_programming, nonlinear_least_squares


.. toctree::
   :hidden:
   :maxdepth: 1

   method-nlssol_sqp-verify_level
   method-nlssol_sqp-function_precision
   method-nlssol_sqp-linesearch_tolerance
   method-nlssol_sqp-convergence_tolerance
   method-nlssol_sqp-max_iterations
   method-nlssol_sqp-constraint_tolerance
   method-nlssol_sqp-speculative
   method-nlssol_sqp-max_function_evaluations
   method-nlssol_sqp-scaling
   method-nlssol_sqp-model_pointer


**Specification**

- *Alias:* None

- *Arguments:* None


**Child Keywords:**

+-------------------------+--------------------+------------------------------+-----------------------------------------------+
| Required/Optional       | Description of     | Dakota Keyword               | Dakota Keyword Description                    |
|                         | Group              |                              |                                               |
+=========================+====================+==============================+===============================================+
| Optional                                     | `verify_level`__             | Verify the quality of analytic gradients      |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `function_precision`__       | Specify the maximum precision of the analysis |
|                                              |                              | code responses                                |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `linesearch_tolerance`__     | Choose how accurately the algorithm will      |
|                                              |                              | compute the minimum in a line search          |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `convergence_tolerance`__    | Stopping criterion based on objective         |
|                                              |                              | function convergence                          |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `max_iterations`__           | Number of iterations allowed for optimizers   |
|                                              |                              | and adaptive UQ methods                       |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `constraint_tolerance`__     | Maximum allowable constraint violation still  |
|                                              |                              | considered feasible                           |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `speculative`__              | Compute speculative gradients                 |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `max_function_evaluations`__ | Number of function evaluations allowed for    |
|                                              |                              | optimizers                                    |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `scaling`__                  | Turn on scaling for variables, responses, and |
|                                              |                              | constraints                                   |
+----------------------------------------------+------------------------------+-----------------------------------------------+
| Optional                                     | `model_pointer`__            | Identifier for model block to be used by a    |
|                                              |                              | method                                        |
+----------------------------------------------+------------------------------+-----------------------------------------------+

.. __: method-nlssol_sqp-verify_level.html
__ method-nlssol_sqp-function_precision.html
__ method-nlssol_sqp-linesearch_tolerance.html
__ method-nlssol_sqp-convergence_tolerance.html
__ method-nlssol_sqp-max_iterations.html
__ method-nlssol_sqp-constraint_tolerance.html
__ method-nlssol_sqp-speculative.html
__ method-nlssol_sqp-max_function_evaluations.html
__ method-nlssol_sqp-scaling.html
__ method-nlssol_sqp-model_pointer.html



**Description**


NLSSOL supports unconstrained, bound-constrained, and
generally-constrained least-squares calibration problems. It exploits
the structure of a least squares objective function through the
periodic use of Gauss-Newton Hessian approximations to accelerate the
SQP algorithm.

*NLSSOL requires a separate software license and therefore may not
be available in all versions of Dakota.  :dakkw:`method-nl2sol` or :dakkw:`method-optpp_g_newton` may be suitable alternatives.*


*Stopping Criteria*

The method independent controls for ``max_iterations`` and
``max_function_evaluations`` limit the number of major SQP iterations and
the number of function evaluations that can be performed during an
NPSOL optimization. The ``convergence_tolerance`` control defines
NPSOL's internal optimality tolerance which is used in evaluating if
an iterate satisfies the first-order Kuhn-Tucker conditions for a
minimum. The magnitude of ``convergence_tolerance`` approximately
specifies the number of significant digits of accuracy desired in the
final objective function (e.g., ``convergence_tolerance`` = ``1``.e-6
will result in approximately six digits of accuracy in the final
objective function). The ``constraint_tolerance`` control defines how
tightly the constraint functions are satisfied at convergence. The
default value is dependent upon the machine precision of the platform
in use, but is typically on the order of ``1``.e-8 for double precision
computations. Extremely small values for ``constraint_tolerance`` may
not be attainable.

*Expected HDF5 Output*

If Dakota was built with HDF5 support and run with the
:dakkw:`environment-results_output-hdf5` keyword, this method
writes the following results to HDF5:


- :ref:`hdf5_results-best_params`
- :ref:`hdf5_results-best_constraints`
- :ref:`hdf5_results-calibration` (when :dakkw:`responses-calibration_terms` are specified)
- :ref:`hdf5_results-lsq_confidence_intervals` (when :dakkw:`responses-calibration_terms-calibration_data-num_experiments` equals 1)


